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.
949 lines
40 KiB
949 lines
40 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2001 David Faure <faure@kde.org>
|
|
|
|
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 "KoParagLayout.h"
|
|
#include "KoRichText.h"
|
|
#include "KoParagCounter.h"
|
|
#include "KoStyleCollection.h"
|
|
#include "KoOasisContext.h"
|
|
#include <KoXmlWriter.h>
|
|
#include <KoXmlNS.h>
|
|
#include <KoDom.h>
|
|
#include <KoGenStyles.h>
|
|
|
|
#include <tdeglobal.h>
|
|
#include <tdelocale.h>
|
|
#include <kdebug.h>
|
|
#include <tqdom.h>
|
|
#include <tqbuffer.h>
|
|
#include <tqcolor.h>
|
|
|
|
#include <float.h>
|
|
|
|
TQString* KoParagLayout::shadowCssCompat = 0L;
|
|
|
|
// Create a default KoParagLayout.
|
|
KoParagLayout::KoParagLayout()
|
|
{
|
|
initialise();
|
|
}
|
|
|
|
void KoParagLayout::operator=( const KoParagLayout &layout )
|
|
{
|
|
alignment = layout.alignment;
|
|
for ( int i = 0 ; i < 5 ; ++i )
|
|
margins[i] = layout.margins[i];
|
|
pageBreaking = layout.pageBreaking;
|
|
leftBorder = layout.leftBorder;
|
|
rightBorder = layout.rightBorder;
|
|
topBorder = layout.topBorder;
|
|
bottomBorder = layout.bottomBorder;
|
|
joinBorder = layout.joinBorder;
|
|
backgroundColor = layout.backgroundColor;
|
|
if ( layout.counter )
|
|
counter = new KoParagCounter( *layout.counter );
|
|
else
|
|
counter = 0L;
|
|
lineSpacing = layout.lineSpacing;
|
|
lineSpacingType = layout.lineSpacingType;
|
|
style = layout.style;
|
|
direction = layout.direction;
|
|
setTabList( layout.tabList() );
|
|
}
|
|
|
|
int KoParagLayout::compare( const KoParagLayout & layout ) const
|
|
{
|
|
int flags = 0;
|
|
if ( alignment != layout.alignment )
|
|
flags |= Alignment;
|
|
for ( int i = 0 ; i < 5 ; ++i )
|
|
if ( margins[i] != layout.margins[i] )
|
|
{
|
|
flags |= Margins;
|
|
break;
|
|
}
|
|
if ( pageBreaking != layout.pageBreaking )
|
|
flags |= PageBreaking;
|
|
if ( leftBorder != layout.leftBorder
|
|
|| rightBorder != layout.rightBorder
|
|
|| topBorder != layout.topBorder
|
|
|| bottomBorder != layout.bottomBorder
|
|
|| joinBorder != layout.joinBorder )
|
|
flags |= Borders;
|
|
|
|
if ( layout.counter )
|
|
{
|
|
if ( counter )
|
|
{
|
|
if ( ! ( *layout.counter == *counter ) )
|
|
flags |= BulletNumber;
|
|
} else
|
|
if ( layout.counter->numbering() != KoParagCounter::NUM_NONE )
|
|
flags |= BulletNumber;
|
|
}
|
|
else
|
|
if ( counter && counter->numbering() != KoParagCounter::NUM_NONE )
|
|
flags |= BulletNumber;
|
|
|
|
if ( lineSpacing != layout.lineSpacing
|
|
|| lineSpacingType != layout.lineSpacingType )
|
|
flags |= LineSpacing;
|
|
//if ( style != layout.style )
|
|
// flags |= Style;
|
|
if ( m_tabList != layout.m_tabList )
|
|
flags |= Tabulator;
|
|
|
|
if ( backgroundColor != layout.backgroundColor)
|
|
flags |= BackgroundColor;
|
|
|
|
// This method is used for the GUI stuff only, so we don't have a flag
|
|
// for the Direction value.
|
|
return flags;
|
|
}
|
|
|
|
void KoParagLayout::initialise()
|
|
{
|
|
alignment = TQt::AlignAuto;
|
|
for ( int i = 0 ; i < 5 ; ++i ) // use memset ?
|
|
margins[i] = 0;
|
|
lineSpacingType = LS_SINGLE;
|
|
lineSpacing = 0;
|
|
counter = 0L;
|
|
leftBorder.setPenWidth( 0);
|
|
rightBorder.setPenWidth( 0);
|
|
topBorder.setPenWidth( 0);
|
|
bottomBorder.setPenWidth( 0);
|
|
joinBorder = true;
|
|
pageBreaking = 0;
|
|
style = 0L;
|
|
direction = TQChar::DirON;
|
|
m_tabList.clear();
|
|
}
|
|
|
|
KoParagLayout::~KoParagLayout()
|
|
{
|
|
delete counter;
|
|
}
|
|
|
|
void KoParagLayout::loadParagLayout( KoParagLayout& layout, const TQDomElement& parentElem, int docVersion )
|
|
{
|
|
// layout is an input and output parameter
|
|
// It can have been initialized already, e.g. by copying from a style
|
|
// (we don't do that anymore though).
|
|
|
|
// Load the paragraph tabs - we load into a clean list, not mixing with those already in "layout"
|
|
// We can't apply the 'default comes from the style' in this case, because
|
|
// there is no way to differentiate between "I want no tabs in the parag"
|
|
// and "use default from style".
|
|
KoTabulatorList tabList;
|
|
TQDomElement element = parentElem.firstChild().toElement();
|
|
for ( ; !element.isNull() ; element = element.nextSibling().toElement() )
|
|
{
|
|
if ( element.tagName() == "TABULATOR" )
|
|
{
|
|
KoTabulator tab;
|
|
tab.type = static_cast<KoTabulators>( getAttribute( element, "type", T_LEFT ) );
|
|
tab.ptPos = getAttribute( element, "ptpos", 0.0 );
|
|
tab.filling = static_cast<KoTabulatorFilling>( getAttribute( element, "filling", TF_BLANK ) );
|
|
tab.ptWidth = getAttribute( element, "width", 0.5 );
|
|
TQString alignCharStr = element.attribute("alignchar");
|
|
if ( alignCharStr.isEmpty() )
|
|
tab.alignChar = TDEGlobal::locale()->decimalSymbol()[0];
|
|
else
|
|
tab.alignChar = alignCharStr[0];
|
|
tabList.append( tab );
|
|
}
|
|
}
|
|
qHeapSort( tabList );
|
|
layout.setTabList( tabList );
|
|
layout.alignment = TQt::AlignAuto;
|
|
element = parentElem.namedItem( "FLOW" ).toElement(); // Flow is what is now called alignment internally
|
|
if ( !element.isNull() )
|
|
{
|
|
TQString flow = element.attribute( "align" ); // KWord-1.0 DTD
|
|
if ( !flow.isEmpty() )
|
|
{
|
|
layout.alignment = flow=="right" ? TQt::AlignRight :
|
|
flow=="center" ? TQt::AlignHCenter :
|
|
flow=="justify" ? TQt::AlignJustify :
|
|
flow=="left" ? TQt::AlignLeft : TQt::AlignAuto;
|
|
|
|
TQString dir = element.attribute( "dir" ); // KWord-1.2
|
|
if ( !dir.isEmpty() ) {
|
|
if ( dir == "L" )
|
|
layout.direction = TQChar::DirL;
|
|
else if ( dir == "R" )
|
|
layout.direction = TQChar::DirR;
|
|
else
|
|
kdWarning() << "Unexpected value for paragraph direction: " << dir << endl;
|
|
}
|
|
} else {
|
|
flow = element.attribute( "value" ); // KWord-0.8
|
|
static const int flow2align[] = { TQt::AlignAuto, TQt::AlignRight, TQt::AlignHCenter, TQt::AlignJustify };
|
|
if ( !flow.isEmpty() && flow.toInt() < 4 )
|
|
layout.alignment = flow2align[flow.toInt()];
|
|
}
|
|
}
|
|
|
|
if ( docVersion < 2 )
|
|
{
|
|
element = parentElem.namedItem( "OHEAD" ).toElement(); // used by KWord-0.8
|
|
if ( !element.isNull() )
|
|
layout.margins[TQStyleSheetItem::MarginTop] = getAttribute( element, "pt", 0.0 );
|
|
|
|
element = parentElem.namedItem( "OFOOT" ).toElement(); // used by KWord-0.8
|
|
if ( !element.isNull() )
|
|
layout.margins[TQStyleSheetItem::MarginBottom] = getAttribute( element, "pt", 0.0 );
|
|
|
|
element = parentElem.namedItem( "IFIRST" ).toElement(); // used by KWord-0.8
|
|
if ( !element.isNull() )
|
|
layout.margins[TQStyleSheetItem::MarginFirstLine] = getAttribute( element, "pt", 0.0 );
|
|
|
|
element = parentElem.namedItem( "ILEFT" ).toElement(); // used by KWord-0.8
|
|
if ( !element.isNull() )
|
|
layout.margins[TQStyleSheetItem::MarginLeft] = getAttribute( element, "pt", 0.0 );
|
|
}
|
|
|
|
// KWord-1.0 DTD
|
|
element = parentElem.namedItem( "INDENTS" ).toElement();
|
|
if ( !element.isNull() )
|
|
{
|
|
layout.margins[TQStyleSheetItem::MarginFirstLine] = getAttribute( element, "first", 0.0 );
|
|
layout.margins[TQStyleSheetItem::MarginLeft] = getAttribute( element, "left", 0.0 );
|
|
layout.margins[TQStyleSheetItem::MarginRight] = getAttribute( element, "right", 0.0 );
|
|
}
|
|
element = parentElem.namedItem( "OFFSETS" ).toElement();
|
|
if ( !element.isNull() )
|
|
{
|
|
layout.margins[TQStyleSheetItem::MarginTop] = getAttribute( element, "before", 0.0 );
|
|
layout.margins[TQStyleSheetItem::MarginBottom] = getAttribute( element, "after", 0.0 );
|
|
}
|
|
|
|
if ( docVersion < 2 )
|
|
{
|
|
element = parentElem.namedItem( "LINESPACE" ).toElement(); // used by KWord-0.8
|
|
if ( !element.isNull() )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_CUSTOM;
|
|
layout.lineSpacing = getAttribute( element, "pt", 0.0 );
|
|
}
|
|
}
|
|
|
|
element = parentElem.namedItem( "LINESPACING" ).toElement(); // KWord-1.0 DTD
|
|
if ( !element.isNull() )
|
|
{
|
|
//compatibility with koffice 1.1
|
|
if ( element.hasAttribute( "value" ))
|
|
{
|
|
TQString value = element.attribute( "value" );
|
|
if ( value == "oneandhalf" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_ONEANDHALF;
|
|
layout.lineSpacing = 0;
|
|
}
|
|
else if ( value == "double" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_DOUBLE;
|
|
layout.lineSpacing = 0;
|
|
}
|
|
else
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_CUSTOM;
|
|
layout.lineSpacing = value.toDouble();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TQString type = element.attribute( "type" );
|
|
if ( type == "oneandhalf" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_ONEANDHALF;
|
|
layout.lineSpacing = 0;
|
|
}
|
|
else if ( type == "double" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_DOUBLE;
|
|
layout.lineSpacing = 0;
|
|
}
|
|
else if ( type == "custom" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_CUSTOM;
|
|
layout.lineSpacing = element.attribute( "spacingvalue" ).toDouble();
|
|
}
|
|
else if ( type == "atleast" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_AT_LEAST;
|
|
layout.lineSpacing = element.attribute( "spacingvalue" ).toDouble();
|
|
}
|
|
else if ( type == "multiple" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_MULTIPLE;
|
|
layout.lineSpacing = element.attribute( "spacingvalue" ).toDouble();
|
|
}
|
|
else if ( type == "fixed" )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_FIXED;
|
|
layout.lineSpacing = element.attribute( "spacingvalue" ).toDouble();
|
|
}
|
|
else if ( type == "single" ) // not used; just in case future versions use it.
|
|
layout.lineSpacingType = KoParagLayout::LS_SINGLE;
|
|
}
|
|
}
|
|
|
|
int pageBreaking = 0;
|
|
element = parentElem.namedItem( "PAGEBREAKING" ).toElement();
|
|
if ( !element.isNull() )
|
|
{
|
|
if ( element.attribute( "linesTogether" ) == "true" )
|
|
pageBreaking |= KoParagLayout::KeepLinesTogether;
|
|
if ( element.attribute( "hardFrameBreak" ) == "true" )
|
|
pageBreaking |= KoParagLayout::HardFrameBreakBefore;
|
|
if ( element.attribute( "hardFrameBreakAfter" ) == "true" )
|
|
pageBreaking |= KoParagLayout::HardFrameBreakAfter;
|
|
}
|
|
if ( docVersion < 2 )
|
|
{
|
|
element = parentElem.namedItem( "HARDBRK" ).toElement(); // KWord-0.8
|
|
if ( !element.isNull() )
|
|
pageBreaking |= KoParagLayout::HardFrameBreakBefore;
|
|
}
|
|
layout.pageBreaking = pageBreaking;
|
|
|
|
element = parentElem.namedItem( "LEFTBORDER" ).toElement();
|
|
if ( !element.isNull() )
|
|
layout.leftBorder = KoBorder::loadBorder( element );
|
|
else
|
|
layout.leftBorder.setPenWidth(0);
|
|
|
|
element = parentElem.namedItem( "RIGHTBORDER" ).toElement();
|
|
if ( !element.isNull() )
|
|
layout.rightBorder = KoBorder::loadBorder( element );
|
|
else
|
|
layout.rightBorder.setPenWidth(0);
|
|
|
|
element = parentElem.namedItem( "TOPBORDER" ).toElement();
|
|
if ( !element.isNull() )
|
|
layout.topBorder = KoBorder::loadBorder( element );
|
|
else
|
|
layout.topBorder.setPenWidth(0);
|
|
|
|
element = parentElem.namedItem( "BOTTOMBORDER" ).toElement();
|
|
if ( !element.isNull() )
|
|
layout.bottomBorder = KoBorder::loadBorder( element );
|
|
else
|
|
layout.bottomBorder.setPenWidth(0);
|
|
|
|
element = parentElem.namedItem( "COUNTER" ).toElement();
|
|
if ( !element.isNull() )
|
|
{
|
|
layout.counter = new KoParagCounter;
|
|
layout.counter->load( element );
|
|
}
|
|
|
|
// Compatibility with KOffice-1.2
|
|
element = parentElem.namedItem( "SHADOW" ).toElement();
|
|
if ( !element.isNull() && element.hasAttribute("direction") )
|
|
{
|
|
int shadowDistance = element.attribute("distance").toInt();
|
|
int shadowDirection = element.attribute("direction").toInt();
|
|
TQColor shadowColor;
|
|
if ( element.hasAttribute("red") )
|
|
{
|
|
int r = element.attribute("red").toInt();
|
|
int g = element.attribute("green").toInt();
|
|
int b = element.attribute("blue").toInt();
|
|
shadowColor.setRgb( r, g, b );
|
|
}
|
|
int distanceX = 0;
|
|
int distanceY = 0;
|
|
switch ( shadowDirection )
|
|
{
|
|
case 1: // KoParagLayout::SD_LEFT_UP:
|
|
case 2: // KoParagLayout::SD_UP:
|
|
case 3: // KoParagLayout::SD_RIGHT_UP:
|
|
distanceX = - shadowDistance;
|
|
break;
|
|
case 7: // KoParagLayout::SD_LEFT_BOTTOM:
|
|
case 6: // KoParagLayout::SD_BOTTOM:
|
|
case 5: // KoParagLayout::SD_RIGHT_BOTTOM:
|
|
distanceX = shadowDistance;
|
|
break;
|
|
}
|
|
switch ( shadowDirection )
|
|
{
|
|
case 7: // KoParagLayout::SD_LEFT_BOTTOM:
|
|
case 8: // KoParagLayout::SD_LEFT:
|
|
case 1: //KoParagLayout::SD_LEFT_UP:
|
|
distanceY = - shadowDistance;
|
|
break;
|
|
case 3: // KoParagLayout::SD_RIGHT_UP:
|
|
case 4: // KoParagLayout::SD_RIGHT:
|
|
case 5: // KoParagLayout::SD_RIGHT_BOTTOM:
|
|
distanceY = shadowDistance;
|
|
break;
|
|
}
|
|
if ( !shadowCssCompat )
|
|
shadowCssCompat = new TQString;
|
|
*shadowCssCompat = KoTextFormat::shadowAsCss( distanceX, distanceY, shadowColor );
|
|
kdDebug(32500) << "setting shadow compat to " << ( *shadowCssCompat ) << endl;
|
|
}
|
|
else
|
|
{
|
|
delete shadowCssCompat;
|
|
shadowCssCompat = 0L;
|
|
}
|
|
}
|
|
|
|
//static
|
|
TQt::AlignmentFlags KoParagLayout::loadOasisAlignment( const TQCString& str )
|
|
{
|
|
return
|
|
str == "left" ? TQt::AlignLeft :
|
|
str == "right" ? TQt::AlignRight :
|
|
str == "start" ? TQt::AlignLeft :
|
|
str == "end" ? TQt::AlignRight :
|
|
str == "center" ? TQt::AlignHCenter :
|
|
str == "justify" ? TQt::AlignJustify :
|
|
str == "start" ? TQt::AlignAuto // i.e. direction-dependent
|
|
: TQt::AlignAuto; // default (can't happen unless spec is extended)
|
|
}
|
|
|
|
//static
|
|
TQCString KoParagLayout::saveOasisAlignment( TQt::AlignmentFlags alignment )
|
|
{
|
|
return alignment == TQt::AlignLeft ? "left" :
|
|
alignment == TQt::AlignRight ? "right" :
|
|
alignment == TQt::AlignHCenter ? "center" :
|
|
alignment == TQt::AlignJustify ? "justify" :
|
|
"start"; // i.e. direction-dependent
|
|
}
|
|
|
|
void KoParagLayout::loadOasisParagLayout( KoParagLayout& layout, KoOasisContext& context )
|
|
{
|
|
context.styleStack().setTypeProperties( "paragraph" );
|
|
// layout is an input and output parameter
|
|
// It can have been initialized already, e.g. by copying from a style
|
|
|
|
// code from OoWriterImport::writeLayout
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "text-align" ) ) {
|
|
TQCString align = context.styleStack().attributeNS( KoXmlNS::fo, "text-align" ).latin1();
|
|
layout.alignment = loadOasisAlignment( align );
|
|
}
|
|
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::style, "writing-mode" ) ) { // http://web4.w3.org/TR/xsl/slice7.html#writing-mode
|
|
// LTR is lr-tb. RTL is rl-tb
|
|
TQString writingMode = context.styleStack().attributeNS( KoXmlNS::style, "writing-mode" );
|
|
layout.direction = ( writingMode=="rl-tb" || writingMode=="rl" ) ? TQChar::DirR : TQChar::DirL;
|
|
}
|
|
|
|
// Indentation (margins)
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "margin-left" ) || // 3.11.19
|
|
context.styleStack().hasAttributeNS( KoXmlNS::fo, "margin-right" ) ) {
|
|
layout.margins[TQStyleSheetItem::MarginLeft] = KoUnit::parseValue( context.styleStack().attributeNS( KoXmlNS::fo, "margin-left" ) );
|
|
layout.margins[TQStyleSheetItem::MarginRight] = KoUnit::parseValue( context.styleStack().attributeNS( KoXmlNS::fo, "margin-right" ) );
|
|
// *text-indent must always be bound to either margin-left or margin-right
|
|
double first = 0;
|
|
if ( context.styleStack().attributeNS( KoXmlNS::style, "auto-text-indent") == "true" ) // style:auto-text-indent takes precedence
|
|
// ### "indented by a value that is based on the current font size"
|
|
// ### and "requires margin-left and margin-right
|
|
// ### but how much is the indent?
|
|
first = 10;
|
|
else if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "text-indent") )
|
|
first = KoUnit::parseValue( context.styleStack().attributeNS( KoXmlNS::fo, "text-indent") );
|
|
|
|
layout.margins[TQStyleSheetItem::MarginFirstLine] = first;
|
|
}
|
|
|
|
// Offset before and after paragraph
|
|
if( context.styleStack().hasAttributeNS( KoXmlNS::fo, "margin-top") || // 3.11.22
|
|
context.styleStack().hasAttributeNS( KoXmlNS::fo, "margin-bottom")) {
|
|
layout.margins[TQStyleSheetItem::MarginTop] = KoUnit::parseValue( context.styleStack().attributeNS( KoXmlNS::fo, "margin-top" ) );
|
|
layout.margins[TQStyleSheetItem::MarginBottom] = KoUnit::parseValue( context.styleStack().attributeNS( KoXmlNS::fo, "margin-bottom" ) );
|
|
}
|
|
|
|
// Line spacing
|
|
if( context.styleStack().hasAttributeNS( KoXmlNS::fo, "line-height") ) { // 3.11.1
|
|
// Fixed line height
|
|
TQString value = context.styleStack().attributeNS( KoXmlNS::fo, "line-height" );
|
|
if ( value != "normal" ) {
|
|
if ( value == "100%" )
|
|
layout.lineSpacingType = KoParagLayout::LS_SINGLE;
|
|
else if( value=="150%")
|
|
layout.lineSpacingType = KoParagLayout::LS_ONEANDHALF;
|
|
else if( value=="200%")
|
|
layout.lineSpacingType = KoParagLayout::LS_DOUBLE;
|
|
else if ( value.find('%') > -1 )
|
|
{
|
|
value = value.remove( '%' );
|
|
double percent = value.toDouble();
|
|
layout.lineSpacingType = KoParagLayout::LS_MULTIPLE;
|
|
layout.lineSpacing = percent / 100.0;
|
|
kdDebug(33001) << "line-height =" << percent << ", " << layout.lineSpacing << ", " << percent/100 << endl;
|
|
}
|
|
else // fixed value
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_FIXED;
|
|
layout.lineSpacing = KoUnit::parseValue( value );
|
|
}
|
|
}
|
|
}
|
|
// Line-height-at-least is mutually exclusive with line-height
|
|
else if ( context.styleStack().hasAttributeNS( KoXmlNS::style, "line-height-at-least") ) // 3.11.2
|
|
{
|
|
TQString value = context.styleStack().attributeNS( KoXmlNS::style, "line-height-at-least" );
|
|
// kotext has "at least" but that's for the linespacing, not for the entire line height!
|
|
// Strange. kotext also has "at least" for the whole line height....
|
|
// Did we make the wrong choice in kotext?
|
|
//kdWarning() << "Unimplemented support for style:line-height-at-least: " << value << endl;
|
|
// Well let's see if this makes a big difference.
|
|
layout.lineSpacingType = KoParagLayout::LS_AT_LEAST;
|
|
layout.lineSpacing = KoUnit::parseValue( value );
|
|
}
|
|
// Line-spacing is mutually exclusive with line-height and line-height-at-least
|
|
else if ( context.styleStack().hasAttributeNS( KoXmlNS::style, "line-spacing") ) // 3.11.3
|
|
{
|
|
double value = KoUnit::parseValue( context.styleStack().attributeNS( KoXmlNS::style, "line-spacing" ) );
|
|
if ( value != 0.0 )
|
|
{
|
|
layout.lineSpacingType = KoParagLayout::LS_CUSTOM;
|
|
layout.lineSpacing = value;
|
|
}
|
|
}
|
|
|
|
// Tabulators
|
|
KoTabulatorList tabList;
|
|
if ( context.styleStack().hasChildNodeNS( KoXmlNS::style, "tab-stops" ) ) { // 3.11.10
|
|
TQDomElement tabStops = context.styleStack().childNodeNS( KoXmlNS::style, "tab-stops" );
|
|
//kdDebug(30519) << k_funcinfo << tabStops.childNodes().count() << " tab stops in layout." << endl;
|
|
TQDomElement tabStop;
|
|
forEachElement( tabStop, tabStops )
|
|
{
|
|
Q_ASSERT( tabStop.localName() == "tab-stop" );
|
|
const TQString type = tabStop.attributeNS( KoXmlNS::style, "type", TQString() ); // left, right, center or char
|
|
|
|
KoTabulator tab;
|
|
tab.ptPos = KoUnit::parseValue( tabStop.attributeNS( KoXmlNS::style, "position", TQString() ) );
|
|
// Tab stop positions in the XML are relative to the left-margin
|
|
tab.ptPos += layout.margins[TQStyleSheetItem::MarginLeft];
|
|
if ( type == "center" )
|
|
tab.type = T_CENTER;
|
|
else if ( type == "right" )
|
|
tab.type = T_RIGHT;
|
|
else if ( type == "char" ) {
|
|
TQString delimiterChar = tabStop.attributeNS( KoXmlNS::style, "char", TQString() ); // single character
|
|
if ( !delimiterChar.isEmpty() )
|
|
tab.alignChar = delimiterChar[0];
|
|
tab.type = T_DEC_PNT; // "alignment on decimal point"
|
|
}
|
|
else //if ( type == "left" )
|
|
tab.type = T_LEFT;
|
|
|
|
tab.ptWidth = KoUnit::parseValue( tabStop.attributeNS( KoXmlNS::style, "leader-width", TQString() ), 0.5 );
|
|
|
|
tab.filling = TF_BLANK;
|
|
if ( tabStop.attributeNS( KoXmlNS::style, "leader-type", TQString() ) == "single" )
|
|
{
|
|
TQString leaderStyle = tabStop.attributeNS( KoXmlNS::style, "leader-style", TQString() );
|
|
if ( leaderStyle == "solid" )
|
|
tab.filling = TF_LINE;
|
|
else if ( leaderStyle == "dotted" )
|
|
tab.filling = TF_DOTS;
|
|
else if ( leaderStyle == "dash" )
|
|
tab.filling = TF_DASH;
|
|
else if ( leaderStyle == "dot-dash" )
|
|
tab.filling = TF_DASH_DOT;
|
|
else if ( leaderStyle == "dot-dot-dash" )
|
|
tab.filling = TF_DASH_DOT_DOT;
|
|
}
|
|
else
|
|
{
|
|
// Fallback: convert leaderChar's unicode value
|
|
TQString leaderChar = tabStop.attributeNS( KoXmlNS::style, "leader-text", TQString() );
|
|
if ( !leaderChar.isEmpty() )
|
|
{
|
|
TQChar ch = leaderChar[0];
|
|
switch (ch.latin1()) {
|
|
case '.':
|
|
tab.filling = TF_DOTS; break;
|
|
case '-':
|
|
case '_': // TODO in KWord: differentiate --- and ___
|
|
tab.filling = TF_LINE; break;
|
|
default:
|
|
// KWord doesn't have support for "any char" as filling.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
tabList.append( tab );
|
|
} //for
|
|
}
|
|
qHeapSort( tabList );
|
|
layout.setTabList( tabList );
|
|
|
|
layout.joinBorder = !( context.styleStack().attributeNS( KoXmlNS::style, "join-border") == "false" );
|
|
|
|
// Borders
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "border","left") )
|
|
layout.leftBorder.loadFoBorder( context.styleStack().attributeNS( KoXmlNS::fo, "border","left") );
|
|
else
|
|
layout.leftBorder.setPenWidth(0);
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "border","right") )
|
|
layout.rightBorder.loadFoBorder( context.styleStack().attributeNS( KoXmlNS::fo, "border","right") );
|
|
else
|
|
layout.rightBorder.setPenWidth(0);
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "border","top") )
|
|
layout.topBorder.loadFoBorder( context.styleStack().attributeNS( KoXmlNS::fo, "border","top") );
|
|
else
|
|
layout.topBorder.setPenWidth(0);
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "border","bottom") )
|
|
layout.bottomBorder.loadFoBorder( context.styleStack().attributeNS( KoXmlNS::fo, "border","bottom") );
|
|
else
|
|
layout.bottomBorder.setPenWidth(0);
|
|
|
|
|
|
// Page breaking
|
|
int pageBreaking = 0;
|
|
if( context.styleStack().hasAttributeNS( KoXmlNS::fo, "break-before") ||
|
|
context.styleStack().hasAttributeNS( KoXmlNS::fo, "break-after") ||
|
|
context.styleStack().hasAttributeNS( KoXmlNS::fo, "keep-together") ||
|
|
context.styleStack().hasAttributeNS( KoXmlNS::style, "keep-with-next") ||
|
|
context.styleStack().hasAttributeNS( KoXmlNS::fo, "keep-with-next") )
|
|
{
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "break-before") ) { // 3.11.24
|
|
// TODO in KWord: implement difference between "column" and "page"
|
|
if ( context.styleStack().attributeNS( KoXmlNS::fo, "break-before" ) != "auto" )
|
|
pageBreaking |= KoParagLayout::HardFrameBreakBefore;
|
|
}
|
|
else if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "break-after") ) { // 3.11.24
|
|
// TODO in KWord: implement difference between "column" and "page"
|
|
if ( context.styleStack().attributeNS( KoXmlNS::fo, "break-after" ) != "auto" )
|
|
pageBreaking |= KoParagLayout::HardFrameBreakAfter;
|
|
}
|
|
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "keep-together" ) ) { // was style:break-inside in OOo-1.1, renamed in OASIS
|
|
if ( context.styleStack().attributeNS( KoXmlNS::fo, "keep-together" ) != "auto" )
|
|
pageBreaking |= KoParagLayout::KeepLinesTogether;
|
|
}
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "keep-with-next" ) ) {
|
|
// OASIS spec says it's "auto"/"always", not a boolean.
|
|
TQString val = context.styleStack().attributeNS( KoXmlNS::fo, "keep-with-next" );
|
|
if ( val == "true" || val == "always" )
|
|
pageBreaking |= KoParagLayout::KeepWithNext;
|
|
}
|
|
}
|
|
layout.pageBreaking = pageBreaking;
|
|
|
|
// Paragraph background color - fo:background-color
|
|
// The background color for parts of a paragraph that have no text underneath
|
|
if ( context.styleStack().hasAttributeNS( KoXmlNS::fo, "background-color" ) ) {
|
|
TQString bgColor = context.styleStack().attributeNS( KoXmlNS::fo, "background-color");
|
|
if (bgColor != "transparent")
|
|
layout.backgroundColor.setNamedColor( bgColor );
|
|
}
|
|
}
|
|
|
|
void KoParagLayout::saveParagLayout( TQDomElement & parentElem, int alignment ) const
|
|
{
|
|
const KoParagLayout& layout = *this; // code moved from somewhere else;)
|
|
TQDomDocument doc = parentElem.ownerDocument();
|
|
TQDomElement element = doc.createElement( "NAME" );
|
|
parentElem.appendChild( element );
|
|
if ( layout.style )
|
|
element.setAttribute( "value", layout.style->displayName() );
|
|
//else
|
|
// kdWarning() << "KoParagLayout::saveParagLayout: style==0!" << endl;
|
|
|
|
element = doc.createElement( "FLOW" );
|
|
parentElem.appendChild( element );
|
|
|
|
element.setAttribute( "align", alignment==TQt::AlignRight ? "right" :
|
|
alignment==TQt::AlignHCenter ? "center" :
|
|
alignment==TQt::AlignJustify ? "justify" :
|
|
alignment==TQt::AlignAuto ? "auto" : "left" ); // Note: styles can have AlignAuto. Not paragraphs.
|
|
|
|
if ( static_cast<TQChar::Direction>(layout.direction) == TQChar::DirR )
|
|
element.setAttribute( "dir", "R" );
|
|
else
|
|
if ( static_cast<TQChar::Direction>(layout.direction) == TQChar::DirL )
|
|
element.setAttribute( "dir", "L" );
|
|
|
|
if ( layout.margins[TQStyleSheetItem::MarginFirstLine] != 0 ||
|
|
layout.margins[TQStyleSheetItem::MarginLeft] != 0 ||
|
|
layout.margins[TQStyleSheetItem::MarginRight] != 0 )
|
|
{
|
|
element = doc.createElement( "INDENTS" );
|
|
parentElem.appendChild( element );
|
|
if ( layout.margins[TQStyleSheetItem::MarginFirstLine] != 0 )
|
|
element.setAttribute( "first", layout.margins[TQStyleSheetItem::MarginFirstLine] );
|
|
if ( layout.margins[TQStyleSheetItem::MarginLeft] != 0 )
|
|
element.setAttribute( "left", layout.margins[TQStyleSheetItem::MarginLeft] );
|
|
if ( layout.margins[TQStyleSheetItem::MarginRight] != 0 )
|
|
element.setAttribute( "right", layout.margins[TQStyleSheetItem::MarginRight] );
|
|
}
|
|
|
|
if ( layout.margins[TQStyleSheetItem::MarginTop] != 0 ||
|
|
layout.margins[TQStyleSheetItem::MarginBottom] != 0 )
|
|
{
|
|
element = doc.createElement( "OFFSETS" );
|
|
parentElem.appendChild( element );
|
|
if ( layout.margins[TQStyleSheetItem::MarginTop] != 0 )
|
|
element.setAttribute( "before", layout.margins[TQStyleSheetItem::MarginTop] );
|
|
if ( layout.margins[TQStyleSheetItem::MarginBottom] != 0 )
|
|
element.setAttribute( "after", layout.margins[TQStyleSheetItem::MarginBottom] );
|
|
}
|
|
if ( layout.lineSpacingType != LS_SINGLE )
|
|
{
|
|
element = doc.createElement( "LINESPACING" );
|
|
parentElem.appendChild( element );
|
|
if ( layout.lineSpacingType == KoParagLayout::LS_ONEANDHALF ) {
|
|
element.setAttribute( "type", "oneandhalf" );
|
|
element.setAttribute( "value", "oneandhalf" ); //compatibility with koffice 1.2
|
|
}
|
|
else if ( layout.lineSpacingType == KoParagLayout::LS_DOUBLE ) {
|
|
element.setAttribute( "type", "double" );
|
|
element.setAttribute( "value", "double" ); //compatibility with koffice 1.2
|
|
}
|
|
else if ( layout.lineSpacingType == KoParagLayout::LS_CUSTOM )
|
|
{
|
|
element.setAttribute( "type", "custom" );
|
|
element.setAttribute( "spacingvalue", layout.lineSpacing);
|
|
element.setAttribute( "value", layout.lineSpacing ); //compatibility with koffice 1.2
|
|
}
|
|
else if ( layout.lineSpacingType == KoParagLayout::LS_AT_LEAST )
|
|
{
|
|
element.setAttribute( "type", "atleast" );
|
|
element.setAttribute( "spacingvalue", layout.lineSpacing);
|
|
}
|
|
else if ( layout.lineSpacingType == KoParagLayout::LS_MULTIPLE )
|
|
{
|
|
element.setAttribute( "type", "multiple" );
|
|
element.setAttribute( "spacingvalue", layout.lineSpacing);
|
|
}
|
|
else if ( layout.lineSpacingType == KoParagLayout::LS_FIXED )
|
|
{
|
|
element.setAttribute( "type", "fixed" );
|
|
element.setAttribute( "spacingvalue", layout.lineSpacing);
|
|
}
|
|
else
|
|
kdDebug()<<" error in lineSpacing Type\n";
|
|
}
|
|
|
|
if ( layout.pageBreaking != 0 )
|
|
{
|
|
element = doc.createElement( "PAGEBREAKING" );
|
|
parentElem.appendChild( element );
|
|
if ( layout.pageBreaking & KoParagLayout::KeepLinesTogether )
|
|
element.setAttribute( "linesTogether", "true" );
|
|
if ( layout.pageBreaking & KoParagLayout::HardFrameBreakBefore )
|
|
element.setAttribute( "hardFrameBreak", "true" );
|
|
if ( layout.pageBreaking & KoParagLayout::HardFrameBreakAfter )
|
|
element.setAttribute( "hardFrameBreakAfter", "true" );
|
|
}
|
|
|
|
if ( layout.leftBorder.penWidth() > 0 )
|
|
{
|
|
element = doc.createElement( "LEFTBORDER" );
|
|
parentElem.appendChild( element );
|
|
layout.leftBorder.save( element );
|
|
}
|
|
if ( layout.rightBorder.penWidth() > 0 )
|
|
{
|
|
element = doc.createElement( "RIGHTBORDER" );
|
|
parentElem.appendChild( element );
|
|
layout.rightBorder.save( element );
|
|
}
|
|
if ( layout.topBorder.penWidth() > 0 )
|
|
{
|
|
element = doc.createElement( "TOPBORDER" );
|
|
parentElem.appendChild( element );
|
|
layout.topBorder.save( element );
|
|
}
|
|
if ( layout.bottomBorder.penWidth() > 0 )
|
|
{
|
|
element = doc.createElement( "BOTTOMBORDER" );
|
|
parentElem.appendChild( element );
|
|
layout.bottomBorder.save( element );
|
|
}
|
|
if ( layout.counter && layout.counter->numbering() != KoParagCounter::NUM_NONE )
|
|
{
|
|
element = doc.createElement( "COUNTER" );
|
|
parentElem.appendChild( element );
|
|
if ( layout.counter )
|
|
layout.counter->save( element );
|
|
}
|
|
|
|
KoTabulatorList tabList = layout.tabList();
|
|
KoTabulatorList::ConstIterator it = tabList.begin();
|
|
for ( ; it != tabList.end() ; it++ )
|
|
{
|
|
element = doc.createElement( "TABULATOR" );
|
|
parentElem.appendChild( element );
|
|
element.setAttribute( "type", (*it).type );
|
|
element.setAttribute( "ptpos", (*it).ptPos );
|
|
element.setAttribute( "filling", (*it).filling );
|
|
if ( (*it).filling != TF_BLANK )
|
|
element.setAttribute( "width", TQString::number( (*it).ptWidth, 'g', DBL_DIG ) );
|
|
if ( (*it).type == T_DEC_PNT && !(*it).alignChar.isNull() )
|
|
element.setAttribute( "alignchar", TQString((*it).alignChar) );
|
|
}
|
|
}
|
|
|
|
void KoParagLayout::saveOasis( KoGenStyle& gs, KoSavingContext& context, bool savingStyle ) const
|
|
{
|
|
gs.addProperty( "fo:text-align", saveOasisAlignment( (TQt::AlignmentFlags)alignment ).data() );
|
|
// Don't save the direction for a style, if "auto", so that the
|
|
// auto-determination of direction based on first char, works.
|
|
if ( !savingStyle || (TQChar::Direction) direction != TQChar::DirON )
|
|
gs.addProperty( "style:writing-mode", (TQChar::Direction)direction == TQChar::DirR ? "rl-tb" : "lr-tb" );
|
|
gs.addPropertyPt( "fo:margin-left", margins[TQStyleSheetItem::MarginLeft] );
|
|
gs.addPropertyPt( "fo:margin-right", margins[TQStyleSheetItem::MarginRight] );
|
|
gs.addPropertyPt( "fo:text-indent", margins[TQStyleSheetItem::MarginFirstLine] );
|
|
gs.addPropertyPt( "fo:margin-top", margins[TQStyleSheetItem::MarginTop] );
|
|
gs.addPropertyPt( "fo:margin-bottom", margins[TQStyleSheetItem::MarginBottom] );
|
|
|
|
switch ( lineSpacingType ) {
|
|
case KoParagLayout::LS_SINGLE:
|
|
gs.addProperty( "fo:line-height", "100%" );
|
|
break;
|
|
case KoParagLayout::LS_ONEANDHALF:
|
|
gs.addProperty( "fo:line-height", "150%" );
|
|
break;
|
|
case KoParagLayout::LS_DOUBLE:
|
|
gs.addProperty( "fo:line-height", "200%" );
|
|
break;
|
|
case KoParagLayout::LS_MULTIPLE:
|
|
gs.addProperty( "fo:line-height", TQString::number( lineSpacing * 100.0 ) + '%' );
|
|
break;
|
|
case KoParagLayout::LS_FIXED:
|
|
gs.addPropertyPt( "fo:line-height", lineSpacing );
|
|
break;
|
|
case KoParagLayout::LS_CUSTOM:
|
|
gs.addPropertyPt( "style:line-spacing", lineSpacing );
|
|
break;
|
|
case KoParagLayout::LS_AT_LEAST:
|
|
gs.addPropertyPt( "style:line-height-at-least", lineSpacing );
|
|
break;
|
|
}
|
|
|
|
TQBuffer buffer;
|
|
buffer.open( IO_WriteOnly );
|
|
KoXmlWriter tabsWriter( &buffer, 4 ); // indent==4: root,autostyle,style,parag-props
|
|
tabsWriter.startElement( "style:tab-stops" );
|
|
KoTabulatorList::ConstIterator it = m_tabList.begin();
|
|
for ( ; it != m_tabList.end() ; it++ )
|
|
{
|
|
tabsWriter.startElement( "style:tab-stop" );
|
|
// Tab stop positions in the XML are relative to the left-margin
|
|
double pos = (*it).ptPos - margins[TQStyleSheetItem::MarginLeft];
|
|
tabsWriter.addAttributePt( "style:position", pos );
|
|
|
|
switch ( (*it).type ) {
|
|
case T_LEFT:
|
|
tabsWriter.addAttribute( "style:type", "left" );
|
|
break;
|
|
case T_CENTER:
|
|
tabsWriter.addAttribute( "style:type", "center" );
|
|
break;
|
|
case T_RIGHT:
|
|
tabsWriter.addAttribute( "style:type", "right" );
|
|
break;
|
|
case T_DEC_PNT: // "alignment on decimal point"
|
|
tabsWriter.addAttribute( "style:type", "char" );
|
|
if ( !(*it).alignChar.isNull() )
|
|
tabsWriter.addAttribute( "style:char", TQString( (*it).alignChar ) );
|
|
break;
|
|
case T_INVALID: // keep compiler happy, this can't happen
|
|
break;
|
|
}
|
|
switch( (*it).filling ) {
|
|
case TF_BLANK:
|
|
tabsWriter.addAttribute( "style:leader-type", "none" );
|
|
break;
|
|
case TF_LINE:
|
|
tabsWriter.addAttribute( "style:leader-type", "single" );
|
|
tabsWriter.addAttribute( "style:leader-style", "solid" );
|
|
// Give OOo a chance to show something, since it doesn't support lines here.
|
|
tabsWriter.addAttribute( "style:leader-text", "_" );
|
|
break;
|
|
case TF_DOTS:
|
|
tabsWriter.addAttribute( "style:leader-type", "single" );
|
|
tabsWriter.addAttribute( "style:leader-style", "dotted" );
|
|
// Give OOo a chance to show something, since it doesn't support lines here.
|
|
tabsWriter.addAttribute( "style:leader-text", "." );
|
|
break;
|
|
case TF_DASH:
|
|
tabsWriter.addAttribute( "style:leader-type", "single" );
|
|
tabsWriter.addAttribute( "style:leader-style", "dash" );
|
|
// Give OOo a chance to show something, since it doesn't support lines here.
|
|
tabsWriter.addAttribute( "style:leader-text", "_" );
|
|
break;
|
|
case TF_DASH_DOT:
|
|
tabsWriter.addAttribute( "style:leader-type", "single" );
|
|
tabsWriter.addAttribute( "style:leader-style", "dot-dash" );
|
|
// Give OOo a chance to show something, since it doesn't support lines here.
|
|
tabsWriter.addAttribute( "style:leader-text", "." );
|
|
break;
|
|
case TF_DASH_DOT_DOT:
|
|
tabsWriter.addAttribute( "style:leader-type", "single" );
|
|
tabsWriter.addAttribute( "style:leader-style", "dot-dot-dash" );
|
|
// Give OOo a chance to show something, since it doesn't support lines here.
|
|
tabsWriter.addAttribute( "style:leader-text", "." );
|
|
break;
|
|
}
|
|
if ( (*it).filling != TF_BLANK )
|
|
tabsWriter.addAttributePt( "style:leader-width", (*it).ptWidth );
|
|
// If we want to support it, oasis also defines style:leader-color
|
|
tabsWriter.endElement();
|
|
}
|
|
tabsWriter.endElement();
|
|
buffer.close();
|
|
TQString elementContents = TQString::fromUtf8( buffer.buffer(), buffer.buffer().size() );
|
|
gs.addChildElement( "style:tab-stops", elementContents );
|
|
|
|
if ( !joinBorder )
|
|
gs.addProperty( "style:join-border", "false" );
|
|
bool fourBordersEqual = leftBorder.penWidth() > 0 &&
|
|
leftBorder == rightBorder && rightBorder == topBorder && topBorder == bottomBorder;
|
|
if ( fourBordersEqual ) {
|
|
gs.addProperty( "fo:border", leftBorder.saveFoBorder() );
|
|
} else {
|
|
if ( leftBorder.penWidth() > 0 )
|
|
gs.addProperty( "fo:border-left", leftBorder.saveFoBorder() );
|
|
if ( rightBorder.penWidth() > 0 )
|
|
gs.addProperty( "fo:border-right", rightBorder.saveFoBorder() );
|
|
if ( topBorder.penWidth() > 0 )
|
|
gs.addProperty( "fo:border-top", topBorder.saveFoBorder() );
|
|
if ( bottomBorder.penWidth() > 0 )
|
|
gs.addProperty( "fo:border-bottom", bottomBorder.saveFoBorder() );
|
|
}
|
|
|
|
if ( pageBreaking & KoParagLayout::HardFrameBreakBefore )
|
|
gs.addProperty( "fo:break-before", context.hasColumns() ? "column" : "page" );
|
|
else if ( pageBreaking & KoParagLayout::HardFrameBreakAfter )
|
|
gs.addProperty( "fo:break-after", context.hasColumns() ? "column" : "page" );
|
|
if ( pageBreaking & KoParagLayout::KeepLinesTogether )
|
|
gs.addProperty( "fo:keep-together", "always" );
|
|
if ( pageBreaking & KoParagLayout::KeepWithNext )
|
|
gs.addProperty( "fo:keep-with-next", "always" );
|
|
|
|
gs.addProperty( "fo:background-color",
|
|
backgroundColor.isValid() ?
|
|
backgroundColor.name() : "transparent");
|
|
}
|