ooo-build r11853 - in trunk: . patches/vba

From: jiaojh svn gnome org
To: svn-commits-list gnome org
Subject: ooo-build r11853 - in trunk: . patches/vba
Date: Mon, 10 Mar 2008 07:46:03 +0000 (GMT)
Author: jiaojh
Date: Mon Mar 10 07:46:02 2008
New Revision: 11853
URL: http://svn.gnome.org/viewvc/ooo-build?rev=11853&view=rev

Log:
update patches/vba/vba-interior.diff with "UserDefinedAttributes"


Modified:
   trunk/ChangeLog
   trunk/patches/vba/vba-interior.diff

Modified: trunk/patches/vba/vba-interior.diff
==============================================================================
--- trunk/patches/vba/vba-interior.diff	(original)
+++ trunk/patches/vba/vba-interior.diff	Mon Mar 10 07:46:02 2008
@@ -11,8 +11,32 @@
  
  //=============================================================================
 --- sc/source/ui/vba/vbainterior.hxx.orig	2008-02-29 16:48:30.000000000 +0800
-+++ sc/source/ui/vba/vbainterior.hxx	2008-02-29 17:19:05.000000000 +0800
-@@ -64,6 +64,12 @@ public:
++++ sc/source/ui/vba/vbainterior.hxx	2008-03-10 14:52:16.000000000 +0800
+@@ -51,8 +51,23 @@ class ScVbaInterior :  public ScVbaInter
+ {
+ 	css::uno::Reference< css::beans::XPropertySet > m_xProps;
+ 	ScDocument* m_pScDoc;
++    Color m_aPattColor;
++    sal_Int32 m_nPattern; 
+ 
+         css::uno::Reference< css::container::XIndexAccess > getPalette(); 
++    css::uno::Reference< css::container::XNameContainer > GetAttributeContainer();
++    css::uno::Any SetAttributeData( sal_Int32 nValue );
++    sal_Int32 GetAttributeData( css::uno::Any aValue );
++    Color GetBackColor();
++protected:
++    Color GetPatternColor( const Color& rPattColor, const Color& rBackColor, sal_uInt32 nXclPattern );
++    Color GetMixedColor( const Color& rFore, const Color& rBack, sal_uInt8 nTrans );
++    sal_uInt8 GetMixedColorComp( sal_uInt8 nFore, sal_uInt8 nBack, sal_uInt8 nTrans );
++    css::uno::Any GetIndexColor( const sal_Int32& nColorIndex );
++    sal_Int32 GetColorIndex( const sal_Int32 nColor );
++    css::uno::Any GetUserDefinedAttributes( const rtl::OUString& sName );
++    void SetUserDefinedAttributes( const rtl::OUString& sName, const css::uno::Any& aValue );
++    void SetMixedColor();
+ public:
+         ScVbaInterior( const css::uno::Reference< oo::vba::XHelperInterface >& xParent,  const css::uno::Reference< css::uno::XComponentContext >& xContext,
+                  const css::uno::Reference< css::beans::XPropertySet >& xProps, ScDocument* pScDoc = NULL) throw ( css::lang::IllegalArgumentException);
+@@ -64,6 +79,12 @@ public:
  
  	virtual css::uno::Any SAL_CALL getColorIndex() throw ( css::uno::RuntimeException);
  	virtual void SAL_CALL setColorIndex( const css::uno::Any& _colorindex ) throw ( css::uno::RuntimeException );
@@ -26,56 +50,359 @@
  	virtual rtl::OUString& getServiceImplName();
  	virtual css::uno::Sequence<rtl::OUString> getServiceNames();
 --- sc/source/ui/vba/vbainterior.cxx.orig	2008-02-29 16:48:30.000000000 +0800
-+++ sc/source/ui/vba/vbainterior.cxx	2008-03-03 17:44:05.000000000 +0800
-@@ -41,6 +41,7 @@
++++ sc/source/ui/vba/vbainterior.cxx	2008-03-10 15:29:14.000000000 +0800
+@@ -39,8 +39,11 @@
+ #include <com/sun/star/beans/XIntrospectionAccess.hpp>
+ #include <com/sun/star/reflection/XIdlMethod.hpp>
  #include <com/sun/star/beans/MethodConcept.hpp>
++#include <com/sun/star/beans/NamedValue.hpp>
++#include <com/sun/star/xml/AttributeData.hpp>
  
  #include <org/openoffice/excel/XlColorIndex.hpp>
 +#include <org/openoffice/excel/XlPattern.hpp>
  
  #include <comphelper/processfactory.hxx>
  #include <cppuhelper/queryinterface.hxx>
-@@ -125,6 +126,43 @@ ScVbaInterior::getColorIndex() throw ( c
- 	}     
- 	return uno::makeAny( nIndex );
+@@ -49,12 +52,53 @@
+ 
+ #include "vbainterior.hxx"
+ #include "vbapalette.hxx"
++
++#define STATIC_TABLE_SIZE( array )  (sizeof(array)/sizeof(*(array)))
++#define COLORMAST 0xFFFFFF
++const sal_uInt16 EXC_COLOR_WINDOWBACK = 65;
++typedef std::map< sal_Int32, sal_Int32 >  PatternMap;
++typedef std::pair< sal_Int32, sal_Int32 > PatternPair;
+ using namespace ::com::sun::star;
+ using namespace ::org::openoffice;
++using namespace ::org::openoffice::excel::XlPattern;
+ static const rtl::OUString BACKCOLOR( RTL_CONSTASCII_USTRINGPARAM( "CellBackColor" ) );
++static const rtl::OUString PATTERN( RTL_CONSTASCII_USTRINGPARAM( "Pattern" ) );
++static const rtl::OUString PATTERNCOLOR( RTL_CONSTASCII_USTRINGPARAM( "PatternColor" ) );
++
++PatternMap lcl_getPatternMap()
++{
++    PatternMap aPatternMap;
++    aPatternMap.insert( PatternPair( xlPatternAutomatic, 0 ) );
++    aPatternMap.insert( PatternPair( xlPatternChecker, 9 ) );
++    aPatternMap.insert( PatternPair( xlPatternCrissCross, 16 ) );
++    aPatternMap.insert( PatternPair( xlPatternDown, 7 ) );
++    aPatternMap.insert( PatternPair( xlPatternGray16, 17 ) );
++    aPatternMap.insert( PatternPair( xlPatternGray25, 4 ) );
++    aPatternMap.insert( PatternPair( xlPatternGray50, 2 ) );
++    aPatternMap.insert( PatternPair( xlPatternGray75, 3 ) );
++    aPatternMap.insert( PatternPair( xlPatternGray8, 18 ) );
++    aPatternMap.insert( PatternPair( xlPatternGrid, 15 ) );
++    aPatternMap.insert( PatternPair( xlPatternHorizontal, 5 ) );
++    aPatternMap.insert( PatternPair( xlPatternLightDown, 13 ) );
++    aPatternMap.insert( PatternPair( xlPatternLightHorizontal, 11 ) );
++    aPatternMap.insert( PatternPair( xlPatternLightUp, 14 ) );
++    aPatternMap.insert( PatternPair( xlPatternLightVertical, 12 ) );
++    aPatternMap.insert( PatternPair( xlPatternNone, 0 ) );
++    aPatternMap.insert( PatternPair( xlPatternSemiGray75, 10 ) );
++    aPatternMap.insert( PatternPair( xlPatternSolid, 0 ) );
++    aPatternMap.insert( PatternPair( xlPatternUp, 8 ) );
++    aPatternMap.insert( PatternPair( xlPatternVertical, 6 ) );
++    return aPatternMap;
++}
++
++static PatternMap aPatternMap( lcl_getPatternMap() );
+ 
+-ScVbaInterior::ScVbaInterior( const uno::Reference< vba::XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< beans::XPropertySet >&  xProps, ScDocument* pScDoc ) throw ( lang::IllegalArgumentException) : ScVbaInterior_BASE( xParent, xContext ), m_xProps(xProps), m_pScDoc( pScDoc )
++ScVbaInterior::ScVbaInterior( const uno::Reference< vba::XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< beans::XPropertySet >&  xProps, ScDocument* pScDoc ) throw ( lang::IllegalArgumentException) : ScVbaInterior_BASE( xParent, xContext ), m_xProps(xProps), m_pScDoc( pScDoc ) 
+ {
++    // auto color
++    //m_aPattColor.SetColor( (sal_uInt32)0xFFFFFFFF );
++    m_aPattColor.SetColor( (sal_uInt32)0x0 );
++    m_nPattern = 0L;
+ 	if ( !m_xProps.is() )
+ 		throw lang::IllegalArgumentException( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "properties") ), uno::Reference< uno::XInterface >(), 2 ); 
  }
