Renaming of files in preparation for code style tools.

Signed-off-by: Michele Calgaro <[email protected]>

1 files changed, 3214 insertions, 0 deletions

diff --git a/kspread/kspread_style.cpp b/kspread/kspread_style.cpp
new file mode 100644
index 00000000..bd58ac88
--- /dev/null
+++ b/kspread/kspread_style.cpp
@@ -0,0 +1,3214 @@
+/* This file is part of the KDE project
+   Copyright (C) 2003 Norbert Andres, [email protected]
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+*/
+
+#include <tqdom.h>
+#include <tqbuffer.h>
+
+#include <kdebug.h>
+#include <tdelocale.h>
+
+#include <KoGlobal.h>
+#include <KoGenStyles.h>
+#include <KoOasisStyles.h>
+#include <KoStyleStack.h>
+#include <KoXmlWriter.h>
+#include <KoXmlNS.h>
+
+#include "kspread_util.h"
+#include "kspread_doc.h"
+
+#include "kspread_style.h"
+
+using namespace KSpread;
+
+static uint calculateValue( TQPen const & pen )
+{
+  uint n = pen.color().red() + pen.color().green() + pen.color().blue();
+
+  n += 1000 * pen.width();
+  n += 10000 * (uint) pen.style();
+
+  return n;
+}
+
+Style::Style()
+  : m_parent( 0 ),
+    m_type( AUTO ),
+    m_usageCount( 1 ),
+    m_featuresSet( 0 ),
+    m_alignX( Format::Undefined ),
+    m_alignY( Format::Middle ),
+    m_floatFormat( Format::OnlyNegSigned ),
+    m_floatColor( Format::AllBlack ),
+    m_formatType( Generic_format ),
+    m_fontFlags( 0 ),
+    m_bgColor( TQt::white ),
+    m_backGroundBrush( TQt::red, TQt::NoBrush ),
+    m_rotateAngle( 0 ),
+    m_indent( 0.0 ),
+    m_precision( -1 ),
+    m_properties( 0 )
+{
+  TQFont f( KoGlobal::defaultFont() );
+  m_fontFamily = f.family();
+  m_fontSize = f.pointSize();
+
+  TQPen pen( TQt::black, 1, TQt::NoPen );
+
+  m_textPen         = pen;
+  m_leftBorderPen   = pen;
+  m_topBorderPen    = pen;
+  m_rightBorderPen  = pen;
+  m_bottomBorderPen = pen;
+  m_fallDiagonalPen = pen;
+  m_goUpDiagonalPen = pen;
+
+  m_leftPenValue    = calculateValue( pen );
+  m_topPenValue     = calculateValue( pen );
+  m_rightPenValue   = calculateValue( pen );
+  m_bottomPenValue  = calculateValue( pen );
+
+  m_currency.type   = 0;
+}
+
+Style::Style( Style * style )
+  : m_parent( ( style->m_type == BUILTIN || style->m_type == CUSTOM ) ? (CustomStyle *) style : 0 ),
+    m_type( AUTO ),
+    m_usageCount( 1 ),
+    m_featuresSet( ( style->m_type == BUILTIN || style->m_type == CUSTOM ) ? 0 : style->m_featuresSet ),
+    m_alignX( style->m_alignX ),
+    m_alignY( style->m_alignY ),
+    m_floatFormat( style->m_floatFormat ),
+    m_floatColor( style->m_floatColor ),
+    m_formatType( style->m_formatType ),
+    m_fontFamily( style->m_fontFamily ),
+    m_fontFlags( style->m_fontFlags ),
+    m_fontSize( style->m_fontSize ),
+    m_textPen( style->m_textPen ),
+    m_bgColor( style->m_bgColor ),
+    m_rightBorderPen( style->m_rightBorderPen ),
+    m_bottomBorderPen( style->m_bottomBorderPen ),
+    m_leftBorderPen( style->m_leftBorderPen ),
+    m_topBorderPen( style->m_topBorderPen ),
+    m_fallDiagonalPen( style->m_fallDiagonalPen ),
+    m_goUpDiagonalPen( style->m_goUpDiagonalPen ),
+    m_backGroundBrush( style->m_backGroundBrush ),
+    m_rotateAngle( style->m_rotateAngle ),
+    m_indent( style->m_indent ),
+    m_strFormat( style->m_strFormat ),
+    m_precision( style->m_precision ),
+    m_prefix( style->m_prefix ),
+    m_postfix( style->m_postfix ),
+    m_currency( style->m_currency ),
+    m_properties( style->m_properties )
+{
+}
+
+Style::~Style()
+{
+}
+
+bool Style::operator == (const Style& style) const
+{
+	//This is prone to error because if someone adds additional
+	//properties to the style class they will have to remember
+	//to correct this function - can we do this a better way?
+  if ( m_featuresSet != style.m_featuresSet )
+    return false;
+  if ( m_type != style.m_type )
+    return false;
+  // NOTE Stefan: Only compare the values of the set features.
+  if ( // layout (4)
+       ( m_featuresSet & SAlignX ) && ( m_alignX != style.m_alignX ) ||
+       ( m_featuresSet & SAlignY ) && ( m_alignY != style.m_alignY ) ||
+       ( m_featuresSet & SAngle )  && ( m_rotateAngle != style.m_rotateAngle ) ||
+       ( m_featuresSet & SIndent ) && ( m_indent != style.m_indent ) ||
+       // background (2)
+       ( m_featuresSet & SBackgroundColor ) && ( m_bgColor != style.m_bgColor ) ||
+       ( m_featuresSet & SBackgroundBrush ) && ( m_backGroundBrush != style.m_backGroundBrush ) ||
+       // borders (6)
+       ( m_featuresSet & SRightBorder )  && ( m_rightBorderPen != style.m_rightBorderPen ) ||
+       ( m_featuresSet & SBottomBorder ) && ( m_bottomBorderPen != style.m_bottomBorderPen ) ||
+       ( m_featuresSet & SLeftBorder )   && ( m_leftBorderPen != style.m_leftBorderPen ) ||
+       ( m_featuresSet & STopBorder )    && ( m_topBorderPen != style.m_topBorderPen ) ||
+       ( m_featuresSet & SFallDiagonal ) && ( m_fallDiagonalPen != style.m_fallDiagonalPen ) ||
+       ( m_featuresSet & SGoUpDiagonal ) && ( m_goUpDiagonalPen != style.m_goUpDiagonalPen ) ||
+       // format (7) (SFormatType twice)
+       ( m_featuresSet & SPrecision )    && ( m_precision != style.m_precision ) ||
+       ( m_featuresSet & SPrefix )       && ( m_prefix != style.m_prefix ) ||
+       ( m_featuresSet & SPostfix )      && ( m_postfix != style.m_postfix ) ||
+       ( m_featuresSet & SFloatFormat )  && ( m_floatFormat != style.m_floatFormat ) ||
+       ( m_featuresSet & SFloatColor )   && ( m_floatColor != style.m_floatColor ) ||
+       ( m_featuresSet & SFormatType )   && ( m_formatType != style.m_formatType ) ||
+       ( m_featuresSet & SFormatType )   && ( m_currency.type != style.m_currency.type ) ||
+       ( m_featuresSet & SCustomFormat ) && ( m_strFormat != style.m_strFormat ) ||
+       // font (4)
+       ( m_featuresSet & SFontFamily ) && ( m_fontFamily != style.m_fontFamily ) ||
+       ( m_featuresSet & SFontFlag )   && ( m_fontFlags != style.m_fontFlags ) ||
+       ( m_featuresSet & SFontSize )   && ( m_fontSize != style.m_fontSize ) ||
+       ( m_featuresSet & STextPen )    && ( m_textPen != style.m_textPen ) )
+  {
+    return false;
+  }
+  // Properties (7)
+  const uint differingProperties = m_properties xor style.m_properties;
+  if ( ( m_featuresSet & SDontPrintText ) && ( differingProperties & PDontPrintText ) ||
+       ( m_featuresSet & SCustomFormat )  && ( differingProperties & PCustomFormat ) ||
+       ( m_featuresSet & SNotProtected )  && ( differingProperties & PNotProtected ) ||
+       ( m_featuresSet & SHideAll )       && ( differingProperties & PHideAll ) ||
+       ( m_featuresSet & SHideFormula )   && ( differingProperties & PHideFormula ) ||
+       ( m_featuresSet & SMultiRow )      && ( differingProperties & PMultiRow ) ||
+       ( m_featuresSet & SVerticalText )  && ( differingProperties & PVerticalText ) )
+  {
+    return false;
+  }
+  return true;
+}
+
+void Style::loadOasisStyle( KoOasisStyles& oasisStyles, const TQDomElement & element )
+{
+  // NOTE Stefan: Don't fill the style stack with the parent styles!
+  KoStyleStack styleStack;
+  styleStack.push( element );
+  styleStack.setTypeProperties( "table-cell" );
+  loadOasisTableCellProperties( oasisStyles, styleStack );
+  styleStack.setTypeProperties( "text" );
+  loadOasisTextProperties( oasisStyles, styleStack );
+  styleStack.setTypeProperties( "paragraph" );
+  loadOasisParagraphProperties( oasisStyles, styleStack );
+
+  loadOasisDataStyle( oasisStyles, element );
+}
+
+void Style::loadOasisDataStyle( KoOasisStyles& oasisStyles, const TQDomElement& element )
+{
+  TQString str;
+  if ( element.hasAttributeNS( KoXmlNS::style, "data-style-name" ) )
+  {
+//     kdDebug()<<"element.attribute( style:data-style-name ) :"<<element.attributeNS( KoXmlNS::style, "data-style-name", TQString() )<<endl;
+//     kdDebug()<< " oasisStyles.dataFormats()[...] :"<< oasisStyles.dataFormats()[element.attributeNS( KoXmlNS::style, "data-style-name" , TQString())].formatStr<<endl;
+//     kdDebug()<< " oasisStyles.dataFormats()[...] prefix :"<< oasisStyles.dataFormats()[element.attributeNS( KoXmlNS::style, "data-style-name" , TQString())].prefix<<endl;
+//     kdDebug()<< " oasisStyles.dataFormats()[...] suffix :"<< oasisStyles.dataFormats()[element.attributeNS( KoXmlNS::style, "data-style-name" , TQString())].suffix<<endl;
+
+    const TQString styleName = element.attributeNS( KoXmlNS::style, "data-style-name", TQString() );
+    if ( oasisStyles.dataFormats().contains(styleName) )
+    {
+      const KoOasisStyles::NumericStyleFormat dataStyle = oasisStyles.dataFormats()[styleName];
+
+      TQString tmp = dataStyle.prefix;
+      if ( !tmp.isEmpty() )
+      {
+        m_prefix = tmp;
+        m_featuresSet |= SPrefix;
+      }
+      tmp = dataStyle.suffix;
+      if ( !tmp.isEmpty() )
+      {
+        m_postfix = tmp;
+        m_featuresSet |= SPostfix;
+      }
+      // determine data formatting
+      switch (dataStyle.type)
+      {
+        case KoOasisStyles::NumericStyleFormat::Number:
+          m_formatType = Number_format;
+          m_featuresSet |= SFormatType;
+          break;
+        case KoOasisStyles::NumericStyleFormat::Scientific:
+          m_formatType = Scientific_format;
+          m_featuresSet |= SFormatType;
+          break;
+        case KoOasisStyles::NumericStyleFormat::Currency:
+          kdDebug() << " currency-symbol: " << dataStyle.currencySymbol << endl;
+          if (!dataStyle.currencySymbol.isEmpty())
+          {
+            Currency currency(dataStyle.currencySymbol);
+            m_currency.type = currency.getIndex();
+            m_currency.symbol = currency.getDisplayCode();
+          }
+          m_formatType = Money_format;
+          m_featuresSet |= SFormatType;
+          break;
+        case KoOasisStyles::NumericStyleFormat::Percentage:
+          m_formatType = Percentage_format;
+          m_featuresSet |= SFormatType;
+          break;
+        case KoOasisStyles::NumericStyleFormat::Fraction:
+          // determine format of fractions, dates and times by using the
+          // formatting string
+          tmp = dataStyle.formatStr;
+          if ( !tmp.isEmpty() )
+          {
+            m_formatType = Style::fractionType( tmp );
+            m_featuresSet |= SFormatType;
+          }
+          break;
+        case KoOasisStyles::NumericStyleFormat::Date:
+          // determine format of fractions, dates and times by using the
+          // formatting string
+          tmp = dataStyle.formatStr;
+          if ( !tmp.isEmpty() )
+          {
+            m_formatType = Style::dateType( tmp );
+            m_featuresSet |= SFormatType;
+          }
+          break;
+        case KoOasisStyles::NumericStyleFormat::Time:
+          // determine format of fractions, dates and times by using the
+          // formatting string
+          tmp = dataStyle.formatStr;
+          if ( !tmp.isEmpty() )
+          {
+            m_formatType = Style::timeType( tmp );
+            m_featuresSet |= SFormatType;
+          }
+          break;
+        case KoOasisStyles::NumericStyleFormat::Boolean:
+          m_formatType = Number_format;
+          m_featuresSet |= SFormatType;
+          break;
+        case KoOasisStyles::NumericStyleFormat::Text:
+          m_formatType = Text_format;
+          m_featuresSet |= SFormatType;
+          break;
+      }
+
+      if (dataStyle.precision > -1)
+      {
+        m_precision = dataStyle.precision;
+        m_featuresSet |= SPrecision;
+      }
+    }
+  }
+}
+
+void Style::loadOasisParagraphProperties( KoOasisStyles& oasisStyles, const KoStyleStack& styleStack )
+{
+  Q_UNUSED( oasisStyles );
+  kdDebug() << "\t paragraph-properties" << endl;
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "text-align" ) )
+  {
+    TQString str = styleStack.attributeNS( KoXmlNS::fo, "text-align" );
+    if ( str == "center" )
+      m_alignX = Format::Center;
+    else if ( str == "end" )
+      m_alignX = Format::Right;
+    else if ( str == "start" )
+      m_alignX = Format::Left;
+    else
+      m_alignX = Format::Undefined;
+    m_featuresSet |= SAlignX;
+    kdDebug() << "\t\t text-align: " << str << endl;
+  }
+}
+
+void Style::loadOasisTableCellProperties( KoOasisStyles& oasisStyles, const KoStyleStack& styleStack )
+{
+  TQString str;
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "vertical-align" ) )
+  {
+    m_alignY = Format::UndefinedY;
+
+    str = styleStack.attributeNS( KoXmlNS::style, "vertical-align" );
+    if ( str == "bottom" )
+      m_alignY = Format::Bottom;
+    else if ( str =="top" )
+      m_alignY = Format::Top;
+    else if ( str =="middle" )
+      m_alignY = Format::Middle;
+
+    if (m_alignY != Format::UndefinedY) // file's property is invalid
+      m_featuresSet |= SAlignY;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "background-color" ) )
+  {
+    m_bgColor = TQColor(  styleStack.attributeNS( KoXmlNS::fo, "background-color" ) );
+    if ( m_bgColor.isValid() && m_bgColor != TQt::white )
+      m_featuresSet |= SBackgroundColor;
+  }
+
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "wrap-option" )&&( styleStack.attributeNS( KoXmlNS::fo, "wrap-option" )=="wrap" ) )
+  {
+    setProperty( PMultiRow );
+    m_featuresSet |= SMultiRow;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "cell-protect" ) )
+  {
+    str = styleStack.attributeNS( KoXmlNS::style, "cell-protect" );
+    if ( str=="hidden-and-protected" )
+    {
+      setProperty( PHideAll );
+      m_featuresSet |= SHideAll;
+    }
+    else if ( str == "protected formula-hidden" )
+    {
+      setProperty( PHideFormula );
+      m_featuresSet |= SHideFormula;
+    }
+    else if ( str == "protected" )
+    {
+      setProperty( PNotProtected );
+      m_featuresSet |= SNotProtected;
+    }
+    else if ( str =="formula-hidden" )
+    {
+            //FIXME !!!!
+#if 0
+            setNotProtected( true );
+            setHideFormula( true );
+            setHideAll( false );
+#endif
+    }
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "print-content" ) && ( styleStack.attributeNS( KoXmlNS::style, "print-content" )=="false" ) )
+  {
+    setProperty( PDontPrintText );
+    m_featuresSet |= SDontPrintText;
+
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "direction" ) && ( styleStack.attributeNS( KoXmlNS::style, "direction" )=="ttb" ) )
+  {
+    setProperty( PVerticalText );
+    m_featuresSet |= SVerticalText;
+
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "rotation-angle" ) )
+  {
+    bool ok;
+    int a = styleStack.attributeNS( KoXmlNS::style, "rotation-angle" ).toInt( &ok );
+    kdDebug()<<" rotation-angle :"<<a<<endl;
+    if ( a != 0 )
+    {
+      m_rotateAngle= ( -a  );
+      m_featuresSet |= SAngle;
+    }
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "margin-left" ) )
+  {
+        //todo fix me
+    setIndent( KoUnit::parseValue( styleStack.attributeNS( KoXmlNS::fo, "margin-left" ),0.0 ) );
+    m_featuresSet |= SIndent;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "border" ) )
+  {
+    str=styleStack.attributeNS( KoXmlNS::fo, "border" );
+    TQPen pen = convertOasisStringToPen( str );
+    m_featuresSet |= SLeftBorder;
+    m_featuresSet |= SRightBorder;
+    m_featuresSet |= STopBorder;
+    m_featuresSet |= SBottomBorder;
+    m_leftBorderPen = pen;
+    m_topBorderPen = pen;
+    m_bottomBorderPen = pen;
+    m_rightBorderPen = pen;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "border-left" ) )
+  {
+    str=styleStack.attributeNS( KoXmlNS::fo, "border-left" );
+    m_leftBorderPen = convertOasisStringToPen( str );
+    m_featuresSet |= SLeftBorder;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "border-right" ) )
+  {
+    str=styleStack.attributeNS( KoXmlNS::fo, "border-right" );
+    m_rightBorderPen = convertOasisStringToPen( str );
+    m_featuresSet |= SRightBorder;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "border-top" ) )
+  {
+    str=styleStack.attributeNS( KoXmlNS::fo, "border-top" );
+    m_topBorderPen = convertOasisStringToPen( str );
+    m_featuresSet |= STopBorder;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "border-bottom" ) )
+  {
+    str=styleStack.attributeNS( KoXmlNS::fo, "border-bottom" );
+    m_bottomBorderPen = convertOasisStringToPen( str );
+    m_featuresSet |= SBottomBorder;
+  }
+  if (styleStack.hasAttributeNS( KoXmlNS::style, "diagonal-tl-br" ) )
+  {
+    str=styleStack.attributeNS( KoXmlNS::style, "diagonal-tl-br" );
+    m_fallDiagonalPen = convertOasisStringToPen( str );
+    m_featuresSet |= SFallDiagonal;
+  }
+  if (styleStack.hasAttributeNS( KoXmlNS::style, "diagonal-bl-tr" ) )
+  {
+    str=styleStack.attributeNS( KoXmlNS::style, "diagonal-bl-tr" );
+    m_goUpDiagonalPen = convertOasisStringToPen( str );
+    m_featuresSet |= SGoUpDiagonal;
+  }
+
+  if ( styleStack.hasAttributeNS( KoXmlNS::draw, "style-name" ) )
+  {
+    kdDebug()<<" style name :"<<styleStack.attributeNS( KoXmlNS::draw, "style-name" )<<endl;
+
+    const TQDomElement * style = oasisStyles.findStyle( styleStack.attributeNS( KoXmlNS::draw, "style-name" ), "graphic" );
+    kdDebug()<<" style :"<<style<<endl;
+    if ( style )
+    {
+      KoStyleStack drawStyleStack;
+      drawStyleStack.push( *style );
+      drawStyleStack.setTypeProperties( "graphic" );
+      if ( drawStyleStack.hasAttributeNS( KoXmlNS::draw, "fill" ) )
+      {
+        const TQString fill = drawStyleStack.attributeNS( KoXmlNS::draw, "fill" );
+        kdDebug()<<" load object gradient fill type :"<<fill<<endl;
+
+        if ( fill == "solid" || fill == "hatch" )
+        {
+          kdDebug()<<" Style ******************************************************\n";
+          m_backGroundBrush=KoOasisStyles::loadOasisFillStyle( drawStyleStack, fill, oasisStyles );
+          m_featuresSet |= SBackgroundBrush;
+        }
+        else
+          kdDebug()<<" fill style not supported into kspread : "<<fill<<endl;
+      }
+    }
+  }
+}
+
+void Style::loadOasisTextProperties( KoOasisStyles& oasisStyles, const KoStyleStack& styleStack )
+{
+  Q_UNUSED( oasisStyles );
+  // fo:font-size="13pt"
+  // fo:font-style="italic"
+  // style:text-underline="double"
+  // style:text-underline-color="font-color"
+  // fo:font-weight="bold"
+  kdDebug() << "\t text-properties" << endl;
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "font-family" ) )
+  {
+    m_fontFamily = styleStack.attributeNS( KoXmlNS::fo, "font-family" ); // FIXME Stefan: sanity check
+    m_featuresSet |= SFontFamily;
+    m_featuresSet |= SFont;
+    kdDebug() << "\t\t fo:font-family: " << m_fontFamily << endl;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "font-size" ) )
+  {
+    m_fontSize = (int) KoUnit::parseValue( styleStack.attributeNS( KoXmlNS::fo, "font-size" ), 10.0 ); // FIXME Stefan: fallback to default
+    m_featuresSet |= SFontSize;
+    m_featuresSet |= SFont;
+    kdDebug() << "\t\t fo:font-size: " << m_fontSize << endl;
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "font-style" ) )
+  {
+    if ( styleStack.attributeNS( KoXmlNS::fo, "font-style" ) == "italic" ) // "normal", "oblique"
+    {
+      m_fontFlags |= FItalic;
+      m_featuresSet |= SFontFlag;
+      m_featuresSet |= SFont;
+      kdDebug() << "\t\t fo:font-style: " << "italic" << endl;
+    }
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "font-weight" ) )
+  {
+    if ( styleStack.attributeNS( KoXmlNS::fo, "font-weight" ) == "bold" ) // "normal", "100", "200", ...
+    {
+      m_fontFlags |= FBold;
+      m_featuresSet |= SFontFlag;
+      m_featuresSet |= SFont;
+      kdDebug() << "\t\t fo:font-weight: " << "bold" << endl;
+    }
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "text-underline-style" ) )
+  {
+    if ( styleStack.attributeNS( KoXmlNS::style, "text-underline-style" ) != "none" )
+    {
+      m_fontFlags |= FUnderline;
+      m_featuresSet |= SFontFlag;
+      m_featuresSet |= SFont;
+      kdDebug() << "\t\t style:text-underline-style: " << "solid (actually: !none)" << endl;
+    }
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "text-underline-width" ) )
+  {
+        //TODO
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "text-underline-color" ) )
+  {
+        //TODO
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::fo, "color" ) )
+  {
+    TQColor color = TQColor( styleStack.attributeNS( KoXmlNS::fo, "color" ) );
+    if ( color.isValid() )
+    {
+      m_featuresSet |= STextPen;
+      m_textPen = TQPen( color );
+      kdDebug() << "\t\t fo:color: " << TQString(color.name()) << endl;
+    }
+  }
+  if ( styleStack.hasAttributeNS( KoXmlNS::style, "text-line-through-style" ) )
+  {
+    if ( styleStack.attributeNS( KoXmlNS::style, "text-line-through-style" ) != "none"
+         /*&& styleStack.attributeNS("text-line-through-style")=="solid"*/ )
+    {
+      m_fontFlags |= FStrike;
+      m_featuresSet |= SFontFlag;
+      m_featuresSet |= SFont;
+      kdDebug() << "\t\t text-line-through-style: " << "solid (actually: !none)" << endl;
+    }
+  }
+}
+
+static TQString convertDateFormat( const TQString& date )
+{
+  TQString result = date;
+  result.replace( "%Y", "yyyy" );
+  result.replace( "%y", "yy" );
+  result.replace( "%n", "M" );
+  result.replace( "%m", "MM" );
+  result.replace( "%e", "d" );
+  result.replace( "%d", "dd" );
+  result.replace( "%b", "MMM" );
+  result.replace( "%B", "MMMM" );
+  result.replace( "%a", "ddd" );
+  result.replace( "%A", "dddd" );
+  return result;
+}
+
+FormatType Style::dateType( const TQString &_format )
+{
+    const TQString dateFormatShort = convertDateFormat( TDEGlobal::locale()->dateFormatShort() );
+    const TQString dateFormat = convertDateFormat( TDEGlobal::locale()->dateFormat() );
+
+    if ( _format == "dd-MMM-yy" )
+        return date_format1;
+    else if ( _format == "dd-MMM-yyyy" )
+        return date_format2;
+    else if ( _format == "d-MM" )
+        return date_format3;
+    else if ( _format == "dd-MM" ) //TODO ???????
+        return date_format4;
+    else if ( _format == "dd/MM/yy" )
+        return date_format5;
+    else if ( _format == "dd/MM/yyyy" )
+        return date_format6;
+    else if ( _format == "MMM-yy" )
+        return date_format7;
+    else if ( _format == "MMMM-yyyy" )
+        return date_format9;
+    else if ( _format == "MMMMM-yy" )
+        return date_format10;
+    else if ( _format == "dd/MMM" )
+        return date_format11;
+    else if ( _format == "dd/MM" )
+        return date_format12;
+    else if ( _format == "dd/MMM/yyyy" )
+        return date_format13;
+    else if ( _format == "yyyy/MMM/dd" )
+        return date_format14;
+    else if ( _format == "yyyy-MMM-dd" )
+        return date_format15;
+    else if ( _format == "yyyy/MM/dd" )
+        return date_format16;
+    else if ( _format == "d MMMM yyyy" )
+        return date_format17;
+    else if ( _format == "MM/dd/yyyy" )
+        return date_format18;
+    else if ( _format == "MM/dd/yy" )
+        return date_format19;
+    else if ( _format == "MMM/dd/yy" )
+        return date_format20;
+    else if ( _format == "MMM/dd/yyyy" )
+        return date_format21;
+    else if ( _format == "MMM-yyyy" )
+        return date_format22;
+    else if ( _format == "yyyy" )
+        return date_format23;
+    else if ( _format == "yy" )
+        return date_format24;
+    else if ( _format == "yyyy/MM/dd" )
+        return date_format25;
+    else if ( _format == "yyyy/MMM/dd" )
+        return date_format26;
+    else if ( _format == dateFormatShort )
+        return ShortDate_format;
+    else if ( _format == dateFormat )
+        return TextDate_format;
+    else
+        return ShortDate_format;
+}
+
+FormatType Style::timeType( const TQString &_format )
+{
+    if ( _format == "h:mm AP" )
+        return Time_format1;
+    else if ( _format == "h:mm:ss AP" )
+        return Time_format2;
+    else if ( _format == "hh \\h mm \\m\\i\\n ss \\s" )
+        return Time_format3;
+    else if ( _format == "hh:mm" )
+        return Time_format4;
+    else if ( _format == "hh:mm:ss" )
+        return Time_format5;
+    else if ( _format == "m:ss" )
+        return Time_format6;
+    else if ( _format == "h:mm:ss" )
+        return Time_format7;
+    else if ( _format == "h:mm" )
+        return Time_format8;
+    else
+        return Time_format;
+}
+
+FormatType Style::fractionType( const TQString &_format )
+{
+    if ( _format == "# ?/2" )
+        return fraction_half;
+    else if ( _format =="# ?/4" )
+        return fraction_quarter;
+    else if ( _format == "# ?/8" )
+        return fraction_eighth;
+    else if ( _format == "# ?/16" )
+        return fraction_sixteenth;
+    else if ( _format == "# ?/10" )
+        return fraction_tenth;
+    else if ( _format == "# ?/100" )
+        return fraction_hundredth;
+    else if ( _format == "# ?/?" )
+        return fraction_one_digit;
+    else if ( _format == "# \?\?/\?\?" )
+        return fraction_two_digits;
+    else if ( _format == "# \?\?\?/\?\?\?" )
+        return fraction_three_digits;
+    else
+        return fraction_half;
+}
+
+TQString Style::saveOasisStyleNumeric( KoGenStyle &style, KoGenStyles &mainStyles,
+                                      FormatType _style,
+                                      const TQString &_prefix, const TQString &_postfix,
+                                      int _precision, const TQString& symbol )
+{
+//  kdDebug() << k_funcinfo << endl;
+    TQString styleName;
+    TQString valueType;
+    switch( _style )
+    {
+    case Number_format:
+        styleName = saveOasisStyleNumericNumber( mainStyles, _style, _precision, _prefix, _postfix );
+        valueType = "float";
+        break;
+    case Text_format:
+        styleName = saveOasisStyleNumericText( mainStyles, _style, _precision, _prefix, _postfix );
+        valueType = "string";
+        break;
+    case Money_format:
+        styleName = saveOasisStyleNumericMoney( mainStyles, _style,symbol, _precision, _prefix, _postfix );
+        valueType = "currency";
+        break;
+    case Percentage_format:
+        styleName = saveOasisStyleNumericPercentage( mainStyles, _style, _precision, _prefix, _postfix );
+        valueType = "percentage";
+        break;
+    case Scientific_format:
+        styleName = saveOasisStyleNumericScientific( mainStyles, _style, _prefix, _postfix, _precision );
+        valueType = "float";
+        break;
+    case ShortDate_format:
+    case TextDate_format:
+        styleName = saveOasisStyleNumericDate( mainStyles, _style, _prefix, _postfix );
+        valueType = "date";
+        break;
+    case Time_format:
+    case SecondeTime_format:
+    case Time_format1:
+    case Time_format2:
+    case Time_format3:
+    case Time_format4:
+    case Time_format5:
+    case Time_format6:
+    case Time_format7:
+    case Time_format8:
+        styleName = saveOasisStyleNumericTime( mainStyles, _style, _prefix, _postfix );
+        valueType = "time";
+        break;
+    case fraction_half:
+    case fraction_quarter:
+    case fraction_eighth:
+    case fraction_sixteenth:
+    case fraction_tenth:
+    case fraction_hundredth:
+    case fraction_one_digit:
+    case fraction_two_digits:
+    case fraction_three_digits:
+        styleName = saveOasisStyleNumericFraction( mainStyles,_style, _prefix, _postfix );
+        valueType = "float";
+        break;
+    case date_format1:
+    case date_format2:
+    case date_format3:
+    case date_format4:
+    case date_format5:
+    case date_format6:
+    case date_format7:
+    case date_format8:
+    case date_format9:
+    case date_format10:
+    case date_format11:
+    case date_format12:
+    case date_format13:
+    case date_format14:
+    case date_format15:
+    case date_format16:
+    case date_format17:
+    case date_format18:
+    case date_format19:
+    case date_format20:
+    case date_format21:
+    case date_format22:
+    case date_format23:
+    case date_format24:
+    case date_format25:
+    case date_format26:
+        styleName = saveOasisStyleNumericDate( mainStyles, _style, _prefix, _postfix );
+        valueType = "date";
+        break;
+    case Custom_format:
+        styleName = saveOasisStyleNumericCustom( mainStyles, _style, _prefix, _postfix );
+        break;
+    case Generic_format:
+    case No_format:
+      if (_precision > -1 || !_prefix.isEmpty() || !_postfix.isEmpty())
+      {
+        styleName = saveOasisStyleNumericNumber( mainStyles, _style, _precision, _prefix, _postfix );
+        valueType = "float";
+      }
+      break;
+    }
+    if ( !styleName.isEmpty() )
+    {
+      style.addAttribute( "style:data-style-name", styleName );
+    }
+    return styleName;
+}
+
+TQString Style::saveOasisStyleNumericNumber( KoGenStyles& mainStyles, FormatType /*_style*/, int _precision,
+                                            const TQString &_prefix, const TQString &_suffix )
+{
+  TQString format;
+  if ( _precision == -1 )
+    format="0";
+  else
+  {
+    TQString tmp;
+    for ( int i = 0; i <_precision; i++ )
+    {
+      tmp+="0";
+    }
+    format = "0."+tmp;
+  }
+  return KoOasisStyles::saveOasisNumberStyle( mainStyles, format, _prefix, _suffix );
+}
+
+TQString Style::saveOasisStyleNumericText( KoGenStyles& /*mainStyles*/, FormatType /*_style*/, int /*_precision*/,
+                                          const TQString &/*_prefix*/, const TQString &/*_suffix*/ )
+{
+    return "";
+}
+
+TQString Style::saveOasisStyleNumericMoney( KoGenStyles& mainStyles, FormatType /*_style*/,
+                                           const TQString& symbol, int _precision,
+                                           const TQString &_prefix, const TQString &_suffix )
+{
+    TQString format;
+    if ( _precision == -1 )
+        format="0";
+    else
+    {
+        TQString tmp;
+        for ( int i = 0; i <_precision; i++ )
+        {
+            tmp+="0";
+        }
+        format = "0."+tmp;
+    }
+    return KoOasisStyles::saveOasisCurrencyStyle( mainStyles, format, symbol, _prefix, _suffix );
+}
+
+TQString Style::saveOasisStyleNumericPercentage( KoGenStyles&mainStyles, FormatType /*_style*/,
+                                                int _precision,
+                                                const TQString &_prefix, const TQString &_suffix )
+{
+    //<number:percentage-style style:name="N106" style:family="data-style">
+    //<number:number number:decimal-places="6" number:min-integer-digits="1"/>
+    //<number:text>%</number:text>
+    //</number:percentage-style>
+    //TODO add decimal etc.
+    TQString format;
+    if ( _precision == -1 )
+        format="0";
+    else
+    {
+        TQString tmp;
+        for ( int i = 0; i <_precision; i++ )
+        {
+            tmp+="0";
+        }
+        format = "0."+tmp;
+    }
+    return KoOasisStyles::saveOasisPercentageStyle( mainStyles, format, _prefix, _suffix );
+}
+
+
+TQString Style::saveOasisStyleNumericScientific( KoGenStyles&mainStyles, FormatType /*_style*/,
+                                                const TQString &_prefix, const TQString _suffix, int _precision )
+{
+    //<number:number-style style:name="N60" style:family="data-style">
+    //  <number:scientific-number number:decimal-places="2" number:min-integer-digits="1" number:min-exponent-digits="3"/>
+    //</number:number-style>
+    TQString format;
+    if ( _precision == -1 )
+        format="0E+00";
+    else
+    {
+        TQString tmp;
+        for ( int i = 0; i <_precision; i++ )
+        {
+            tmp+="0";
+        }
+        format = "0."+tmp+"E+00";
+    }
+    return KoOasisStyles::saveOasisScientificStyle( mainStyles, format, _prefix, _suffix );
+}
+
+TQString Style::saveOasisStyleNumericDate( KoGenStyles&mainStyles, FormatType _style,
+                                          const TQString &_prefix, const TQString &_suffix )
+{
+    TQString format;
+    bool locale = false;
+    switch( _style )
+    {
+        //TODO fixme use locale of kspread and not kglobal
+    case ShortDate_format:
+        format = TDEGlobal::locale()->dateFormatShort();
+        locale = true;
+        break;
+    case TextDate_format:
+        format = TDEGlobal::locale()->dateFormat();
+        locale = true;
+        break;
+    case date_format1:
+        format = "dd-MMM-yy";
+        break;
+    case date_format2:
+        format = "dd-MMM-yyyy";
+        break;
+    case date_format3:
+        format = "dd-M";
+        break;
+    case date_format4:
+        format = "dd-MM";
+        break;
+    case date_format5:
+        format = "dd/MM/yy";
+        break;
+    case date_format6:
+        format = "dd/MM/yyyy";
+        break;
+    case date_format7:
+        format = "MMM-yy";
+        break;
+    case date_format8:
+        format = "MMMM-yy";
+        break;
+    case date_format9:
+        format = "MMMM-yyyy";
+        break;
+    case date_format10:
+        format = "MMMMM-yy";
+        break;
+    case date_format11:
+        format = "dd/MMM";
+        break;
+    case date_format12:
+        format = "dd/MM";
+        break;
+    case date_format13:
+        format = "dd/MMM/yyyy";
+        break;
+    case date_format14:
+        format = "yyyy/MMM/dd";
+        break;
+    case date_format15:
+        format = "yyyy-MMM-dd";
+        break;
+    case date_format16:
+        format = "yyyy/MM/dd";
+        break;
+    case date_format17:
+        format = "d MMMM yyyy";
+        break;
+    case date_format18:
+        format = "MM/dd/yyyy";
+        break;
+    case date_format19:
+        format = "MM/dd/yy";
+        break;
+    case date_format20:
+        format = "MMM/dd/yy";
+        break;
+    case date_format21:
+        format = "MMM/dd/yyyy";
+        break;
+    case date_format22:
+        format = "MMM-yyyy";
+        break;
+    case date_format23:
+        format = "yyyy";
+        break;
+    case date_format24:
+        format = "yy";
+        break;
+    case date_format25:
+        format = "yyyy/MM/dd";
+        break;
+    case date_format26:
+        format = "yyyy/MMM/dd";
+        break;
+    default:
+        kdDebug()<<"this date format is not defined ! :"<<_style<<endl;
+        break;
+    }
+    return KoOasisStyles::saveOasisDateStyle( mainStyles, format, locale, _prefix, _suffix );
+}
+
+TQString Style::saveOasisStyleNumericCustom( KoGenStyles& /*mainStyles*/, FormatType /*_style*/,
+                                            const TQString &/*_prefix*/, const TQString &/*_suffix*/ )
+{
+    //TODO
+    //<number:date-style style:name="N50" style:family="data-style" number:automatic-order="true" number:format-source="language">
+    //<number:month/>
+    //<number:text>/</number:text>
+    //<number:day/>
+    //<number:text>/</number:text>
+    //<number:year/>
+    //<number:text> </number:text>
+    //<number:hours number:style="long"/>
+    //<number:text>:</number:text>
+    //<number:minutes number:style="long"/>
+    // <number:text> </number:text>
+    //<number:am-pm/>
+    //</number:date-style>
+    return "";
+}
+
+TQString Style::saveOasisStyleNumericTime( KoGenStyles& mainStyles, FormatType _style,
+                                          const TQString &_prefix, const TQString &_suffix )
+{
+    //<number:time-style style:name="N42" style:family="data-style">
+    //<number:hours number:style="long"/>
+    //<number:text>:</number:text>
+    //<number:minutes number:style="long"/>
+    //<number:text> </number:text>
+    //<number:am-pm/>
+    //</number:time-style>
+
+    TQString format;
+    bool locale = false;
+    //TODO use format
+    switch( _style )
+    {
+    case Time_format: //TODO FIXME
+        format = "hh:mm:ss";
+        break;
+    case SecondeTime_format: //TODO FIXME
+        format = "hh:mm";
+        break;
+    case Time_format1:
+        format = "h:mm AP";
+        break;
+    case Time_format2:
+        format = "h:mm:ss AP";
+        break;
+    case Time_format3: // 9 h 01 min 28 s
+        format = "hh \\h mm \\m\\i\\n ss \\s";
+        break;
+    case Time_format4:
+        format = "hh:mm";
+        break;
+    case Time_format5:
+        format = "hh:mm:ss";
+        break;
+    case Time_format6:
+        format = "m:ss";
+        break;
+    case Time_format7:
+        format = "h:mm:ss";
+        break;
+    case Time_format8:
+        format = "h:mm";
+        break;
+    default:
+        kdDebug()<<"time format not defined :"<<_style<<endl;
+        break;
+    }
+    return KoOasisStyles::saveOasisTimeStyle( mainStyles, format, locale, _prefix, _suffix );
+}
+
+
+TQString Style::saveOasisStyleNumericFraction( KoGenStyles &mainStyles, FormatType _style,
+                                              const TQString &_prefix, const TQString _suffix )
+{
+    //<number:number-style style:name="N71" style:family="data-style">
+    //<number:fraction number:min-integer-digits="0" number:min-numerator-digits="2" number:min-denominator-digits="2"/>
+    //</number:number-style>
+    TQString format;
+    switch( _style )
+    {
+    case fraction_half:
+        format = "# ?/2";
+        break;
+    case fraction_quarter:
+        format = "# ?/4";
+        break;
+    case fraction_eighth:
+        format = "# ?/8";
+        break;
+    case fraction_sixteenth:
+        format = "# ?/16";
+        break;
+    case fraction_tenth:
+        format = "# ?/10";
+        break;
+    case fraction_hundredth:
+        format = "# ?/100";
+        break;
+    case fraction_one_digit:
+        format = "# ?/?";
+        break;
+    case fraction_two_digits:
+        format = "# \?\?/\?\?";
+        break;
+    case fraction_three_digits:
+        format = "# \?\?\?/\?\?\?";
+        break;
+    default:
+        kdDebug()<<" fraction format not defined :"<<_style<<endl;
+        break;
+    }
+
+    return KoOasisStyles::saveOasisFractionStyle( mainStyles, format, _prefix, _suffix );
+}
+
+TQString Style::saveOasis( KoGenStyle& style, KoGenStyles& mainStyles )
+{
+  // KSpread::Style is definitly an OASIS auto style,
+  // but don't overwrite it, if it already exists
+  if (style.type() == 0)
+      style = KoGenStyle( Doc::STYLE_CELL_AUTO, "table-cell" );
+  // doing the real work
+  saveOasisStyle( style, mainStyles );
+  return TQString();
+}
+
+void Style::saveOasisStyle( KoGenStyle &style, KoGenStyles &mainStyles )
+{
+#ifndef NDEBUG
+    //if (type() == BUILTIN )
+    //  kdDebug() << "BUILTIN" << endl;
+    //else if (type() == CUSTOM )
+    //  kdDebug() << "CUSTOM" << endl;
+    //else if (type() == AUTO )
+    //  kdDebug() << "AUTO" << endl;
+#endif
+
+    // don't store parent, if it's the default style
+    if ( m_parent && (m_parent->type() != BUILTIN || m_parent->name() != "Default") )
+        // FIXME this is not the OASIS parent style's name. it's its display name!
+        style.addAttribute( "style:parent-style-name", m_parent->name() );
+
+    if ( featureSet( SAlignX ) && alignX() != Format::Undefined )
+    {
+        TQString value;
+        switch( alignX() )
+        {
+        case Format::Center:
+            value = "center";
+            break;
+        case Format::Right:
+            value = "end";
+            break;
+        case Format::Left:
+            value = "start";
+            break;
+        case Format::Undefined:
+            break;
+        }
+        if ( !value.isEmpty() )
+        {
+            style.addProperty( "style:text-align-source", "fix" ); // table-cell-properties
+            style.addProperty( "fo:text-align", value, KoGenStyle::ParagraphType );
+        }
+    }
+
+    if ( featureSet( SAlignY ) )
+    {
+        TQString value;
+        switch( alignY() )
+        {
+        case Format::Top:
+            value = "top";
+            break;
+        case Format::Middle:
+            value = "middle";
+            break;
+        case Format::Bottom:
+            value = "bottom";
+            break;
+        case Format::UndefinedY:
+        default:
+            break;
+        }
+        if (!value.isEmpty()) // sanity
+            style.addProperty( "style:vertical-align", value );
+    }
+
+    if ( featureSet( SBackgroundColor ) && m_bgColor != TQColor() && m_bgColor.isValid() )
+        style.addProperty( "fo:background-color", colorName(m_bgColor) );
+
+    if ( featureSet( SMultiRow ) && hasProperty( PMultiRow ) )
+        style.addProperty( "fo:wrap-option", "wrap" );
+
+    if ( featureSet( SVerticalText ) && hasProperty( PVerticalText ) )
+    {
+        style.addProperty( "style:direction", "ttb" );
+        style.addProperty( "style:rotation-angle", "0" );
+        style.addProperty( "style:rotation-align", "none" );
+    }
+#if 0
+    if ( featureSet( SFloatFormat ) )
+        format.setAttribute( "float", (int) m_floatFormat );
+
+    if ( featureSet( SFloatColor ) )
+        format.setAttribute( "floatcolor", (int)m_floatColor );
+
+    if ( featureSet( SCustomFormat ) && !strFormat().isEmpty() )
+        format.setAttribute( "custom", m_strFormat );
+
+    if ( featureSet( SFormatType ) && formatType() == Format::Money )
+    {
+        format.setAttribute( "type", (int) m_currency.type );
+        format.setAttribute( "symbol", m_currency.symbol );
+    }
+#endif
+    if ( featureSet( SAngle ) && m_rotateAngle != 0 )
+    {
+        style.addProperty( "style:rotation-align", "none" );
+        style.addProperty( "style:rotation-angle", TQString::number( -1.0 *m_rotateAngle  ) );
+    }
+
+    if ( featureSet( SIndent ) && m_indent != 0.0 )
+    {
+        style.addPropertyPt("fo:margin-left", m_indent, KoGenStyle::ParagraphType );
+        //FIXME
+        //if ( a == Format::Undefined )
+        //currentCellStyle.addProperty("fo:text-align", "start" );
+    }
+
+    if ( featureSet( SDontPrintText ) && hasProperty( PDontPrintText ) )
+        style.addProperty( "style:print-content", "false");
+
+    // protection
+    bool hideAll = false;
+    bool hideFormula = false;
+    bool isNotProtected = false;
+
+    if ( featureSet( SNotProtected ) && hasProperty( PNotProtected ) )
+        isNotProtected = true;
+
+    if ( featureSet( SHideAll ) && hasProperty( PHideAll ) )
+        hideAll=true;
+
+    if ( featureSet( SHideFormula ) && hasProperty( PHideFormula ) )
+        hideFormula = true;
+
+    if ( hideAll )
+        style.addProperty( "style:cell-protect", "hidden-and-protected" );
+    else
+    {
+        if ( isNotProtected && !hideFormula )
+            style.addProperty( "style:cell-protect", "none" );
+        else if ( isNotProtected && hideFormula )
+            style.addProperty( "style:cell-protect", "formula-hidden" );
+        else if ( hideFormula )
+            style.addProperty( "style:cell-protect", "protected formula-hidden" );
+        else if ( featureSet( SNotProtected ) && !hasProperty( PNotProtected ) )
+            // write out, only if it is explicity set
+            style.addProperty( "style:cell-protect", "protected" );
+    }
+
+    // borders
+    // NOTE Stefan: TQPen api docs:
+    //              For horizontal and vertical lines a line width of 0 is
+    //              the same as a line width of 1.
+    //              A line width of 0 will produce a 1 pixel wide line using
+    //              a fast algorithm for diagonals. A line width of 1 will
+    //              also produce a 1 pixel wide line, but uses a slower more
+    //              accurate algorithm for diagonals.
+    if ( featureSet( SLeftBorder ) && featureSet( SRightBorder ) &&
+         featureSet( STopBorder ) && featureSet( SBottomBorder ) &&
+         ( m_leftBorderPen == m_topBorderPen ) &&
+         ( m_leftBorderPen == m_rightBorderPen ) &&
+         ( m_leftBorderPen == m_bottomBorderPen ) )
+    {
+      if ( m_leftBorderPen.style() != TQt::NoPen )
+            style.addProperty("fo:border", convertOasisPenToString( m_leftBorderPen ) );
+    }
+    else
+    {
+        if ( featureSet( SLeftBorder ) && ( m_leftBorderPen.style() != TQt::NoPen ) )
+            style.addProperty( "fo:border-left", convertOasisPenToString( m_leftBorderPen ) );
+
+        if ( featureSet( SRightBorder ) && ( m_rightBorderPen.style() != TQt::NoPen ) )
+            style.addProperty( "fo:border-right", convertOasisPenToString( m_rightBorderPen ) );
+
+        if ( featureSet( STopBorder ) && ( m_topBorderPen.style() != TQt::NoPen ) )
+            style.addProperty( "fo:border-top", convertOasisPenToString( m_topBorderPen ) );
+
+        if ( featureSet( SBottomBorder ) && ( m_bottomBorderPen.style() != TQt::NoPen ) )
+            style.addProperty( "fo:border-bottom", convertOasisPenToString( m_bottomBorderPen ) );
+    }
+    if ( featureSet( SFallDiagonal ) && ( m_fallDiagonalPen.style() != TQt::NoPen ) )
+    {
+        style.addProperty("style:diagonal-tl-br", convertOasisPenToString( m_fallDiagonalPen ) );
+    }
+    if ( featureSet( SGoUpDiagonal ) && ( m_goUpDiagonalPen.style() != TQt::NoPen ) )
+    {
+        style.addProperty("style:diagonal-bl-tr", convertOasisPenToString(m_goUpDiagonalPen ) );
+    }
+
+    // font
+    if ( featureSet( SFontFamily ) ) // !m_fontFamily.isEmpty() == true
+    {
+        style.addProperty("fo:font-family", m_fontFamily, KoGenStyle::TextType );
+    }
+    if ( featureSet( SFontSize ) ) // m_fontSize != 0
+    {
+        style.addPropertyPt("fo:font-size",m_fontSize, KoGenStyle::TextType  );
+    }
+
+    if ( featureSet( SFontFlag ) && m_fontFlags & (uint) FBold )
+        style.addProperty("fo:font-weight","bold", KoGenStyle::TextType );
+
+    if ( featureSet( SFontFlag ) && m_fontFlags & (uint) FItalic )
+        style.addProperty("fo:font-style", "italic", KoGenStyle::TextType );
+
+    if ( featureSet( SFontFlag ) && m_fontFlags & (uint) FUnderline )
+    {
+        //style:text-underline-style="solid" style:text-underline-width="auto"
+        style.addProperty( "style:text-underline-style", "solid", KoGenStyle::TextType );
+        //copy from oo-129
+        style.addProperty( "style:text-underline-width", "auto", KoGenStyle::TextType );
+        style.addProperty( "style:text-underline-color", "font-color", KoGenStyle::TextType );
+    }
+
+    if ( featureSet( SFontFlag ) && m_fontFlags & (uint) FStrike )
+        style.addProperty( "style:text-line-through-style", "solid", KoGenStyle::TextType );
+
+    if ( featureSet( STextPen ) && m_textPen.color().isValid() ) // always save; default: m_textPen.style() == TQt::NoPen
+    {
+        style.addProperty("fo:color", colorName(m_textPen.color()), KoGenStyle::TextType );
+    }
+
+    //I don't think there is a reason why the background brush should be saved if it is null,
+    //but remove the check if it causes problems.  -- Robert Knight <[email protected]>
+    if ( featureSet( SBackgroundBrush ) && (m_backGroundBrush.style() != TQt::NoBrush) )
+    {
+        TQString tmp = saveOasisBackgroundStyle( mainStyles, m_backGroundBrush );
+        if ( !tmp.isEmpty() )
+            style.addProperty("draw:style-name", tmp );
+    }
+
+    TQString _prefix;
+    TQString _postfix;
+    int _precision = -1;
+    if ( featureSet( SPrefix ) && !prefix().isEmpty() )
+        _prefix = m_prefix;
+    if ( featureSet( SPostfix ) && !postfix().isEmpty() )
+        _postfix = m_postfix;
+    if ( featureSet( SPrecision ) && m_precision != -1 )
+        _precision =  m_precision;
+
+    TQString symbol;
+    if ( featureSet( SFormatType ) && m_formatType == Money_format )
+    {
+      symbol = Currency::getCurrencyCode(m_currency.type);
+    }
+
+    TQString numericStyle = saveOasisStyleNumeric( style, mainStyles, m_formatType,
+                                                  _prefix, _postfix, _precision,
+                                                  symbol );
+    if ( !numericStyle.isEmpty() )
+        style.addAttribute( "style:data-style-name", numericStyle );
+}
+
+TQString Style::saveOasisBackgroundStyle( KoGenStyles &mainStyles, const TQBrush &brush )
+{
+    KoGenStyle styleobjectauto = KoGenStyle( KoGenStyle::STYLE_GRAPHICAUTO, "graphic" );
+    KoOasisStyles::saveOasisFillStyle( styleobjectauto, mainStyles, brush );
+    return mainStyles.lookup( styleobjectauto, "gr" );
+}
+
+void Style::saveXML( TQDomDocument & doc, TQDomElement & format ) const
+{
+  if ( featureSet( SAlignX ) && alignX() != Format::Undefined )
+    format.setAttribute( "alignX", (int) m_alignX );
+
+  if ( featureSet( SAlignY ) && alignY() != Format::Middle )
+    format.setAttribute( "alignY", (int) m_alignY );
+
+  if ( featureSet( SBackgroundColor ) && m_bgColor != TQColor() && m_bgColor.isValid() )
+    format.setAttribute( "bgcolor", m_bgColor.name() );
+
+  if ( featureSet( SMultiRow ) && hasProperty( PMultiRow ) )
+    format.setAttribute( "multirow", "yes" );
+
+  if ( featureSet( SVerticalText ) && hasProperty( PVerticalText ) )
+    format.setAttribute( "verticaltext", "yes" );
+
+  if ( featureSet( SPrecision ) )
+    format.setAttribute( "precision", m_precision );
+
+  if ( featureSet( SPrefix ) && !prefix().isEmpty() )
+    format.setAttribute( "prefix", m_prefix );
+
+  if ( featureSet( SPostfix ) && !postfix().isEmpty() )
+    format.setAttribute( "postfix", m_postfix );
+
+  if ( featureSet( SFloatFormat ) )
+    format.setAttribute( "float", (int) m_floatFormat );
+
+  if ( featureSet( SFloatColor ) )
+  format.setAttribute( "floatcolor", (int)m_floatColor );
+
+  if ( featureSet( SFormatType ) )
+    format.setAttribute( "format",(int) m_formatType );
+
+  if ( featureSet( SCustomFormat ) && !strFormat().isEmpty() )
+    format.setAttribute( "custom", m_strFormat );
+
+  if ( featureSet( SFormatType ) && formatType() == Money_format )
+  {
+    format.setAttribute( "type", (int) m_currency.type );
+    format.setAttribute( "symbol", m_currency.symbol );
+  }
+
+  if ( featureSet( SAngle ) )
+    format.setAttribute( "angle", m_rotateAngle );
+
+  if ( featureSet( SIndent ) )
+    format.setAttribute( "indent", m_indent );
+
+  if ( featureSet( SDontPrintText ) && hasProperty( PDontPrintText ) )
+    format.setAttribute( "dontprinttext", "yes" );
+
+  if ( featureSet( SNotProtected ) && hasProperty( PNotProtected ) )
+    format.setAttribute( "noprotection", "yes" );
+
+  if ( featureSet( SHideAll ) && hasProperty( PHideAll ) )
+    format.setAttribute( "hideall", "yes" );
+
+  if ( featureSet( SHideFormula ) && hasProperty( PHideFormula ) )
+    format.setAttribute( "hideformula", "yes" );
+
+  if ( featureSet( SFontFamily ) )
+    format.setAttribute( "font-family", m_fontFamily );
+  if ( featureSet( SFontSize ) )
+    format.setAttribute( "font-size", m_fontSize );
+  if ( featureSet( SFontFlag ) )
+    format.setAttribute( "font-flags", m_fontFlags );
+
+  //  if ( featureSet( SFont ) )
+  //    format.appendChild( util_createElement( "font", m_textFont, doc ) );
+
+  if ( featureSet( STextPen ) && m_textPen.color().isValid() )
+    format.appendChild( util_createElement( "pen", m_textPen, doc ) );
+
+  if ( featureSet( SBackgroundBrush ) )
+  {
+    format.setAttribute( "brushcolor", m_backGroundBrush.color().name() );
+    format.setAttribute( "brushstyle", (int) m_backGroundBrush.style() );
+  }
+
+  if ( featureSet( SLeftBorder ) )
+  {
+    TQDomElement left = doc.createElement( "left-border" );
+    left.appendChild( util_createElement( "pen", m_leftBorderPen, doc ) );
+    format.appendChild( left );
+  }
+
+  if ( featureSet( STopBorder ) )
+  {
+    TQDomElement top = doc.createElement( "top-border" );
+    top.appendChild( util_createElement( "pen", m_topBorderPen, doc ) );
+    format.appendChild( top );
+  }
+
+  if ( featureSet( SRightBorder ) )
+  {
+    TQDomElement right = doc.createElement( "right-border" );
+    right.appendChild( util_createElement( "pen", m_rightBorderPen, doc ) );
+    format.appendChild( right );
+  }
+
+  if ( featureSet( SBottomBorder ) )
+  {
+    TQDomElement bottom = doc.createElement( "bottom-border" );
+    bottom.appendChild( util_createElement( "pen", m_bottomBorderPen, doc ) );
+    format.appendChild( bottom );
+  }
+
+  if ( featureSet( SFallDiagonal ) )
+  {
+    TQDomElement fallDiagonal  = doc.createElement( "fall-diagonal" );
+    fallDiagonal.appendChild( util_createElement( "pen", m_fallDiagonalPen, doc ) );
+    format.appendChild( fallDiagonal );
+  }
+
+  if ( featureSet( SGoUpDiagonal ) )
+  {
+    TQDomElement goUpDiagonal = doc.createElement( "up-diagonal" );
+    goUpDiagonal.appendChild( util_createElement( "pen", m_goUpDiagonalPen, doc ) );
+    format.appendChild( goUpDiagonal );
+  }
+}
+
+bool Style::loadXML( TQDomElement & format )
+{
+  bool ok;
+  if ( format.hasAttribute( "type" ) )
+  {
+    m_type = (StyleType) format.attribute( "type" ).toInt( &ok );
+    if ( !ok )
+      return false;
+  }
+
+  if ( format.hasAttribute( "alignX" ) )
+  {
+    Format::Align a = (Format::Align) format.attribute( "alignX" ).toInt( &ok );
+    if ( !ok )
+      return false;
+    if ( (unsigned int) a >= 1 || (unsigned int) a <= 4 )
+    {
+      m_alignX = a;
+      m_featuresSet |= SAlignX;
+    }
+  }
+  if ( format.hasAttribute( "alignY" ) )
+  {
+    Format::AlignY a = (Format::AlignY) format.attribute( "alignY" ).toInt( &ok );
+    if ( !ok )
+      return false;
+    if ( (unsigned int) a >= 1 || (unsigned int) a < 4 )
+    {
+      m_alignY = a;
+      m_featuresSet |= SAlignY;
+    }
+  }
+
+  if ( format.hasAttribute( "bgcolor" ) )
+  {
+    m_bgColor = TQColor( format.attribute( "bgcolor" ) );
+    // FIXME: Is white always correct here?
+    if ( m_bgColor != TQt::white )
+	m_featuresSet |= SBackgroundColor;
+  }
+
+  if ( format.hasAttribute( "multirow" ) )
+  {
+    setProperty( PMultiRow );
+    m_featuresSet |= SMultiRow;
+  }
+
+  if ( format.hasAttribute( "verticaltext" ) )
+  {
+    setProperty( PVerticalText );
+    m_featuresSet |= SVerticalText;
+  }
+
+  if ( format.hasAttribute( "precision" ) )
+  {
+    int i = format.attribute( "precision" ).toInt( &ok );
+    if ( i < -1 )
+    {
+      kdDebug(36001) << "Value out of range Cell::precision=" << i << endl;
+      return false;
+    }
+    m_precision = i;
+    m_featuresSet |= SPrecision;
+  }
+
+  if ( format.hasAttribute( "float" ) )
+  {
+    Format::FloatFormat a = (Format::FloatFormat)format.attribute( "float" ).toInt( &ok );
+    if ( !ok )
+      return false;
+    if ( (unsigned int) a >= 1 || (unsigned int) a <= 3 )
+    {
+      m_floatFormat = a;
+      m_featuresSet |= SFloatFormat;
+    }
+  }
+
+  if ( format.hasAttribute( "floatcolor" ) )
+  {
+    Format::FloatColor a = (Format::FloatColor) format.attribute( "floatcolor" ).toInt( &ok );
+    if ( !ok ) return false;
+    if ( (unsigned int) a >= 1 || (unsigned int) a <= 2 )
+    {
+      m_floatColor = a;
+      m_featuresSet |= SFloatColor;
+    }
+  }
+
+  if ( format.hasAttribute( "format" ) )
+  {
+    int fo = format.attribute( "format" ).toInt( &ok );
+    if ( ! ok )
+      return false;
+    m_formatType = ( FormatType ) fo;
+    m_featuresSet |= SFormatType;
+  }
+  if ( format.hasAttribute( "custom" ) )
+  {
+    m_strFormat = format.attribute( "custom" );
+    m_featuresSet |= SCustomFormat;
+  }
+  if ( m_formatType == Money_format )
+  {
+    if ( format.hasAttribute( "type" ) )
+    {
+      m_currency.type   = format.attribute( "type" ).toInt( &ok );
+      if (!ok)
+        m_currency.type = 1;
+    }
+    if ( format.hasAttribute( "symbol" ) )
+    {
+      m_currency.symbol = format.attribute( "symbol" );
+    }
+    m_featuresSet |= SFormatType;
+  }
+  if ( format.hasAttribute( "angle" ) )
+  {
+    m_rotateAngle = format.attribute( "angle" ).toInt( &ok );
+    if ( !ok )
+      return false;
+    m_featuresSet |= SAngle;
+  }
+  if ( format.hasAttribute( "indent" ) )
+  {
+    m_indent = format.attribute( "indent" ).toDouble( &ok );
+    if ( !ok )
+      return false;
+    m_featuresSet |= SIndent;
+  }
+  if ( format.hasAttribute( "dontprinttext" ) )
+  {
+    setProperty( PDontPrintText );
+    m_featuresSet |= SDontPrintText;
+  }
+
+  if ( format.hasAttribute( "noprotection" ) )
+  {
+    setProperty( PNotProtected );
+    m_featuresSet |= SNotProtected;
+  }
+
+  if ( format.hasAttribute( "hideall" ) )
+  {
+    setProperty( PHideAll );
+    m_featuresSet |= SHideAll;
+  }
+
+  if ( format.hasAttribute( "hideformula" ) )
+  {
+    setProperty( PHideFormula );
+    m_featuresSet |= SHideFormula;
+  }
+
+  // TODO: remove that...
+  TQDomElement font = format.namedItem( "font" ).toElement();
+  if ( !font.isNull() )
+  {
+    TQFont f( util_toFont( font ) );
+    m_fontFamily = f.family();
+    m_fontSize = f.pointSize();
+    if ( f.italic() )
+      m_fontFlags |= FItalic;
+    if ( f.bold() )
+      m_fontFlags |= FBold;
+    if ( f.underline() )
+      m_fontFlags |= FUnderline;
+    if ( f.strikeOut() )
+      m_fontFlags |= FStrike;
+
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFamily;
+    m_featuresSet |= SFontFlag;
+    m_featuresSet |= SFontSize;
+  }
+
+  if ( format.hasAttribute( "font-family" ) )
+  {
+    m_fontFamily = format.attribute( "font-family" );
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFamily;
+  }
+  if ( format.hasAttribute( "font-size" ) )
+  {
+    m_fontSize = format.attribute( "font-size" ).toInt( &ok );
+    if ( !ok )
+      return false;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontSize;
+  }
+
+  if ( format.hasAttribute( "font-flags" ) )
+  {
+    m_fontFlags = format.attribute( "font-flags" ).toInt( &ok );
+    if ( !ok )
+      return false;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+
+  if ( format.hasAttribute( "brushcolor" ) )
+  {
+    m_backGroundBrush.setColor( TQColor( format.attribute( "brushcolor" ) ) );
+    // It is not necessary to set this feature just because the color changes.
+    // FIXME: Or is it?
+    //m_featuresSet |= SBackgroundBrush;
+  }
+
+  if ( format.hasAttribute( "brushstyle" ) )
+  {
+    m_backGroundBrush.setStyle( (Qt::BrushStyle) format.attribute( "brushstyle" ).toInt( &ok )  );
+    if ( !ok )
+      return false;
+
+    if ( m_backGroundBrush.style() != TQt::NoBrush )
+	m_featuresSet |= SBackgroundBrush;
+  }
+
+  TQDomElement pen = format.namedItem( "pen" ).toElement();
+  if ( !pen.isNull() )
+  {
+    m_textPen = util_toPen( pen );
+    if ( m_textPen.style() != TQt::NoPen )
+	m_featuresSet |= STextPen;
+  }
+
+  TQDomElement left = format.namedItem( "left-border" ).toElement();
+  if ( !left.isNull() )
+  {
+    TQDomElement pen = left.namedItem( "pen" ).toElement();
+    if ( !pen.isNull() )
+    {
+      m_leftBorderPen = util_toPen( pen );
+      if ( m_leftBorderPen.style() != TQt::NoPen )
+	  m_featuresSet |= SLeftBorder;
+    }
+  }
+
+  TQDomElement top = format.namedItem( "top-border" ).toElement();
+  if ( !top.isNull() )
+  {
+    TQDomElement pen = top.namedItem( "pen" ).toElement();
+    if ( !pen.isNull() )
+    {
+      m_topBorderPen = util_toPen( pen );
+      if ( m_topBorderPen.style() != TQt::NoPen )
+	  m_featuresSet |= STopBorder;
+    }
+  }
+
+  TQDomElement right = format.namedItem( "right-border" ).toElement();
+  if ( !right.isNull() )
+  {
+    TQDomElement pen = right.namedItem( "pen" ).toElement();
+    if ( !pen.isNull() )
+    {
+      m_rightBorderPen = util_toPen( pen );
+      if ( m_rightBorderPen.style() != TQt::NoPen )
+	  m_featuresSet |= SRightBorder;
+    }
+  }
+
+  TQDomElement bottom = format.namedItem( "bottom-border" ).toElement();
+  if ( !bottom.isNull() )
+  {
+    TQDomElement pen = bottom.namedItem( "pen" ).toElement();
+    if ( !pen.isNull() )
+    {
+      m_bottomBorderPen = util_toPen( pen );
+      if ( m_bottomBorderPen.style() != TQt::NoPen )
+	  m_featuresSet |= SBottomBorder;
+    }
+  }
+
+  TQDomElement fallDiagonal = format.namedItem( "fall-diagonal" ).toElement();
+  if ( !fallDiagonal.isNull() )
+  {
+    TQDomElement pen = fallDiagonal.namedItem( "pen" ).toElement();
+    if ( !pen.isNull() )
+    {
+      m_fallDiagonalPen = util_toPen( pen );
+      if ( m_fallDiagonalPen.style() != TQt::NoPen )
+	  m_featuresSet |= SFallDiagonal;
+    }
+  }
+
+  TQDomElement goUpDiagonal = format.namedItem( "up-diagonal" ).toElement();
+  if ( !goUpDiagonal.isNull() )
+  {
+    TQDomElement pen = goUpDiagonal.namedItem( "pen" ).toElement();
+    if ( !pen.isNull() )
+    {
+      m_goUpDiagonalPen = util_toPen( pen );
+      if ( m_goUpDiagonalPen.style() != TQt::NoPen )
+	  m_featuresSet |= SGoUpDiagonal;
+    }
+  }
+
+  if ( format.hasAttribute( "prefix" ) )
+  {
+    m_prefix = format.attribute( "prefix" );
+    m_featuresSet |= SPrefix;
+  }
+  if ( format.hasAttribute( "postfix" ) )
+  {
+    m_postfix = format.attribute( "postfix" );
+    m_featuresSet |= SPostfix;
+  }
+
+  return true;
+}
+
+void Style::setParent( CustomStyle * parent )
+{
+  m_parent = parent;
+  if ( m_parent )
+    m_parentName = m_parent->name();
+}
+
+CustomStyle * Style::parent() const
+{
+  return m_parent;
+}
+
+bool Style::release()
+{
+  --m_usageCount;
+
+  if ( m_type == CUSTOM || m_type == BUILTIN )
+    return false; // never delete builtin styles...
+
+  if ( m_usageCount < 1 )
+    return true;
+
+  return false;
+}
+
+void Style::addRef()
+{
+  ++m_usageCount;
+}
+
+bool Style::hasProperty( Properties p ) const
+{
+  FlagsSet f;
+  switch( p )
+  {
+   case PDontPrintText:
+    f = SDontPrintText;
+    break;
+   case PCustomFormat:
+    f = SCustomFormat;
+    break;
+   case PNotProtected:
+    f = SNotProtected;
+    break;
+   case PHideAll:
+    f = SHideAll;
+    break;
+   case PHideFormula:
+    f = SHideFormula;
+    break;
+   case PMultiRow:
+    f = SMultiRow;
+    break;
+   case PVerticalText:
+    f = SVerticalText;
+    break;
+   default:
+    kdWarning() << "Unhandled property" << endl;
+    return ( m_properties  & (uint) p );
+  }
+
+  return ( !m_parent || featureSet( f ) ? ( m_properties & (uint) p ) : m_parent->hasProperty( p ) );
+}
+
+bool Style::hasFeature( FlagsSet f, bool withoutParent ) const
+{
+  bool b = ( m_featuresSet & (uint) f );
+
+  // check if feature is defined here or at parent level
+  if ( m_parent && !withoutParent )
+    b = ( m_parent->hasFeature( f, withoutParent ) ? true : b );
+
+  return b;
+}
+
+void Style::clearFeature( FlagsSet f )
+{
+  m_featuresSet &= ~(uint)f;
+}
+
+TQFont Style::font() const
+{
+  TQString family = fontFamily();
+  int  size      = fontSize();
+  uint ff        = fontFlags();
+
+  TQFont f( family, size );
+  if ( ff & (uint) FBold )
+    f.setBold( true );
+  if ( ff & (uint) FItalic )
+    f.setItalic( true );
+  if ( ff & (uint) FUnderline )
+    f.setUnderline( true );
+  if ( ff & (uint) FStrike )
+    f.setStrikeOut( true );
+
+  return f;
+}
+
+TQString const & Style::fontFamily() const
+{
+  return ( !m_parent || featureSet( SFontFamily ) ? m_fontFamily : m_parent->fontFamily() );
+}
+
+uint Style::fontFlags() const
+{
+  return ( !m_parent || featureSet( SFontFlag ) ? m_fontFlags : m_parent->fontFlags() );
+}
+
+int Style::fontSize() const
+{
+  return ( !m_parent || featureSet( SFontSize ) ? m_fontSize : m_parent->fontSize() );
+}
+
+TQPen const & Style::pen() const
+{
+  return ( !m_parent || featureSet( STextPen ) ? m_textPen : m_parent->pen() );
+}
+
+TQColor const & Style::bgColor() const
+{
+  return ( !m_parent || featureSet( SBackgroundColor ) ? m_bgColor : m_parent->bgColor() );
+}
+
+TQPen const & Style::rightBorderPen() const
+{
+  return ( !m_parent || featureSet( SRightBorder ) ? m_rightBorderPen : m_parent->rightBorderPen() );
+}
+
+TQPen const & Style::bottomBorderPen() const
+{
+  return ( !m_parent || featureSet( SBottomBorder ) ? m_bottomBorderPen : m_parent->bottomBorderPen() );
+}
+
+TQPen const & Style::leftBorderPen() const
+{
+  return ( !m_parent || featureSet( SLeftBorder ) ? m_leftBorderPen : m_parent->leftBorderPen() );
+}
+
+TQPen const & Style::topBorderPen() const
+{
+  return ( !m_parent || featureSet( STopBorder ) ? m_topBorderPen : m_parent->topBorderPen() );
+}
+
+TQPen const & Style::fallDiagonalPen() const
+{
+  return ( !m_parent || featureSet( SFallDiagonal ) ? m_fallDiagonalPen : m_parent->fallDiagonalPen() );
+}
+
+TQPen const & Style::goUpDiagonalPen() const
+{
+  return ( !m_parent || featureSet( SGoUpDiagonal ) ? m_goUpDiagonalPen : m_parent->goUpDiagonalPen() );
+}
+
+int Style::precision() const
+{
+  return ( !m_parent || featureSet( SPrecision ) ? m_precision : m_parent->precision() );
+}
+
+int Style::rotateAngle() const
+{
+  return ( !m_parent || featureSet( SAngle ) ? m_rotateAngle : m_parent->rotateAngle() );
+}
+
+double Style::indent() const
+{
+  return ( !m_parent || featureSet( SIndent ) ? m_indent : m_parent->indent() );
+}
+
+TQBrush const & Style::backGroundBrush() const
+{
+  return ( !m_parent || featureSet( SBackgroundBrush ) ? m_backGroundBrush : m_parent->backGroundBrush() );
+}
+
+Format::Align Style::alignX() const
+{
+  return ( !m_parent || featureSet( SAlignX ) ? m_alignX : m_parent->alignX() );
+}
+
+Format::AlignY Style::alignY() const
+{
+  return ( !m_parent || featureSet( SAlignY ) ? m_alignY : m_parent->alignY() );
+}
+
+Format::FloatFormat Style::floatFormat() const
+{
+  return ( !m_parent || featureSet( SFloatFormat ) ? m_floatFormat : m_parent->floatFormat() );
+}
+
+Format::FloatColor Style::floatColor() const
+{
+  return ( !m_parent || featureSet( SFloatColor ) ? m_floatColor : m_parent->floatColor() );
+}
+
+FormatType Style::formatType() const
+{
+  return ( !m_parent || featureSet( SFormatType ) ? m_formatType : m_parent->formatType() );
+}
+
+Format::Currency const & Style::currency() const
+{
+  return ( !m_parent || featureSet( SFormatType ) ? m_currency : m_parent->currency() );
+}
+
+TQString const & Style::strFormat() const
+{
+  return ( !m_parent || featureSet( SCustomFormat ) ? m_strFormat : m_parent->strFormat() );
+}
+
+TQString const & Style::prefix() const
+{
+  return ( !m_parent || featureSet( SPrefix ) ? m_prefix : m_parent->prefix() );
+}
+
+TQString const & Style::postfix() const
+{
+  return ( !m_parent || featureSet( SPostfix ) ? m_postfix : m_parent->postfix() );
+}
+
+
+
+Style * Style::setAlignX( Format::Align alignX )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_alignX = alignX;
+    style->m_featuresSet |= SAlignX;
+    return style;
+  }
+
+  m_alignX      = alignX;
+  m_featuresSet |= SAlignX;
+  return this;
+}
+
+Style * Style::setAlignY( Format::AlignY alignY )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_alignY = alignY;
+    style->m_featuresSet |= SAlignY;
+    return style;
+  }
+
+  m_alignY = alignY;
+  m_featuresSet |= SAlignY;
+  return this;
+}
+
+Style * Style::setFont( TQFont const & f )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    if ( style->m_fontFamily != f.family() )
+    {
+      style->m_fontFamily = f.family();
+      style->m_featuresSet |= SFont;
+      style->m_featuresSet |= SFontFamily;
+    }
+    if ( style->m_fontSize != f.pointSize() )
+    {
+      style->m_fontSize = f.pointSize();
+      style->m_featuresSet |= SFont;
+      style->m_featuresSet |= SFontSize;
+    }
+    if ( f.italic() != (m_fontFlags & (uint) FItalic ) )
+    {
+      if ( f.italic() )
+        style->m_fontFlags |= FItalic;
+      else
+        style->m_fontFlags &= ~(uint) FItalic;
+      style->m_featuresSet |= SFont;
+      style->m_featuresSet |= SFontFlag;
+    }
+    if ( f.bold() != (m_fontFlags & (uint) FBold ) )
+    {
+      if ( f.bold() )
+        style->m_fontFlags |= FBold;
+      else
+        style->m_fontFlags &= ~(uint) FBold;
+      style->m_featuresSet |= SFont;
+      style->m_featuresSet |= SFontFlag;
+    }
+    if ( f.underline() != (m_fontFlags & (uint) FUnderline ) )
+    {
+      if ( f.underline() )
+        style->m_fontFlags |= FUnderline;
+      else
+        style->m_fontFlags &= ~(uint) FUnderline;
+      style->m_featuresSet |= SFont;
+      style->m_featuresSet |= SFontFlag;
+    }
+    if ( f.strikeOut() != (m_fontFlags & (uint) FStrike ) )
+    {
+      if ( f.strikeOut() )
+        style->m_fontFlags |= FStrike;
+      else
+        style->m_fontFlags &= ~(uint) FStrike;
+      style->m_featuresSet |= SFont;
+      style->m_featuresSet |= SFontFlag;
+    }
+
+    return style;
+  }
+
+  if ( m_fontFamily != f.family() )
+  {
+    m_fontFamily = f.family();
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFamily;
+  }
+  if ( m_fontSize != f.pointSize() )
+  {
+    m_fontSize = f.pointSize();
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontSize;
+  }
+  if ( f.italic() != (m_fontFlags & (uint) FItalic ) )
+  {
+    if ( f.italic() )
+      m_fontFlags |= FItalic;
+    else
+      m_fontFlags &= ~(uint) FItalic;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+  if ( f.bold() != (m_fontFlags & (uint) FBold ) )
+  {
+    if ( f.bold() )
+      m_fontFlags |= FBold;
+    else
+      m_fontFlags &= ~(uint) FBold;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+  if ( f.underline() != (m_fontFlags & (uint) FUnderline ) )
+  {
+    if ( f.underline() )
+      m_fontFlags |= FUnderline;
+    else
+      m_fontFlags &= ~(uint) FUnderline;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+  if ( f.strikeOut() != (m_fontFlags & (uint) FStrike ) )
+  {
+    if ( f.strikeOut() )
+      m_fontFlags |= FStrike;
+    else
+      m_fontFlags &= ~(uint) FStrike;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+
+  return this;
+}
+
+Style * Style::setFontFamily( TQString const & fam )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    if ( m_fontFamily != fam )
+    {
+      Style * style  = new Style( this );
+      style->m_fontFamily   = fam;
+      style->m_featuresSet |= SFontFamily;
+      style->m_featuresSet |= SFont;
+      return style;
+    }
+    return this;
+  }
+
+  m_fontFamily   = fam;
+  m_featuresSet |= SFont;
+  m_featuresSet |= SFontFamily;
+  return this;
+}
+
+Style * Style::setFontFlags( uint flags )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    if ( m_fontFlags != flags )
+    {
+      Style * style = new Style( this );
+      style->m_fontFlags = flags;
+      style->m_featuresSet |= SFontFlag;
+      style->m_featuresSet |= SFont;
+      return style;
+    }
+    return this;
+  }
+
+  m_fontFlags    = flags;
+  m_featuresSet |= SFont;
+  m_featuresSet |= SFontFlag;
+  return this;
+}
+
+Style * Style::setFontSize( int size )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    if ( m_fontSize != size )
+    {
+      Style * style  = new Style( this );
+      style->m_fontSize     = size;
+      style->m_featuresSet |= SFontSize;
+      style->m_featuresSet |= SFont;
+      return style;
+    }
+    return this;
+  }
+
+  m_fontSize     = size;
+  m_featuresSet |= SFont;
+  m_featuresSet |= SFontSize;
+  return this;
+}
+
+Style * Style::setPen( TQPen const & pen )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_textPen = pen;
+    if ( style->m_textPen.style() != TQt::NoPen )
+	style->m_featuresSet |= STextPen;
+    return style;
+  }
+
+  m_textPen = pen;
+  if ( m_textPen.style() != TQt::NoPen )
+      m_featuresSet |= STextPen;
+  return this;
+}
+
+Style * Style::setBgColor( TQColor const & color )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_bgColor = color;
+    if ( style->m_bgColor != TQt::white )
+	style->m_featuresSet |= SBackgroundColor;
+    return style;
+  }
+
+  m_bgColor = color;
+  if ( m_bgColor != TQt::white )
+      m_featuresSet |= SBackgroundColor;
+  return this;
+}
+
+Style * Style::setRightBorderPen( TQPen const & pen )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_rightBorderPen = pen;
+    style->m_rightPenValue = calculateValue( pen );
+    if ( style->m_rightBorderPen.style() != TQt::NoPen )
+	style->m_featuresSet |= SRightBorder;
+    return style;
+  }
+
+  m_rightBorderPen = pen;
+  m_rightPenValue = calculateValue( pen );
+  if ( m_rightBorderPen.style() != TQt::NoPen )
+      m_featuresSet |= SRightBorder;
+  return this;
+}
+
+Style * Style::setBottomBorderPen( TQPen const & pen )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_bottomBorderPen = pen;
+    style->m_bottomPenValue = calculateValue( pen );
+    if ( style->m_bottomBorderPen.style() != TQt::NoPen )
+        style->m_featuresSet |= SBottomBorder;
+    return style;
+  }
+
+  m_bottomBorderPen = pen;
+  m_bottomPenValue = calculateValue( pen );
+  if ( m_bottomBorderPen.style() != TQt::NoPen )
+      m_featuresSet |= SBottomBorder;
+  return this;
+}
+
+Style * Style::setLeftBorderPen( TQPen const & pen )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_leftBorderPen = pen;
+    style->m_leftPenValue = calculateValue( pen );
+    if ( style->m_leftBorderPen.style() != TQt::NoPen )
+	style->m_featuresSet |= SLeftBorder;
+    return style;
+  }
+
+  m_leftBorderPen = pen;
+  m_leftPenValue = calculateValue( pen );
+  if ( m_leftBorderPen.style() != TQt::NoPen )
+      m_featuresSet |= SLeftBorder;
+  return this;
+}
+
+Style * Style::setTopBorderPen( TQPen const & pen )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_topBorderPen = pen;
+    style->m_topPenValue = calculateValue( pen );
+    if ( style->m_topBorderPen.style() != TQt::NoPen )
+	style->m_featuresSet |= STopBorder;
+    return style;
+  }
+
+  m_topBorderPen = pen;
+  m_topPenValue = calculateValue( pen );
+  if ( m_topBorderPen.style() != TQt::NoPen )
+      m_featuresSet |= STopBorder;
+  return this;
+}
+
+Style * Style::setFallDiagonalPen( TQPen const & pen )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_fallDiagonalPen = pen;
+    if ( style->m_fallDiagonalPen.style() != TQt::NoPen )
+	style->m_featuresSet |= SFallDiagonal;
+    return style;
+  }
+
+  m_fallDiagonalPen = pen;
+  if ( m_fallDiagonalPen.style() != TQt::NoPen )
+      m_featuresSet |= SFallDiagonal;
+  return this;
+}
+
+Style * Style::setGoUpDiagonalPen( TQPen const & pen )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_goUpDiagonalPen = pen;
+    if ( style->m_goUpDiagonalPen.style() != TQt::NoPen )
+	style->m_featuresSet |= SGoUpDiagonal;
+    return style;
+  }
+
+  m_goUpDiagonalPen = pen;
+  if ( m_goUpDiagonalPen.style() != TQt::NoPen )
+      m_featuresSet |= SGoUpDiagonal;
+  return this;
+}
+
+Style * Style::setRotateAngle( int angle )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_rotateAngle = angle;
+    style->m_featuresSet |= SAngle;
+    return style;
+  }
+
+  m_rotateAngle = angle;
+  m_featuresSet |= SAngle;
+  return this;
+}
+
+Style * Style::setIndent( double indent )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_indent = indent;
+    style->m_featuresSet |= SIndent;
+    return style;
+  }
+
+  m_indent = indent;
+  m_featuresSet |= SIndent;
+  return this;
+}
+
+Style * Style::setBackGroundBrush( TQBrush const & brush )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_backGroundBrush = brush;
+    if ( style->m_backGroundBrush.style() != TQt::NoBrush )
+	style->m_featuresSet |= SBackgroundBrush;
+    return style;
+  }
+
+  m_backGroundBrush = brush;
+  if ( m_backGroundBrush.style() != TQt::NoBrush )
+      m_featuresSet |= SBackgroundBrush;
+  return this;
+}
+
+Style * Style::setFloatFormat( Format::FloatFormat format )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_floatFormat = format;
+    style->m_featuresSet |= SFloatFormat;
+    return style;
+  }
+
+  m_floatFormat = format;
+  m_featuresSet |= SFloatFormat;
+  return this;
+}
+
+Style * Style::setFloatColor( Format::FloatColor color )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_floatColor = color;
+    style->m_featuresSet |= SFloatColor;
+    return style;
+  }
+
+  m_floatColor = color;
+  m_featuresSet |= SFloatColor;
+  return this;
+}
+
+Style * Style::setStrFormat( TQString const & strFormat )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_strFormat = strFormat;
+    style->m_featuresSet |= SCustomFormat;
+    return style;
+  }
+
+  m_strFormat = strFormat;
+  m_featuresSet |= SCustomFormat;
+  return this;
+}
+
+Style * Style::setPrecision( int precision )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_precision = precision;
+    style->m_featuresSet |= SPrecision;
+    return style;
+  }
+
+  m_precision = precision;
+  m_featuresSet |= SPrecision;
+  return this;
+}
+
+Style * Style::setPrefix( TQString const & prefix )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_prefix = prefix;
+    style->m_featuresSet |= SPrefix;
+    return style;
+  }
+
+  m_prefix = prefix;
+  m_featuresSet |= SPrefix;
+  return this;
+}
+
+Style * Style::setPostfix( TQString const & postfix )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_postfix = postfix;
+    style->m_featuresSet |= SPostfix;
+    return style;
+  }
+
+  m_postfix = postfix;
+  m_featuresSet |= SPostfix;
+  return this;
+}
+
+Style * Style::setCurrency( Format::Currency const & currency )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_currency = currency;
+    style->m_featuresSet |= SFormatType;
+    return style;
+  }
+
+  m_currency = currency;
+  m_featuresSet |= SFormatType;
+  return this;
+}
+
+Style * Style::setProperty( Properties p )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_properties |= (uint) p;
+    switch( p )
+    {
+     case PDontPrintText:
+      style->m_featuresSet |= SDontPrintText;
+      break;
+     case PCustomFormat:
+      style->m_featuresSet |= SCustomFormat;
+      break;
+     case PNotProtected:
+      style->m_featuresSet |= SNotProtected;
+      break;
+     case PHideAll:
+      style->m_featuresSet |= SHideAll;
+      break;
+     case PHideFormula:
+      style->m_featuresSet |= SHideFormula;
+      break;
+     case PMultiRow:
+      style->m_featuresSet |= SMultiRow;
+      break;
+     case PVerticalText:
+      style->m_featuresSet |= SVerticalText;
+      break;
+     default:
+      kdWarning() << "Unhandled property" << endl;
+    }
+    return style;
+  }
+
+  m_properties |= (uint) p;
+  switch( p )
+  {
+   case PDontPrintText:
+    m_featuresSet |= SDontPrintText;
+    break;
+   case PCustomFormat:
+    m_featuresSet |= SCustomFormat;
+    break;
+   case PNotProtected:
+     m_featuresSet |= SNotProtected;
+    break;
+   case PHideAll:
+    m_featuresSet |= SHideAll;
+    break;
+   case PHideFormula:
+    m_featuresSet |= SHideFormula;
+    break;
+   case PMultiRow:
+    m_featuresSet |= SMultiRow;
+    break;
+   case PVerticalText:
+    m_featuresSet |= SVerticalText;
+    break;
+   default:
+    kdWarning() << "Unhandled property" << endl;
+  }
+  return this;
+}
+
+Style * Style::clearProperty( Properties p )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style = new Style( this );
+    style->m_properties &= ~(uint) p;
+    switch( p )
+    {
+     case PDontPrintText:
+      style->m_featuresSet |= SDontPrintText;
+      break;
+     case PCustomFormat:
+      style->m_featuresSet |= SCustomFormat;
+      break;
+     case PNotProtected:
+      style->m_featuresSet |= SNotProtected;
+      break;
+     case PHideAll:
+      style->m_featuresSet |= SHideAll;
+      break;
+     case PHideFormula:
+      style->m_featuresSet |= SHideFormula;
+      break;
+     case PMultiRow:
+      style->m_featuresSet |= SMultiRow;
+      break;
+     case PVerticalText:
+      style->m_featuresSet |= SVerticalText;
+      break;
+     default:
+      kdWarning() << "Unhandled property" << endl;
+    }
+    return style;
+  }
+
+  m_properties &= ~(uint) p;
+  switch( p )
+  {
+   case PDontPrintText:
+    m_featuresSet |= SDontPrintText;
+    break;
+   case PCustomFormat:
+    m_featuresSet |= SCustomFormat;
+    break;
+   case PNotProtected:
+    m_featuresSet |= SNotProtected;
+    break;
+   case PHideAll:
+    m_featuresSet |= SHideAll;
+    break;
+   case PHideFormula:
+    m_featuresSet |= SHideFormula;
+    break;
+   case PMultiRow:
+    m_featuresSet |= SMultiRow;
+    break;
+   case PVerticalText:
+    m_featuresSet |= SVerticalText;
+    break;
+   default:
+    kdWarning() << "Unhandled property" << endl;
+  }
+  return this;
+}
+
+
+Style * Style::setFormatType( FormatType format )
+{
+  if ( m_type != AUTO || m_usageCount > 1 )
+  {
+    Style * style  = new Style( this );
+    style->m_formatType  = format;
+    style->m_featuresSet |= SFormatType;
+    return style;
+  }
+
+  m_formatType  = format;
+  m_featuresSet |= SFormatType;
+  return this;
+}
+
+TQString Style::colorName( const TQColor& color )
+{
+	static TQMap<TQRgb , TQString> map;
+
+	TQRgb rgb = color.rgb();
+
+	if (!map.contains( rgb ))
+	{
+		map[rgb] = color.name();
+		return map[rgb];
+	}
+	else
+	{
+		return map[rgb];
+	}
+}
+
+/**
+ * ************************************************************
+ * CustomStyle
+ * ************************************************************
+ */
+
+CustomStyle::CustomStyle()
+  : Style(),
+    m_name( "Default" )
+{
+  m_type   = BUILTIN;
+  m_parent = 0;
+}
+
+CustomStyle::CustomStyle( Style * parent, TQString const & name )
+  : Style(),
+    m_name( name )
+{
+  m_type   = CUSTOM;
+  m_parent = 0;
+
+  // one to one copy
+  if ( parent->hasProperty( PDontPrintText ) )
+    addProperty( PDontPrintText );
+  if ( parent->hasProperty( PCustomFormat ) )
+    addProperty( PCustomFormat );
+  if ( parent->hasProperty( PNotProtected ) )
+    addProperty( PNotProtected );
+  if ( parent->hasProperty( PHideAll ) )
+    addProperty( PHideAll );
+  if ( parent->hasProperty( PHideFormula ) )
+    addProperty( PHideFormula );
+  if ( parent->hasProperty( PMultiRow ) )
+    addProperty( PMultiRow );
+  if ( parent->hasProperty( PVerticalText ) )
+    addProperty( PVerticalText );
+
+  changeAlignX( parent->alignX() );
+  changeAlignY( parent->alignY() );
+  changeFloatFormat( parent->floatFormat() );
+  changeFloatColor( parent->floatColor() );
+  changeFormatType( parent->formatType() );
+  changeFontFamily( parent->fontFamily() );
+  changeFontSize( parent->fontSize() );
+  changeFontFlags( parent->fontFlags() );
+  changePen( parent->pen() );
+  changeBgColor( parent->bgColor() );
+  changeRightBorderPen( parent->rightBorderPen() );
+  changeBottomBorderPen( parent->bottomBorderPen() );
+  changeLeftBorderPen( parent->leftBorderPen() );
+  changeTopBorderPen( parent->topBorderPen() );
+  changeFallBorderPen( parent->fallDiagonalPen() );
+  changeGoUpBorderPen( parent->goUpDiagonalPen() );
+  changeBackGroundBrush( parent->backGroundBrush() );
+  changeRotateAngle( parent->rotateAngle() );
+  changeIndent( parent->indent() );
+  changeStrFormat( parent->strFormat() );
+  changePrecision( parent->precision() );
+  changePrefix( parent->prefix() );
+  changePostfix( parent->postfix() );
+  changeCurrency( parent->currency() );
+}
+
+CustomStyle::CustomStyle( TQString const & name, CustomStyle * parent )
+  : Style(),
+    m_name( name )
+{
+  m_parent = parent;
+  if ( m_parent )
+    m_parentName = m_parent->name();
+}
+
+CustomStyle::~CustomStyle()
+{
+}
+
+TQString CustomStyle::saveOasis( KoGenStyle& style, KoGenStyles &mainStyles )
+{
+    // If the type is undefined, we're called from Format
+    // and the OASIS style is not an automatic style.
+    // TODO: As the user styles are already created, look them up
+    //       in what way ever and return here.
+//     if ( style.type() == 0 && ( m_type == BUILTIN ) && ( m_name == "Default" ) )
+//       return "Default";
+    if ( style.type() == 0 )
+      style = KoGenStyle( Doc::STYLE_CELL_USER, "table-cell" );
+
+    if ( m_name.isEmpty() )
+        return TQString(); // TODO fallback to Style::saveOasis() ???
+
+    // default style does not need display name
+    if( type() != BUILTIN || m_name != "Default" )
+        style.addAttribute( "style:display-name", m_name );
+
+    // doing the real work
+    saveOasisStyle( style, mainStyles );
+
+    // The lookup is done in the calling object (Format).
+    if ( style.type() == Doc::STYLE_CELL_AUTO )
+        return TQString();
+
+    if( ( m_type == BUILTIN ) && ( m_name == "Default" ) )
+    {
+        style.setDefaultStyle(true);
+        // don't i18n'ize "Default" in this case
+        return mainStyles.lookup( style, "Default", KoGenStyles::DontForceNumbering );
+    }
+    else
+        // this is a custom style
+        return mainStyles.lookup( style, "custom-style" );
+}
+
+void CustomStyle::loadOasis( KoOasisStyles& oasisStyles, const TQDomElement& style, const TQString & name )
+{
+    m_name = name;
+    if ( style.hasAttributeNS( KoXmlNS::style, "parent-style-name" ) )
+        m_parentName = style.attributeNS( KoXmlNS::style, "parent-style-name", TQString() );
+    else if ( m_name != "Default" )
+        m_parentName = "Default";
+
+    m_type = CUSTOM;
+
+    Style::loadOasisStyle( oasisStyles, style );
+}
+
+void CustomStyle::save( TQDomDocument & doc, TQDomElement & styles )
+{
+  if ( m_name.isEmpty() )
+    return;
+
+  TQDomElement style( doc.createElement( "style" ) );
+  style.setAttribute( "type", (int) m_type );
+  if ( m_parent )
+    style.setAttribute( "parent", m_parent->name() );
+  style.setAttribute( "name", m_name );
+
+  TQDomElement format( doc.createElement( "format" ) );
+  saveXML( doc, format );
+  style.appendChild( format );
+
+  styles.appendChild( style );
+}
+
+bool CustomStyle::loadXML( TQDomElement const & style, TQString const & name )
+{
+  m_name = name;
+
+  if ( style.hasAttribute( "parent" ) )
+    m_parentName = style.attribute( "parent" );
+
+  if ( !style.hasAttribute( "type" ) )
+    return false;
+
+  bool ok = true;
+  m_type = (StyleType) style.attribute( "type" ).toInt( &ok );
+  if ( !ok )
+    return false;
+
+  TQDomElement f( style.namedItem( "format" ).toElement() );
+  if ( !f.isNull() )
+    if ( !Style::loadXML( f ) )
+      return false;
+
+  return true;
+}
+
+void CustomStyle::setName( TQString const & name )
+{
+  m_name = name;
+}
+
+void CustomStyle::refreshParentName()
+{
+  if ( m_parent )
+    m_parentName = m_parent->name();
+}
+
+bool CustomStyle::definesAll() const
+{
+  if ( !( m_featuresSet & (uint) SAlignX ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SAlignY ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SPrefix ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SPostfix ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SLeftBorder ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SRightBorder ) )
+    return false;
+  if ( !( m_featuresSet & (uint) STopBorder ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SBottomBorder ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SFallDiagonal ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SGoUpDiagonal ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SBackgroundBrush ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SFontFamily ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SFontSize ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SFontFlag ) )
+    return false;
+  if ( !( m_featuresSet & (uint) STextPen ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SBackgroundColor ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SFloatFormat ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SFloatColor ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SMultiRow ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SVerticalText ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SPrecision ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SFormatType ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SAngle ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SIndent ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SDontPrintText ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SCustomFormat ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SNotProtected ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SHideAll ) )
+    return false;
+  if ( !( m_featuresSet & (uint) SHideFormula ) )
+    return false;
+
+  return true;
+}
+
+void CustomStyle::changeAlignX( Format::Align alignX )
+{
+  m_alignX = alignX;
+  m_featuresSet |= SAlignX;
+}
+
+void CustomStyle::changeAlignY( Format::AlignY alignY )
+{
+  m_alignY = alignY;
+  m_featuresSet |= SAlignY;
+}
+
+void CustomStyle::changeFont( TQFont const & f )
+{
+  if ( m_fontFamily != f.family() )
+  {
+    m_fontFamily = f.family();
+    m_featuresSet |= SFontFamily;
+    m_featuresSet |= SFont;
+  }
+  if ( m_fontSize != f.pointSize() )
+  {
+    m_fontSize = f.pointSize();
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontSize;
+  }
+
+  if ( f.italic() != (m_fontFlags & (uint) FItalic ) )
+  {
+    if ( f.italic() )
+      m_fontFlags |= FItalic;
+    else
+      m_fontFlags &= ~(uint) FItalic;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+  if ( f.bold() != (m_fontFlags & (uint) FBold ) )
+  {
+    if ( f.bold() )
+      m_fontFlags |= FBold;
+    else
+      m_fontFlags &= ~(uint) FBold;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+  if ( f.underline() != (m_fontFlags & (uint) FUnderline ) )
+  {
+    if ( f.underline() )
+      m_fontFlags |= FUnderline;
+    else
+      m_fontFlags &= ~(uint) FUnderline;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+  if ( f.strikeOut() != (m_fontFlags & (uint) FStrike ) )
+  {
+    if ( f.strikeOut() )
+      m_fontFlags |= FStrike;
+    else
+      m_fontFlags &= ~(uint) FStrike;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+}
+
+void CustomStyle::changeFontFamily( TQString const & fam )
+{
+  if ( m_fontFamily != fam )
+  {
+    m_fontFamily   = fam;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFamily;
+  }
+}
+
+void CustomStyle::changeFontSize( int size )
+{
+  if ( m_fontSize != size )
+  {
+    m_fontSize     = size;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontSize;
+  }
+}
+
+void CustomStyle::changeFontFlags( uint flags )
+{
+  if ( m_fontFlags != flags )
+  {
+    m_fontFlags    = flags;
+    m_featuresSet |= SFont;
+    m_featuresSet |= SFontFlag;
+  }
+}
+
+void CustomStyle::changeTextColor( TQColor const & color )
+{
+  m_textPen.setColor( color );
+  m_featuresSet |= STextPen;
+}
+
+void CustomStyle::changePen( TQPen const & pen )
+{
+  m_textPen = pen;
+  m_featuresSet |= STextPen;
+}
+
+void CustomStyle::changeBgColor( TQColor const & color )
+{
+  m_bgColor = color;
+  m_featuresSet |= SBackgroundColor;
+}
+
+void CustomStyle::changeRightBorderPen( TQPen const & pen )
+{
+  m_rightBorderPen = pen;
+  m_rightPenValue  = calculateValue( pen );
+  m_featuresSet   |= SRightBorder;
+}
+
+void CustomStyle::changeBottomBorderPen( TQPen const & pen )
+{
+  m_bottomBorderPen = pen;
+  m_bottomPenValue  = calculateValue( pen );
+  m_featuresSet    |= SBottomBorder;
+}
+
+void CustomStyle::changeLeftBorderPen( TQPen const & pen )
+{
+  m_leftBorderPen = pen;
+  m_leftPenValue  = calculateValue( pen );
+  m_featuresSet  |= SLeftBorder;
+}
+
+void CustomStyle::changeTopBorderPen( TQPen const & pen )
+{
+  m_topBorderPen = pen;
+  m_topPenValue  = calculateValue( pen );
+  m_featuresSet |= STopBorder;
+}
+
+void CustomStyle::changeFallBorderPen( TQPen const & pen )
+{
+  m_fallDiagonalPen = pen;
+  m_featuresSet |= SFallDiagonal;
+}
+
+void CustomStyle::changeGoUpBorderPen( TQPen const & pen )
+{
+  m_goUpDiagonalPen = pen;
+  m_featuresSet |= SGoUpDiagonal;
+}
+
+void CustomStyle::changeRotateAngle( int angle )
+{
+  m_rotateAngle = angle;
+  m_featuresSet |= SAngle;
+}
+
+void CustomStyle::changeIndent( double indent )
+{
+  m_indent = indent;
+  m_featuresSet |= SIndent;
+}
+
+void CustomStyle::changeBackGroundBrush( TQBrush const & brush )
+{
+  m_backGroundBrush = brush;
+  m_featuresSet |= SBackgroundBrush;
+}
+
+void CustomStyle::changeFloatFormat( Format::FloatFormat format )
+{
+  m_floatFormat = format;
+  m_featuresSet |= SFloatFormat;
+}
+
+void CustomStyle::changeFloatColor( Format::FloatColor color )
+{
+  m_floatColor = color;
+  m_featuresSet |= SFloatColor;
+}
+
+void CustomStyle::changeFormatType( FormatType format )
+{
+  m_formatType = format;
+  m_featuresSet |= SFormatType;
+}
+
+void CustomStyle::changeStrFormat( TQString const & strFormat )
+{
+  m_strFormat = strFormat;
+  m_featuresSet |= SCustomFormat;
+}
+
+void CustomStyle::changePrecision( int precision )
+{
+  m_precision = precision;
+  m_featuresSet |= SPrecision;
+}
+
+void CustomStyle::changePrefix( TQString const & prefix )
+{
+  m_prefix = prefix;
+  m_featuresSet |= SPrefix;
+}
+
+void CustomStyle::changePostfix( TQString const & postfix )
+{
+  m_postfix = postfix;
+  m_featuresSet |= SPostfix;
+}
+
+void CustomStyle::changeCurrency( Format::Currency const & currency )
+{
+  m_currency = currency;
+}
+
+void CustomStyle::addProperty( Properties p )
+{
+  m_properties |= (uint) p;
+  switch( p )
+  {
+   case PDontPrintText:
+    m_featuresSet |= SDontPrintText;
+    break;
+   case PCustomFormat:
+    m_featuresSet |= SCustomFormat;
+    break;
+   case PNotProtected:
+    m_featuresSet |= SNotProtected;
+    break;
+   case PHideAll:
+    m_featuresSet |= SHideAll;
+    break;
+   case PHideFormula:
+    m_featuresSet |= SHideFormula;
+    break;
+   case PMultiRow:
+    m_featuresSet |= SMultiRow;
+    break;
+   case PVerticalText:
+    m_featuresSet |= SVerticalText;
+    break;
+   default:
+    kdWarning() << "Unhandled property" << endl;
+  }
+}
+
+void CustomStyle::removeProperty( Properties p )
+{
+  m_properties &= ~(uint) p;
+  switch( p )
+  {
+   case PDontPrintText:
+    m_featuresSet &= SDontPrintText;
+    break;
+   case PCustomFormat:
+    m_featuresSet &= SCustomFormat;
+    break;
+   case PNotProtected:
+    m_featuresSet &= SNotProtected;
+    break;
+   case PHideAll:
+    m_featuresSet &= SHideAll;
+    break;
+   case PHideFormula:
+    m_featuresSet &= SHideFormula;
+    break;
+   case PMultiRow:
+    m_featuresSet &= SMultiRow;
+    break;
+   case PVerticalText:
+    m_featuresSet &= SVerticalText;
+    break;
+   default:
+    kdWarning() << "Unhandled property" << endl;
+  }
+}
+
+bool CustomStyle::operator==( const CustomStyle& other ) const
+{
+  if ( m_name != other.m_name )
+    return false;
+  return Style::operator==( other );
+}