You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3215 lines
91 KiB
3215 lines
91 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2003 Norbert Andres, nandres@web.de
|
|
|
|
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 <robertknight@gmail.com>
|
|
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 );
|
|
}
|