+@@ -62,15 +106,50 @@ ScVbaInterior::ScVbaInterior( const uno:
+ uno::Any
+ ScVbaInterior::getColor() throw (uno::RuntimeException) 
+ {
+-	uno::Any aAny;
+-	aAny = OORGBToXLRGB( m_xProps->getPropertyValue( BACKCOLOR ) );
+-	return aAny;
++    Color aBackColor( GetBackColor() );
++	return uno::makeAny( OORGBToXLRGB( aBackColor.GetColor() ) );
+ }
+  
+ void 
+ ScVbaInterior::setColor( const uno::Any& _color  ) throw (uno::RuntimeException)
+ {
+-	m_xProps->setPropertyValue( BACKCOLOR , XLRGBToOORGB(_color));
++    sal_Int32 nColor;
++    if( _color >>= nColor )
++    {
++        SetUserDefinedAttributes( BACKCOLOR, SetAttributeData( XLRGBToOORGB( nColor ) ) );
++	    //m_xProps->setPropertyValue( BACKCOLOR , XLRGBToOORGB(_color));
++        SetMixedColor();
++    }
++}
++
++void
++ScVbaInterior::SetMixedColor()
++{
++    // pattern
++    uno::Any aPattern = GetUserDefinedAttributes( PATTERN );
++    if( aPattern.hasValue() )
++    {
++        m_nPattern = GetAttributeData( aPattern );
++    }
++    sal_Int32 nPattern = aPatternMap[ m_nPattern ];
++    // pattern color
++    uno::Any aPatternColor = GetUserDefinedAttributes( PATTERNCOLOR );
++    if( aPatternColor.hasValue() )
++    {
++        sal_uInt32 nPatternColor = GetAttributeData( aPatternColor );
++        m_aPattColor.SetColor( nPatternColor );
++    }
++    sal_Int32 nPatternColor = m_aPattColor.GetColor();
++    // back color
++    Color aBackColor( GetBackColor() );
++    // set mixed color
++    Color aMixedColor;
++    if( nPattern > 0 )
++        aMixedColor = GetPatternColor( Color(nPatternColor), aBackColor, (sal_uInt32)nPattern );
++    else
++        aMixedColor = GetPatternColor( aBackColor, aBackColor, (sal_uInt32)nPattern );
++    sal_Int32 nMixedColor = aMixedColor.GetColor() & COLORMAST;
++	m_xProps->setPropertyValue( BACKCOLOR , uno::makeAny( nMixedColor ) );
+ }
+ 
+ uno::Reference< container::XIndexAccess >
+@@ -88,28 +167,28 @@ ScVbaInterior::setColorIndex( const css:
+ {
+ 	sal_Int32 nIndex = 0;
+ 	_colorindex >>= nIndex;
++	
++	// setColor expects colors in XL RGB values
++	// #FIXME this is daft we convert OO RGB val to XL RGB val and
++	// then back again to OO RGB value
++	setColor( OORGBToXLRGB( GetIndexColor( nIndex ) ) );
++}
++uno::Any
++ScVbaInterior::GetIndexColor( const sal_Int32& nColorIndex )
++{
++	sal_Int32 nIndex = nColorIndex;
+ 	// #FIXME  xlColorIndexAutomatic & xlColorIndexNone are not really
+ 	// handled properly here
+-	
+ 	if ( !nIndex || ( nIndex == excel::XlColorIndex::xlColorIndexAutomatic ) || ( nIndex == excel::XlColorIndex::xlColorIndexNone )  )
+ 		nIndex = 2; // default is white ( this maybe will probably break, e.g. we may at some stage need to know what this interior is,  a cell or something else and then pick a default colour based on that )
+ 	--nIndex; // OOo indices are zero bases
+ 	uno::Reference< container::XIndexAccess > xIndex = getPalette();
+-	// setColor expects colors in XL RGB values
+-	// #FIXME this is daft we convert OO RGB val to XL RGB val and
+-	// then back again to OO RGB value
+-	setColor( OORGBToXLRGB(xIndex->getByIndex( nIndex )) );
++    return xIndex->getByIndex( nIndex );
+ }
+ 
+-uno::Any SAL_CALL 
+-ScVbaInterior::getColorIndex() throw ( css::uno::RuntimeException )
++sal_Int32
++ScVbaInterior::GetColorIndex( const sal_Int32 nColor )
+ {
+-	sal_Int32 nColor = 0;
+-	// getColor returns Xl ColorValue, need to convert it to OO val
+-	// as the palette deals with OO RGB values 
+-	// #FIXME this is daft in getColor we convert OO RGB val to XL RGB val 
+-	// and then back again to OO RGB value
+-	XLRGBToOORGB( getColor() ) >>= nColor; 
+ 	uno::Reference< container::XIndexAccess > xIndex = getPalette();
+ 	sal_Int32 nElems = xIndex->getCount();
+ 	sal_Int32 nIndex = -1;
+@@ -122,8 +201,188 @@ ScVbaInterior::getColorIndex() throw ( c
+ 			nIndex = count + 1; // 1 based
+ 			break;
+ 		}
+-	}     
+-	return uno::makeAny( nIndex );
++	}
++    return nIndex;
++}
++
++uno::Any SAL_CALL 
++ScVbaInterior::getColorIndex() throw ( css::uno::RuntimeException )
++{
++	sal_Int32 nColor = 0;
++	// getColor returns Xl ColorValue, need to convert it to OO val
++	// as the palette deals with OO RGB values 
++	// #FIXME this is daft in getColor we convert OO RGB val to XL RGB val 
++	// and then back again to OO RGB value
++	XLRGBToOORGB( getColor() ) >>= nColor; 
++     
++	return uno::makeAny( GetIndexColor( nColor ) );
++}
++Color
++ScVbaInterior::GetPatternColor( const Color& rPattColor, const Color& rBackColor, sal_uInt32 nXclPattern )
++{
++    // 0x00 == 0% transparence (full rPattColor)
++    // 0x80 == 100% transparence (full rBackColor)
++    static const sal_uInt8 pnRatioTable[] =
++    {
++        0x80, 0x00, 0x40, 0x20, 0x60, 0x40, 0x40, 0x40,     // 00 - 07
++        0x40, 0x40, 0x20, 0x60, 0x60, 0x60, 0x60, 0x48,     // 08 - 15
++        0x50, 0x70, 0x78                                    // 16 - 18
++    };
++    return ( nXclPattern < STATIC_TABLE_SIZE( pnRatioTable ) ) ?
++        GetMixedColor( rPattColor, rBackColor, pnRatioTable[ nXclPattern ] ) : rPattColor;
++}
++Color
++ScVbaInterior::GetMixedColor( const Color& rFore, const Color& rBack, sal_uInt8 nTrans )
++{
++    return Color( 
++        nTrans,
++        GetMixedColorComp( rFore.GetRed(), rBack.GetRed(), nTrans ),
++        GetMixedColorComp( rFore.GetGreen(), rBack.GetGreen(), nTrans ),
++        GetMixedColorComp( rFore.GetBlue(), rBack.GetBlue(), nTrans ));
++}
++sal_uInt8
++ScVbaInterior::GetMixedColorComp(  sal_uInt8 nFore, sal_uInt8 nBack, sal_uInt8 nTrans )
++{
++    sal_uInt32 nTemp = ((static_cast< sal_Int32 >( nBack ) - nFore) * nTrans) / 0x80 + nFore;
++    return static_cast< sal_uInt8 >( nTemp );
++}
++uno::Reference< container::XNameContainer >
++ScVbaInterior::GetAttributeContainer()
++{
++    return uno::Reference < container::XNameContainer > ( m_xProps->getPropertyValue( rtl::OUString::createFromAscii( "UserDefinedAttributes" ) ), uno::UNO_QUERY_THROW );
++}
++sal_Int32
++ScVbaInterior::GetAttributeData( uno::Any aValue )
++{
++    xml::AttributeData aDataValue;
++    if( aValue >>= aDataValue )
++    {
++        return aDataValue.Value.toInt32();
++    }
++    return sal_Int32( 0 );
++}
++uno::Any
++ScVbaInterior::SetAttributeData( sal_Int32 nValue )
++{
++    xml::AttributeData aAttributeData;
++    //aAttributeData.Namespace = rtl::OUString::createFromAscii( "org.openoffice.excel.CellPatten");
++    aAttributeData.Type = rtl::OUString::createFromAscii( "sal_Int32" );
++    aAttributeData.Value = rtl::OUString::valueOf( nValue );
++    return uno::makeAny( aAttributeData );
++}
++uno::Any
++ScVbaInterior::GetUserDefinedAttributes( const rtl::OUString& sName )
++{
++    uno::Reference< container::XNameContainer > xNameContainer( GetAttributeContainer(), uno::UNO_QUERY_THROW );
++    if( xNameContainer->hasByName( sName ) )
++    {
++        return xNameContainer->getByName( sName );
++    }
++    return uno::Any();
++}
++void
++ScVbaInterior::SetUserDefinedAttributes( const rtl::OUString& sName, const uno::Any& aValue )
++{
++    if( aValue.hasValue() )
++    {
++        uno::Reference< container::XNameContainer > xNameContainer( GetAttributeContainer(), uno::UNO_QUERY_THROW );
++        if( xNameContainer->hasByName( sName ) )
++            xNameContainer->removeByName( sName );
++        xNameContainer->insertByName( sName, aValue );
++        m_xProps->setPropertyValue( rtl::OUString::createFromAscii( "UserDefinedAttributes" ), uno::makeAny( xNameContainer ) );
++    }
++}
 +// OOo do not support below API
 +uno::Any SAL_CALL 
 +ScVbaInterior::getPattern() throw (uno::RuntimeException)
 +{
 +    // XlPattern
++    uno::Any aPattern = GetUserDefinedAttributes( PATTERN );
++    if( aPattern.hasValue() )
++        return uno::makeAny( GetAttributeData( aPattern ) );
 +    return uno::makeAny( excel::XlPattern::xlPatternNone );
 +}
 +void SAL_CALL 
 +ScVbaInterior::setPattern( const uno::Any& _pattern ) throw (uno::RuntimeException)
 +{
-+    (void) _pattern;
-+    setColorIndex( uno::makeAny( excel::XlColorIndex::xlColorIndexAutomatic ) );
++    if( _pattern >>= m_nPattern )
++    {
++        SetUserDefinedAttributes( PATTERN, SetAttributeData( m_nPattern ) );
++        SetMixedColor();
++    }
++    else
++        throw uno::RuntimeException( rtl::OUString::createFromAscii( "Invalid Pattern index" ), uno::Reference< uno::XInterface >() );
++}
++Color
++ScVbaInterior::GetBackColor()
++{
++    sal_Int32 nColor;
++    Color aBackColor;
++    uno::Any aColor = GetUserDefinedAttributes( BACKCOLOR ); 
++    if( aColor.hasValue() )
++    {
++        nColor = GetAttributeData( aColor );
++        aBackColor.SetColor( nColor );
++    }
++    else
++    {
++	    uno::Any aAny;
++	    aAny = OORGBToXLRGB( m_xProps->getPropertyValue( BACKCOLOR ) );
++        if( aAny >>= nColor )
++        {
++            nColor = XLRGBToOORGB( nColor );
++            aBackColor.SetColor( nColor );
++            SetUserDefinedAttributes( BACKCOLOR, SetAttributeData( nColor ) );
++        }
++    }
++    return aBackColor;
 +}
 +uno::Any SAL_CALL 
 +ScVbaInterior::getPatternColor() throw (uno::RuntimeException)
 +{
 +    // 0 is the default color. no filled.
-+    // RGB
-+    return getColor();
++    uno::Any aPatternColor = GetUserDefinedAttributes( PATTERNCOLOR );
++    if( aPatternColor.hasValue() )
++    {
++        sal_uInt32 nPatternColor = GetAttributeData( aPatternColor );
++        return uno::makeAny( OORGBToXLRGB( nPatternColor ) );
++    }
++    return uno::makeAny( sal_Int32( 0 ) );
 +}
 +void SAL_CALL 
 +ScVbaInterior::setPatternColor( const uno::Any& _patterncolor ) throw (uno::RuntimeException)
 +{
-+    setColor( _patterncolor );
++    sal_Int32 nPattColor;
++    if( _patterncolor >>= nPattColor )
++    {
++        SetUserDefinedAttributes( PATTERNCOLOR, SetAttributeData( XLRGBToOORGB( nPattColor ) ) );
++        SetMixedColor();
++    }
++    else
++        throw uno::RuntimeException( rtl::OUString::createFromAscii( "Invalid Pattern Color" ), uno::Reference< uno::XInterface >() );
 +}
 +uno::Any SAL_CALL 
 +ScVbaInterior::getPatternColorIndex() throw (uno::RuntimeException)
 +{
-+    // 0 means color is not set. 
-+    // XlColorIndex
-+    return getColorIndex();
++	sal_Int32 nColor = 0;
++	XLRGBToOORGB( getPatternColor() ) >>= nColor; 
++     
++	return uno::makeAny( GetIndexColor( nColor ) );
 +}
 +void SAL_CALL 
 +ScVbaInterior::setPatternColorIndex( const uno::Any& _patterncolorindex ) throw (uno::RuntimeException)
 +{
-+    setColorIndex( _patterncolorindex );
-+}
++    sal_Int32 nColorIndex = 0;
++    if( _patterncolorindex >>= nColorIndex )
++    {
++        if( nColorIndex == 0 )
++            return;
++        sal_Int32 nPattColor = 0;
++        GetIndexColor( nColorIndex ) >>= nPattColor;
++        setPatternColor( uno::makeAny( OORGBToXLRGB( nPattColor ) ) );
++    }
++    else
++        throw uno::RuntimeException( rtl::OUString::createFromAscii( "Invalid Pattern Color" ), uno::Reference< uno::XInterface >() );
+ }
  
  rtl::OUString& 
- ScVbaInterior::getServiceImplName()
[Date Prev][Date Next] [Thread Prev][Thread Next] [Thread Index] [Date Index] [Author Index]