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.
koffice/kpresenter/KPrTextObject.cpp

2586 lines
97 KiB

/* This file is part of the KDE project
Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
Copyright (C) 2005-2006 Thorsten Zachmann <zachmann@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.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "KPrTextObject.h"
#include "KPrTextObject.moc"
#include "KPrGradient.h"
#include "KPrCommand.h"
#include "KPrCanvas.h"
#include "KPrPage.h"
#include "KPrView.h"
#include "KPrDocument.h"
#include "KPrBgSpellCheck.h"
#include "KPrVariableCollection.h"
#include <KoAutoFormat.h>
#include <KoTextParag.h>
#include <KoTextObject.h>
#include <KoStyleCollection.h>
#include <KoTextFormatter.h>
#include <KoTextZoomHandler.h>
#include "KPrTextViewIface.h"
#include "KPrTextObjectIface.h"
#include <KoOasisContext.h>
#include <KoStyleStack.h>
#include <tdetempfile.h>
#include <tdelocale.h>
#include <kdebug.h>
#include <tdeversion.h>
#include <tdemultipledrag.h>
#include <tqfont.h>
#include <tqfile.h>
#include <tqwidget.h>
#include <tqpicture.h>
#include <tqpainter.h>
#include <tqwmatrix.h>
#include <tqdom.h>
#include <tqapplication.h>
#include <tqfontdatabase.h>
#include <tqpopupmenu.h>
#include <tqclipboard.h>
#include <KoParagCounter.h>
#include <tdeaction.h>
#include <KoVariable.h>
#include <KoCustomVariablesDia.h>
#include <KoRuler.h>
#include <KoSize.h>
#include <KoXmlNS.h>
#include <KoDom.h>
#include <KoStore.h>
#include <KoStoreDrag.h>
#include <KoOasisStore.h>
#include <float.h>
using namespace std;
#undef S_NONE // Solaris defines it in sys/signal.h
const TQString &KPrTextObject::tagTEXTOBJ=TDEGlobal::staticQString("TEXTOBJ");
const TQString &KPrTextObject::attrLineSpacing=TDEGlobal::staticQString("lineSpacing");
const TQString &KPrTextObject::attrParagSpacing=TDEGlobal::staticQString("paragSpacing");
const TQString &KPrTextObject::attrMargin=TDEGlobal::staticQString("margin");
const TQString &KPrTextObject::attrBulletType1=TDEGlobal::staticQString("bulletType1");
const TQString &KPrTextObject::attrBulletType2=TDEGlobal::staticQString("bulletType2");
const TQString &KPrTextObject::attrBulletType3=TDEGlobal::staticQString("bulletType3");
const TQString &KPrTextObject::attrBulletType4=TDEGlobal::staticQString("bulletType4");
const TQString &KPrTextObject::attrBulletColor1=TDEGlobal::staticQString("bulletColor1");
const TQString &KPrTextObject::attrBulletColor2=TDEGlobal::staticQString("bulletColor2");
const TQString &KPrTextObject::attrBulletColor3=TDEGlobal::staticQString("bulletColor3");
const TQString &KPrTextObject::attrBulletColor4=TDEGlobal::staticQString("bulletColor4");
const TQString &KPrTextObject::tagP=TDEGlobal::staticQString("P");
const TQString &KPrTextObject::attrAlign=TDEGlobal::staticQString("align");
const TQString &KPrTextObject::attrType=TDEGlobal::staticQString("type");
const TQString &KPrTextObject::attrDepth=TDEGlobal::staticQString("depth");
const TQString &KPrTextObject::tagTEXT=TDEGlobal::staticQString("TEXT");
const TQString &KPrTextObject::attrFamily=TDEGlobal::staticQString("family");
const TQString &KPrTextObject::attrPointSize=TDEGlobal::staticQString("pointSize");
const TQString &KPrTextObject::attrBold=TDEGlobal::staticQString("bold");
const TQString &KPrTextObject::attrItalic=TDEGlobal::staticQString("italic");
const TQString &KPrTextObject::attrUnderline=TDEGlobal::staticQString("underline");
const TQString &KPrTextObject::attrStrikeOut=TDEGlobal::staticQString("strikeOut");
const TQString &KPrTextObject::attrColor=TDEGlobal::staticQString("color");
const TQString &KPrTextObject::attrWhitespace=TDEGlobal::staticQString("whitespace");
const TQString &KPrTextObject::attrTextBackColor=TDEGlobal::staticQString("textbackcolor");
const TQString &KPrTextObject::attrVertAlign=TDEGlobal::staticQString("VERTALIGN");
KPrTextObject::KPrTextObject( KPrDocument *doc )
: KPr2DObject()
{
m_doc=doc;
m_textVertAlign = KP_TOP;
// Default color should be TQColor() ... but kpresenter isn't fully color-scheme-aware yet
KoTextFormatCollection* fc = new KoTextFormatCollection( doc->defaultFont(), TQt::black, doc->globalLanguage(), doc->globalHyphenation() );
KPrTextDocument * textdoc = new KPrTextDocument( this, fc );
if ( m_doc->tabStopValue() != -1 )
textdoc->setTabStops( m_doc->zoomHandler()->ptToLayoutUnitPixX( m_doc->tabStopValue() ));
m_textobj = new KoTextObject( textdoc, m_doc->styleCollection()->findStyle( "Standard" ), this );
textdoc->setFlow( this );
m_doc->backSpeller()->registerNewTextObject( m_textobj );
pen = defaultPen();
drawEditRect = true;
drawEmpty = true;
editingTextObj = false;
bleft = 0.0;
btop = 0.0;
bright = 0.0;
bbottom = 0.0;
alignVertical = 0.0;
connect( m_textobj, TQ_SIGNAL( newCommand( KCommand * ) ),
TQ_SLOT( slotNewCommand( KCommand * ) ) );
connect( m_textobj, TQ_SIGNAL( availableHeightNeeded() ),
TQ_SLOT( slotAvailableHeightNeeded() ) );
connect( m_textobj, TQ_SIGNAL( repaintChanged( KoTextObject* ) ),
TQ_SLOT( slotRepaintChanged() ) );
// Send our "repaintChanged" signals to the document.
connect( this, TQ_SIGNAL( repaintChanged( KPrTextObject * ) ),
m_doc, TQ_SLOT( slotRepaintChanged( KPrTextObject * ) ) );
connect(m_textobj, TQ_SIGNAL( showFormatObject(const KoTextFormat &) ),
TQ_SLOT( slotFormatChanged(const KoTextFormat &)) );
connect( m_textobj, TQ_SIGNAL( afterFormatting( int, KoTextParag*, bool* ) ),
TQ_SLOT( slotAfterFormatting( int, KoTextParag*, bool* ) ) );
connect( m_textobj, TQ_SIGNAL( paragraphDeleted( KoTextParag*) ),
TQ_SLOT( slotParagraphDeleted(KoTextParag*) ));
}
KPrTextObject::~KPrTextObject()
{
textDocument()->takeFlow();
m_doc = 0L;
}
DCOPObject* KPrTextObject::dcopObject()
{
if ( !dcop )
dcop = new KPrTextObjectIface( this );
return dcop;
}
void KPrTextObject::slotParagraphDeleted(KoTextParag*_parag)
{
m_doc->spellCheckParagraphDeleted( _parag, this);
}
TQBrush KPrTextObject::getBrush() const
{
TQBrush tmpBrush( m_brush.getBrush() );
if(!tmpBrush.color().isValid())
tmpBrush.setColor(TQApplication::palette().color( TQPalette::Active, TQColorGroup::Base ));
return tmpBrush;
}
void KPrTextObject::resizeTextDocument( bool widthChanged, bool heightChanged )
{
if ( heightChanged )
{
// Recalc available height
slotAvailableHeightNeeded();
// Recalc the vertical centering, if enabled
recalcVerticalAlignment();
}
if ( widthChanged )
{
// not when simply changing the height, otherwise the auto-resize code
// prevents making a textobject less high than it currently is.
textDocument()->setWidth( m_doc->zoomHandler()->ptToLayoutUnitPixX( innerWidth() ) );
m_textobj->setLastFormattedParag( textDocument()->firstParag() );
m_textobj->formatMore( 2 );
}
}
void KPrTextObject::setSize( double _width, double _height )
{
bool widthModified = KABS( _width - ext.width() ) > DBL_EPSILON ; // floating-point equality test
bool heightModified = KABS( _height - ext.height() ) > DBL_EPSILON;
if ( widthModified || heightModified )
{
KPrObject::setSize( _width, _height );
resizeTextDocument( widthModified, heightModified ); // will call formatMore() if widthModified
}
}
TQDomDocumentFragment KPrTextObject::save( TQDomDocument& doc, double offset )
{
TQDomDocumentFragment fragment=KPr2DObject::save(doc, offset);
fragment.appendChild(saveKTextObject( doc ));
return fragment;
}
bool KPrTextObject::saveOasisObjectAttributes( KPOasisSaveContext &sc ) const
{
sc.xmlWriter.startElement( "draw:text-box" );
m_textobj->saveOasisContent( sc.xmlWriter, sc.context );
sc.xmlWriter.endElement();
return true;
}
const char * KPrTextObject::getOasisElementName() const
{
return "draw:frame";
}
void KPrTextObject::saveOasisMarginElement( KoGenStyle &styleobjectauto ) const
{
kdDebug()<<"void KPrTextObject::saveOasisMarginElement( KoGenStyle &styleobjectauto )\n";
if ( btop != 0.0 )
styleobjectauto.addPropertyPt("fo:padding-top", btop );
if ( bbottom != 0.0 )
styleobjectauto.addPropertyPt("fo:padding-bottom", bbottom );
if ( bleft != 0.0 )
styleobjectauto.addPropertyPt("fo:padding-left", bleft );
if ( bright != 0.0 )
styleobjectauto.addPropertyPt("fo:padding-right", bright );
//add vertical alignment
switch( m_textVertAlign )
{
case KP_TOP:
styleobjectauto.addProperty("draw:textarea-vertical-align", "top" );
break;
case KP_CENTER:
styleobjectauto.addProperty("draw:textarea-vertical-align", "middle" );
break;
case KP_BOTTOM:
styleobjectauto.addProperty("draw:textarea-vertical-align", "bottom" );
break;
}
// fo:padding-top="1.372cm" fo:padding-bottom="0.711cm" fo:padding-left="1.118cm" fo:padding-right="1.27cm"
}
void KPrTextObject::loadOasis(const TQDomElement &element, KoOasisContext& context,
KPrLoadingInfo *info )
{
KPr2DObject::loadOasis(element, context, info);
//todo other attribute
KoStyleStack &styleStack = context.styleStack();
styleStack.setTypeProperties( "graphic" );
if( styleStack.hasAttributeNS( KoXmlNS::fo, "padding-top" ) )
btop = KoUnit::parseValue( styleStack.attributeNS( KoXmlNS::fo, "padding-top" ) );
if( styleStack.hasAttributeNS( KoXmlNS::fo, "padding-bottom" ) )
bbottom = KoUnit::parseValue( styleStack.attributeNS( KoXmlNS::fo, "padding-bottom" ) );
if( styleStack.hasAttributeNS( KoXmlNS::fo, "padding-left") )
bleft = KoUnit::parseValue( styleStack.attributeNS( KoXmlNS::fo, "padding-left" ) );
if( styleStack.hasAttributeNS( KoXmlNS::fo, "padding-right" ) )
bright = KoUnit::parseValue( styleStack.attributeNS( KoXmlNS::fo, "padding-right" ) );
kdDebug()<<" KPrTextObject::loadOasis : btp :"<<btop<<" bbottom :"<<bbottom<<" bleft :"<<bleft<<" bright :"<<bright<<endl;
// vertical alignment
if ( styleStack.hasAttributeNS( KoXmlNS::draw, "textarea-vertical-align" ) )
{
TQString alignment = styleStack.attributeNS( KoXmlNS::draw, "textarea-vertical-align" );
if ( alignment == "top" )
m_textVertAlign= KP_TOP;
else if ( alignment == "middle" )
m_textVertAlign= KP_CENTER;
else if ( alignment == "bottom" )
m_textVertAlign= KP_BOTTOM;
}
kdDebug()<<" vertical Alignment :"<< ( ( m_textVertAlign== KP_TOP ) ? "top" : ( m_textVertAlign== KP_CENTER ) ? "center": "bottom" )<<endl;
TQDomElement tmp = KoDom::namedItemNS( element, KoXmlNS::draw, "text-box");
m_textobj->loadOasisContent( tmp, context, m_doc->styleCollection() );
resizeTextDocument(); // this will to formatMore()
}
double KPrTextObject::load(const TQDomElement &element)
{
double offset=KPr2DObject::load(element);
TQDomElement e=element.namedItem(tagTEXTOBJ).toElement();
if(!e.isNull()) {
if ( e.hasAttribute( "protectcontent"))
setProtectContent((bool)e.attribute( "protectcontent" ).toInt());
if (e.hasAttribute( "bleftpt"))
bleft = e.attribute( "bleftpt").toDouble();
if (e.hasAttribute( "brightpt"))
bright = e.attribute( "brightpt").toDouble();
if (e.hasAttribute( "btoppt"))
btop = e.attribute( "btoppt").toDouble();
if (e.hasAttribute( "bbottompt"))
bbottom = e.attribute( "bbottompt").toDouble();
if ( e.hasAttribute("verticalAlign"))
{
TQString str =e.attribute("verticalAlign");
if ( str == "bottom" )
m_textVertAlign= KP_BOTTOM;
else if ( str == "center" )
m_textVertAlign= KP_CENTER;
else if ( str == "top" )//never
m_textVertAlign= KP_TOP;
}
if ( e.hasAttribute( "verticalValue" ))
alignVertical = e.attribute( "verticalValue" ).toDouble();
loadKTextObject( e );
}
shadowCompatibility();
resizeTextDocument(); // this will to formatMore()
return offset;
}
void KPrTextObject::shadowCompatibility()
{
if ( shadowDistance != 0)
{
int sx = 0;
int sy = 0;
switch ( shadowDirection )
{
case SD_LEFT_BOTTOM:
case SD_LEFT:
case SD_LEFT_UP:
sx = - shadowDistance;
case SD_RIGHT_UP:
case SD_RIGHT:
case SD_RIGHT_BOTTOM:
sx = shadowDistance;
default:
break;
}
switch ( shadowDirection )
{
case SD_LEFT_UP:
case SD_UP:
case SD_RIGHT_UP:
sy = - shadowDistance;
case SD_LEFT_BOTTOM:
case SD_BOTTOM:
case SD_RIGHT_BOTTOM:
sy = shadowDistance;
default:
break;
}
KoTextFormat tmpFormat;
tmpFormat.setShadow( sx, sy, shadowColor );
KCommand* cmd = m_textobj->setFormatCommand( &tmpFormat, KoTextFormat::ShadowText );
delete cmd;
}
//force to reset shadow compatibility between koffice 1.1 and 1.2
shadowDirection = SD_RIGHT_BOTTOM;
shadowDistance = 0;
shadowColor = TQt::gray;
}
// Standard paint method for KP2DObjects.
void KPrTextObject::paint( TQPainter *_painter, KoTextZoomHandler*_zoomHandler,
int pageNum, bool drawingShadow, bool drawContour )
{
// Never draw shadow (in text objects, it's a character property, not an object property)
KPrPage *p = m_doc->pageList().at( pageNum );
// neccessary when on masterpage
if ( p )
recalcPageNum( p );
if ( drawingShadow ) return;
paint( _painter, _zoomHandler, false, 0L, true, drawContour );
}
// Special method for drawing a text object that is being edited
void KPrTextObject::paintEdited( TQPainter *_painter, KoTextZoomHandler*_zoomHandler,
bool onlyChanged, KoTextCursor* cursor, bool resetChanged )
{
_painter->save();
_painter->translate( _zoomHandler->zoomItX(orig.x()), _zoomHandler->zoomItY(orig.y()) );
if ( angle != 0 )
rotateObject(_painter,_zoomHandler);
paint( _painter, _zoomHandler, onlyChanged, cursor, resetChanged, false /*not drawContour*/ );
_painter->restore();
}
// Common functionality for the above 2 methods
void KPrTextObject::paint( TQPainter *_painter, KoTextZoomHandler*_zoomHandler,
bool onlyChanged, KoTextCursor* cursor, bool resetChanged,
bool drawContour )
{
double ow = ext.width();
double oh = ext.height();
double pw = pen.pointWidth() / 2;
if ( drawContour ) {
TQPen pen3( TQt::black, 1, TQt::DotLine );
_painter->setPen( pen3 );
_painter->setRasterOp( TQt::NotXorROP );
_painter->drawRect( _zoomHandler->zoomItX(pw), _zoomHandler->zoomItY(pw),
_zoomHandler->zoomItX(ow), _zoomHandler->zoomItY( oh) );
return;
}
_painter->save();
TQPen pen2 = pen.zoomedPen(_zoomHandler);
//TQRect clip=TQRect(_zoomHandler->zoomItX(pw), _zoomHandler->zoomItY(pw), _zoomHandler->zoomItX( ow - 2 * pw),_zoomHandler->zoomItY( oh - 2 * pw));
//setupClipRegion( _painter, clip );
//for debug
//_painter->fillRect( clip, TQt::blue );
_painter->setPen( pen2 );
if ( editingTextObj && _painter->device() && _painter->device()->devType() != TQInternal::Printer) // editing text object
_painter->setBrush( TQBrush( m_doc->txtBackCol(), TQt::SolidPattern ) );
else {
// Handle the rotation, draw the background/border, then call drawText()
if ( getFillType() == FT_BRUSH || !gradient ) {
_painter->setBrush( getBrush() );
}
else {
TQSize size( _zoomHandler->zoomSize( ext ) );
gradient->setSize( size );
_painter->drawPixmap( _zoomHandler->zoomItX(pw), _zoomHandler->zoomItX(pw), gradient->pixmap(), 0, 0,
_zoomHandler->zoomItX( ow - 2 * pw ),
_zoomHandler->zoomItY( oh - 2 * pw ) );
}
}
if ( !editingTextObj || !onlyChanged )
{
/// #### Port this to KoBorder, see e.g. kword/kwframe.cpp:590
// (so that the border gets drawn OUTSIDE of the object area)
_painter->drawRect( _zoomHandler->zoomItX(pw), _zoomHandler->zoomItX(pw), _zoomHandler->zoomItX( ow - 2 * pw),
_zoomHandler->zoomItY( oh - 2 * pw) );
}
drawText( _painter, _zoomHandler, onlyChanged, cursor, resetChanged );
_painter->restore();
// And now draw the border for text objects.
// When they are drawn outside of the object, this can be moved to the standard paint() method,
// so that we don't have to do it while editing the object, maybe.
if ( m_doc->firstView() && m_doc->firstView()->getCanvas()->getEditMode() &&
getDrawEditRect() && getPen().style() == TQt::NoPen )
{
_painter->save();
_painter->setPen( TQPen( TQt::gray, 1, TQt::DotLine ) );
_painter->setBrush( TQt::NoBrush );
_painter->setRasterOp( TQt::NotXorROP );
_painter->drawRect( 0, 0, _zoomHandler->zoomItX(ow), _zoomHandler->zoomItY( oh) );
_painter->restore();
}
}
// This method simply draws the paragraphs in the given painter
// Assumes the painter is already set up correctly.
void KPrTextObject::drawText( TQPainter* _painter, KoTextZoomHandler *zoomHandler, bool onlyChanged, KoTextCursor* cursor, bool resetChanged )
{
//kdDebug(33001) << "KPrTextObject::drawText onlyChanged=" << onlyChanged << " cursor=" << cursor << " resetChanged=" << resetChanged << endl;
recalcVerticalAlignment();
TQColorGroup cg = TQApplication::palette().active();
_painter->save();
_painter->translate( m_doc->zoomHandler()->zoomItX( bLeft()), m_doc->zoomHandler()->zoomItY( bTop()+alignVertical));
if ( !editingTextObj || (_painter->device() && _painter->device()->devType() == TQInternal::Printer))
cg.setBrush( TQColorGroup::Base, TQt::NoBrush );
else
cg.setColor( TQColorGroup::Base, m_doc->txtBackCol() );
TQRect r = zoomHandler->zoomRect( KoRect( 0, 0, innerWidth(), innerHeight() ) );
bool editMode = false;
if( m_doc->firstView() && m_doc->firstView()->getCanvas())
editMode = m_doc->firstView()->getCanvas()->getEditMode();
uint drawingFlags = 0;
if ( _painter->device() && _painter->device()->devType() != TQInternal::Printer )
drawingFlags |= KoTextDocument::DrawSelections;
if ( m_doc->backgroundSpellCheckEnabled() && editMode )
drawingFlags |= KoTextDocument::DrawMisspelledLine;
if ( !editMode )
drawingFlags |= KoTextDocument::DontDrawNoteVariable;
if ( m_doc->viewFormattingChars() && editMode )
drawingFlags |= KoTextDocument::DrawFormattingChars;
if ( specEffects )
{
switch ( effect2 )
{
case EF2T_PARA:
//kdDebug(33001) << "KPrTextObject::draw onlyCurrStep=" << onlyCurrStep << " subPresStep=" << subPresStep << endl;
drawParags( _painter, zoomHandler, cg, ( onlyCurrStep ? subPresStep : 0 ), subPresStep );
break;
default:
/*KoTextParag * lastFormatted =*/ textDocument()->drawWYSIWYG(
_painter, r.x(), r.y(), r.width(), r.height(),
cg, zoomHandler,
onlyChanged, cursor != 0, cursor, resetChanged, drawingFlags );
}
}
else
{
//kdDebug(33001) << "KPrTextObject::drawText r=" << DEBUGRECT(r) << endl;
/*KoTextParag * lastFormatted = */ textDocument()->drawWYSIWYG(
_painter, r.x(), r.y(), r.width(), r.height(),
cg, zoomHandler,
onlyChanged, cursor != 0, cursor, resetChanged, drawingFlags );
}
_painter->restore();
}
int KPrTextObject::getSubPresSteps() const
{
int paragraphs = 0;
KoTextParag * parag = textDocument()->firstParag();
for ( ; parag ; parag = parag->next() )
paragraphs++;
return paragraphs;
}
TQDomElement KPrTextObject::saveKTextObject( TQDomDocument& doc )
{
#if 0
KTextEditParag *parag = ktextobject.document()->firstParag();
KTextEditDocument::TextSettings textSettings = ktextobject.document()->textSettings();
#endif
TQDomElement textobj=doc.createElement(tagTEXTOBJ);
if ( isProtectContent() )
textobj.setAttribute( "protectcontent", (int)isProtectContent());
if (bleft !=0.0)
textobj.setAttribute( "bleftpt", bleft );
if (bright !=0.0)
textobj.setAttribute( "brightpt", bright );
if (btop !=0.0)
textobj.setAttribute( "btoppt", btop );
if (bbottom !=0.0)
textobj.setAttribute( "bbottompt", bbottom );
if ( m_textVertAlign != KP_TOP )
{
if ( m_textVertAlign == KP_BOTTOM )
textobj.setAttribute( "verticalAlign", "bottom" );
else if ( m_textVertAlign == KP_CENTER )
textobj.setAttribute( "verticalAlign", "center" );
else if ( m_textVertAlign == KP_TOP )//never
textobj.setAttribute( "verticalAlign", "top" );
textobj.setAttribute( "verticalValue",alignVertical );
}
#if 0
textobj.setAttribute(attrLineSpacing, ktextobject.document()->lineSpacing());
textobj.setAttribute(attrParagSpacing, ktextobject.document()->paragSpacing());
textobj.setAttribute(attrMargin, ktextobject.document()->margin());
textobj.setAttribute(attrBulletType1, (int)textSettings.bulletType[0]);
textobj.setAttribute(attrBulletType2, (int)textSettings.bulletType[1]);
textobj.setAttribute(attrBulletType3, (int)textSettings.bulletType[2]);
textobj.setAttribute(attrBulletType4, (int)textSettings.bulletType[3]);
textobj.setAttribute(attrBulletColor1, textSettings.bulletColor[0].name());
textobj.setAttribute(attrBulletColor2, textSettings.bulletColor[1].name());
textobj.setAttribute(attrBulletColor3, textSettings.bulletColor[2].name());
textobj.setAttribute(attrBulletColor4, textSettings.bulletColor[3].name());
#endif
KoTextParag *parag = static_cast<KoTextParag*> (textDocument()->firstParag());
// ### fix this loop (Werner)
while ( parag ) {
saveParagraph( doc, parag, textobj, 0, parag->length()-2 );
parag = static_cast<KoTextParag*>( parag->next());
}
return textobj;
}
void KPrTextObject::saveFormat( TQDomElement & element, KoTextFormat*lastFormat )
{
TQString tmpFamily, tmpColor, tmpTextBackColor;
unsigned int tmpBold=false, tmpItalic=false, tmpUnderline=false,tmpStrikeOut=false;
int tmpVerticalAlign=-1;
tmpFamily=lastFormat->font().family();
tmpBold=static_cast<unsigned int>(lastFormat->font().bold());
tmpItalic=static_cast<unsigned int>(lastFormat->font().italic());
tmpUnderline=static_cast<unsigned int>(lastFormat->underline());
tmpStrikeOut=static_cast<unsigned int>(lastFormat->strikeOut());
tmpColor=lastFormat->color().name();
tmpVerticalAlign=static_cast<unsigned int>(lastFormat->vAlign());
if(lastFormat->textBackgroundColor().isValid())
tmpTextBackColor=lastFormat->textBackgroundColor().name();
element.setAttribute(attrFamily, tmpFamily);
element.setAttribute(attrPointSize, lastFormat->pointSize());
if(tmpBold)
element.setAttribute(attrBold, tmpBold);
if(tmpItalic)
element.setAttribute(attrItalic, tmpItalic);
if ( lastFormat->underlineType()!= KoTextFormat::U_NONE )
{
if(lastFormat->doubleUnderline())
element.setAttribute(attrUnderline, "double");
if(lastFormat->underlineType()==KoTextFormat::U_SIMPLE_BOLD)
element.setAttribute(attrUnderline, "single-bold");
else if( lastFormat->underlineType()==KoTextFormat::U_WAVE)
element.setAttribute(attrUnderline, "wave");
else if(tmpUnderline)
element.setAttribute(attrUnderline, tmpUnderline);
TQString strLineType=KoTextFormat::underlineStyleToString( lastFormat->underlineStyle() );
element.setAttribute( "underlinestyleline", strLineType );
if ( lastFormat->textUnderlineColor().isValid() )
element.setAttribute( "underlinecolor", lastFormat->textUnderlineColor().name() );
}
if ( lastFormat->strikeOutType()!= KoTextFormat::S_NONE )
{
if ( lastFormat->doubleStrikeOut() )
element.setAttribute(attrStrikeOut, "double");
else if ( lastFormat->strikeOutType()== KoTextFormat::S_SIMPLE_BOLD)
element.setAttribute(attrStrikeOut, "single-bold");
else if(tmpStrikeOut)
element.setAttribute(attrStrikeOut, tmpStrikeOut);
TQString strLineType=KoTextFormat::strikeOutStyleToString( lastFormat->strikeOutStyle() );
element.setAttribute( "strikeoutstyleline", strLineType );
}
element.setAttribute(attrColor, tmpColor);
if(!tmpTextBackColor.isEmpty())
element.setAttribute(attrTextBackColor, tmpTextBackColor);
if(tmpVerticalAlign!=-1)
{
element.setAttribute(attrVertAlign,tmpVerticalAlign);
if(lastFormat->relativeTextSize()!=0.66)
element.setAttribute("relativetextsize",lastFormat->relativeTextSize());
}
if ( lastFormat->shadowDistanceX() != 0
|| lastFormat->shadowDistanceY() != 0)
element.setAttribute("text-shadow", lastFormat->shadowAsCss());
if ( lastFormat->offsetFromBaseLine()!=0 )
element.setAttribute( "offsetfrombaseline" , lastFormat->offsetFromBaseLine());
if ( lastFormat->wordByWord() )
element.setAttribute("wordbyword", true);
if ( lastFormat->attributeFont()!= KoTextFormat::ATT_NONE )
element.setAttribute("fontattribute", KoTextFormat::attributeFontToString(lastFormat->attributeFont() ));
if ( !lastFormat->language().isEmpty())
element.setAttribute("language", lastFormat->language());
}
TQDomElement KPrTextObject::saveHelper(const TQString &tmpText,KoTextFormat*lastFormat , TQDomDocument &doc)
{
TQDomElement element=doc.createElement(tagTEXT);
saveFormat ( element, lastFormat );
if(tmpText.stripWhiteSpace().isEmpty())
// working around a bug in TQDom
element.setAttribute(attrWhitespace, tmpText.length());
element.appendChild(doc.createTextNode(tmpText));
return element;
}
void KPrTextObject::fillStyle( KoGenStyle& styleObjectAuto, KoGenStyles& mainStyles ) const
{
KPr2DObject::fillStyle( styleObjectAuto, mainStyles );
saveOasisMarginElement( styleObjectAuto );
}
void KPrTextObject::loadKTextObject( const TQDomElement &elem )
{
TQDomElement e = elem.firstChild().toElement();
KoTextParag *lastParag = static_cast<KoTextParag *>(textDocument()->firstParag());
int i = 0;
int listNum = 0;
// Initialize lineSpacing and paragSpacing with the values of the object-level attributes
// (KOffice-1.1 file format)
int lineSpacing = elem.attribute( attrLineSpacing ).toInt();
int bottomBorder = elem.attribute( attrParagSpacing ).toInt();
int topBorder = 0;
while ( !e.isNull() ) {
TQValueList<TQDomElement> listVariable;
listVariable.clear();
if ( e.tagName() == tagP ) {
TQDomElement n = e.firstChild().toElement();
//skip the whitespace if it's a bullet/number
if( e.hasAttribute( attrType ) && n.hasAttribute( attrWhitespace ) )
if ( e.attribute( attrType )!="0" && n.attribute( attrWhitespace )=="1" ) {
e = e.nextSibling().toElement();
continue;
}
KoParagLayout paragLayout = loadParagLayout(e, m_doc, true);
// compatibility (bullet/numbering depth); only a simulation thru the margins, this is how it _looked_ before
double depth = 0.0;
if( e.hasAttribute(attrDepth) ) {
depth = e.attribute( attrDepth ).toDouble();
paragLayout.margins[TQStyleSheetItem::MarginLeft] = depth * MM_TO_POINT(10.0);
}
//kdDebug(33001) << k_funcinfo << "old bullet depth is: " << depth << endl;
// 1.1 compatibility (bullets)
TQString type;
if( e.hasAttribute(attrType) )
type = e.attribute( attrType );
//kdDebug(33001) << k_funcinfo << "old PARAG type is: " << type << endl;
// Do not import type="2" (enum list). The enum was there in 1.1, but not the code!
if(type == "1")
{
if(!paragLayout.counter)
paragLayout.counter = new KoParagCounter;
paragLayout.counter->setStyle(KoParagCounter::STYLE_DISCBULLET);
paragLayout.counter->setNumbering(KoParagCounter::NUM_LIST);
paragLayout.counter->setPrefix(TQString());
paragLayout.counter->setSuffix(TQString());
}
// This is for very old (KOffice-1.0) documents.
if ( e.hasAttribute( attrLineSpacing ) )
lineSpacing = e.attribute( attrLineSpacing ).toInt();
if ( e.hasAttribute( "distBefore" ) )
topBorder = e.attribute( "distBefore" ).toInt();
if ( e.hasAttribute( "distAfter" ) )
bottomBorder = e.attribute( "distAfter" ).toInt();
// Apply values coming from 1.0 or 1.1 documents
if ( paragLayout.lineSpacingValue() == 0 )
paragLayout.setLineSpacingValue(lineSpacing);
if ( paragLayout.margins[ TQStyleSheetItem::MarginTop ] == 0 )
paragLayout.margins[ TQStyleSheetItem::MarginTop ] = topBorder;
if ( paragLayout.margins[ TQStyleSheetItem::MarginBottom ] == 0 )
paragLayout.margins[ TQStyleSheetItem::MarginBottom ] = bottomBorder;
lastParag->setParagLayout( paragLayout );
//lastParag->setAlign(TQt::AlignAuto);
if(e.hasAttribute(attrAlign))
{
int tmpAlign=e.attribute( attrAlign ).toInt();
if(tmpAlign==1 || tmpAlign==0 /* a kpresenter version I think a cvs version saved leftAlign = 0 for header/footer */)
lastParag->setAlign(TQt::AlignLeft);
else if(tmpAlign==2)
lastParag->setAlign(TQt::AlignRight);
else if(tmpAlign==4)
lastParag->setAlign(TQt::AlignHCenter);
else if(tmpAlign==8)
lastParag->setAlign(TQt::AlignJustify);
else
kdDebug(33001) << "Error in e.attribute( attrAlign ).toInt()" << endl;
}
// ######## TODO paragraph direction (LTR or RTL)
// TODO check/convert values
bool firstTextTag = true;
while ( !n.isNull() ) {
if ( n.tagName() == tagTEXT ) {
if ( firstTextTag ) {
lastParag->remove( 0, 1 ); // Remove current trailing space
firstTextTag = false;
}
KoTextFormat fm = loadFormat( n, lastParag->paragraphFormat(), m_doc->defaultFont(), m_doc->globalLanguage(),
m_doc->globalHyphenation() );
TQString txt = n.firstChild().toText().data();
if(n.hasAttribute(attrWhitespace)) {
int ws=n.attribute(attrWhitespace).toInt();
txt.fill(' ', ws);
}
n=n.nextSibling().toElement();
if ( n.isNull() )
txt += ' '; // trailing space at end of paragraph
lastParag->append( txt, true );
lastParag->setFormat( i, txt.length(), textDocument()->formatCollection()->format( &fm ) );
//kdDebug(33001)<<"setFormat :"<<txt<<" i :"<<i<<" txt.length() "<<txt.length()<<endl;
i += txt.length();
}
else if ( n.tagName() == "CUSTOM" )
{
listVariable.append( n );
n = n.nextSibling().toElement();
}
else
n = n.nextSibling().toElement();
}
} else if ( e.tagName() == "UNSORTEDLISTTYPE" ) {
if ( listNum < 4 ) {
//TQColor c( e.attribute( "red" ).toInt(), e.attribute( "green" ).toInt(), e.attribute( "blue" ).toInt() );
// ## settings.bulletColor[ listNum++ ] = c;
}
}
e = e.nextSibling().toElement();
loadVariable( listVariable,lastParag );
if ( e.isNull() )
break;
i = 0;
if ( !lastParag->length() == 0 )
lastParag = new KoTextParag( textDocument(), lastParag, 0 );
}
}
void KPrTextObject::loadVariable( TQValueList<TQDomElement> & listVariable,KoTextParag *lastParag, int offset )
{
TQValueList<TQDomElement>::Iterator it = listVariable.begin();
TQValueList<TQDomElement>::Iterator end = listVariable.end();
for ( ; it != end ; ++it )
{
TQDomElement elem = *it;
if ( !elem.hasAttribute("pos"))
continue;
int index = elem.attribute("pos").toInt();
index+=offset;
TQDomElement varElem = elem.namedItem( "VARIABLE" ).toElement();
if ( !varElem.isNull() )
{
TQDomElement typeElem = varElem.namedItem( "TYPE" ).toElement();
int type = typeElem.attribute( "type" ).toInt();
TQString key = typeElem.attribute( "key" );
int correct = 0;
if (typeElem.hasAttribute( "correct" ))
correct = typeElem.attribute("correct").toInt();
kdDebug(33001) << "loadKTextObject variable type=" << type << " key=" << key << endl;
KoVariableFormat * varFormat = key.isEmpty() ? 0 : m_doc->variableFormatCollection()->format( key.latin1() );
// If varFormat is 0 (no key specified), the default format will be used.
KoVariable * var =m_doc->getVariableCollection()->createVariable( type, -1, m_doc->variableFormatCollection(),
varFormat, lastParag->textDocument(),
m_doc, correct, true/* force default format for date/time*/ );
if ( var )
{
var->load( varElem );
KoTextFormat format = loadFormat( *it, lastParag->paragraphFormat(), m_doc->defaultFont(), m_doc->globalLanguage(),
m_doc->globalHyphenation() );
lastParag->setCustomItem( index, var, lastParag->document()->formatCollection()->format( &format ));
var->recalc();
}
}
}
}
KoTextFormat KPrTextObject::loadFormat( TQDomElement &n, KoTextFormat * refFormat, const TQFont & defaultFont,
const TQString & defaultLanguage, bool hyphen )
{
KoTextFormat format;
format.setHyphenation( hyphen );
TQFont fn;
if ( refFormat )
{
format = *refFormat;
format.setCollection( 0 ); // Out of collection copy
fn = format.font();
}
else
fn = defaultFont;
if ( !n.isNull() )
{
TQFontDatabase fdb;
TQStringList families = fdb.families();
if ( families.findIndex( n.attribute( attrFamily ) ) != -1 )
fn.setFamily( n.attribute( attrFamily ) );
else
fn = defaultFont;
}
else if ( !refFormat )
{ // No reference format and no FONT tag -> use default font
fn = defaultFont;
}
int size = n.attribute( attrPointSize ).toInt();
bool bold=false;
if(n.hasAttribute(attrBold))
bold = (bool)n.attribute( attrBold ).toInt();
bool italic = false;
if(n.hasAttribute(attrItalic))
italic=(bool)n.attribute( attrItalic ).toInt();
if(n.hasAttribute( attrUnderline ))
{
TQString value = n.attribute( attrUnderline );
if ( value == "double" )
format.setUnderlineType ( KoTextFormat::U_DOUBLE);
else if ( value == "single" )
format.setUnderlineType ( KoTextFormat::U_SIMPLE);
else if ( value == "single-bold" )
format.setUnderlineType ( KoTextFormat::U_SIMPLE_BOLD);
else if( value =="wave" )
format.setUnderlineType( KoTextFormat::U_WAVE);
else
format.setUnderlineType ( (bool)value.toInt() ? KoTextFormat::U_SIMPLE :KoTextFormat::U_NONE);
}
if (n.hasAttribute("underlinestyleline") )
format.setUnderlineStyle( KoTextFormat::stringToUnderlineStyle( n.attribute("underlinestyleline") ));
if (n.hasAttribute("underlinecolor"))
format.setTextUnderlineColor(TQColor(n.attribute("underlinecolor")));
if(n.hasAttribute(attrStrikeOut))
{
TQString value = n.attribute( attrStrikeOut );
if ( value == "double" )
format.setStrikeOutType ( KoTextFormat::S_DOUBLE);
else if ( value == "single" )
format.setStrikeOutType ( KoTextFormat::S_SIMPLE);
else if ( value == "single-bold" )
format.setStrikeOutType ( KoTextFormat::S_SIMPLE_BOLD);
else
format.setStrikeOutType ( (bool)value.toInt() ? KoTextFormat::S_SIMPLE :KoTextFormat::S_NONE);
}
if (n.hasAttribute("strikeoutstyleline"))
{
TQString strLineType = n.attribute("strikeoutstyleline");
format.setStrikeOutStyle( KoTextFormat::stringToStrikeOutStyle( strLineType ));
}
TQString color = n.attribute( attrColor );
fn.setPointSize( size );
fn.setBold( bold );
fn.setItalic( italic );
//kdDebug(33001) << "KPrTextObject::loadFormat: family=" << fn.family() << " size=" << fn.pointSize() << endl;
TQColor col( color );
format.setFont( fn );
format.setColor( col );
TQString textBackColor=n.attribute(attrTextBackColor);
if(!textBackColor.isEmpty())
{
TQColor tmpCol(textBackColor);
tmpCol=tmpCol.isValid() ? tmpCol : TQApplication::palette().color( TQPalette::Active, TQColorGroup::Base );
format.setTextBackgroundColor(tmpCol);
}
if(n.hasAttribute(attrVertAlign))
format.setVAlign( static_cast<KoTextFormat::VerticalAlignment>(n.attribute(attrVertAlign).toInt() ) );
if ( n.hasAttribute("text-shadow") )
format.parseShadowFromCss( n.attribute("text-shadow") );
if ( n.hasAttribute("relativetextsize") )
format.setRelativeTextSize( n.attribute("relativetextsize").toDouble() ) ;
if ( n.hasAttribute("offsetfrombaseline") )
format.setOffsetFromBaseLine( static_cast<int>(n.attribute("offsetfrombaseline").toInt() ) );
if ( n.hasAttribute("wordbyword") )
format.setWordByWord( static_cast<int>(n.attribute("wordbyword").toInt() ) );
if ( n.hasAttribute("fontattribute") )
format.setAttributeFont( KoTextFormat::stringToAttributeFont(n.attribute("fontattribute") ) );
if ( n.hasAttribute("language"))
format.setLanguage( n.attribute("language"));
else
{ // No reference format and no language tag -> use default font
format.setLanguage( defaultLanguage);
}
//kdDebug(33001)<<"loadFormat :"<<format.key()<<endl;
return format;
}
KoParagLayout KPrTextObject::loadParagLayout( TQDomElement & parentElem, KPrDocument *doc, bool findStyle)
{
KoParagLayout layout;
// Only when loading paragraphs, not when loading styles
if ( findStyle )
{
KoParagStyle *style;
// Name of the style. If there is no style, then we do not supply
// any default!
TQDomElement element = parentElem.namedItem( "NAME" ).toElement();
if ( !element.isNull() )
{
TQString styleName = element.attribute( "value" );
style = doc->styleCollection()->findStyle( styleName );
if (!style)
{
kdError(33001) << "Cannot find style \"" << styleName << "\" specified in paragraph LAYOUT - using Standard" << endl;
style = doc->styleCollection()->findStyle( "Standard" );
}
//else kdDebug(33001) << "KoParagLayout::KoParagLayout setting style to " << style << " " << style->name() << endl;
}
else
{
kdError(33001) << "Missing NAME tag in paragraph LAYOUT - using Standard" << endl;
style = doc->styleCollection()->findStyle( "Standard" );
}
Q_ASSERT(style);
layout.style = style;
}
TQDomElement element = parentElem.namedItem( "INDENTS" ).toElement();
if ( !element.isNull() )
{
double val=0.0;
if(element.hasAttribute("first"))
val=element.attribute("first").toDouble();
layout.margins[TQStyleSheetItem::MarginFirstLine] = val;
val=0.0;
if(element.hasAttribute( "left"))
// The GUI prevents a negative indent, so let's fixup broken docs too
val=TQMAX(0, element.attribute( "left").toDouble());
layout.margins[TQStyleSheetItem::MarginLeft] = val;
val=0.0;
if(element.hasAttribute("right"))
// The GUI prevents a negative indent, so let's fixup broken docs too
val=TQMAX(0, element.attribute("right").toDouble());
layout.margins[TQStyleSheetItem::MarginRight] = val;
}
element = parentElem.namedItem( "LINESPACING" ).toElement();
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.setLineSpacingValue(0);
}
else if ( value == "double" )
{
layout.lineSpacingType = KoParagLayout::LS_DOUBLE;
layout.setLineSpacingValue(0);
}
else
{
layout.lineSpacingType = KoParagLayout::LS_CUSTOM;
layout.setLineSpacingValue(value.toDouble());
}
}
else
{
TQString type = element.attribute( "type" );
if ( type == "oneandhalf" )
{
layout.lineSpacingType = KoParagLayout::LS_ONEANDHALF;
layout.setLineSpacingValue(0);
}
else if ( type == "double" )
{
layout.lineSpacingType = KoParagLayout::LS_DOUBLE;
layout.setLineSpacingValue(0);
}
else if ( type == "custom" )
{
layout.lineSpacingType = KoParagLayout::LS_CUSTOM;
layout.setLineSpacingValue(element.attribute( "spacingvalue" ).toDouble());
}
else if ( type == "atleast" )
{
layout.lineSpacingType = KoParagLayout::LS_AT_LEAST;
layout.setLineSpacingValue(element.attribute( "spacingvalue" ).toDouble());
}
else if ( type == "multiple" )
{
layout.lineSpacingType = KoParagLayout::LS_MULTIPLE;
layout.setLineSpacingValue(element.attribute( "spacingvalue" ).toDouble());
}
}
}
element = parentElem.namedItem( "OFFSETS" ).toElement();
if ( !element.isNull() )
{
double val =0.0;
if(element.hasAttribute("before"))
val=TQMAX(0, element.attribute("before").toDouble());
layout.margins[TQStyleSheetItem::MarginTop] = val;
val = 0.0;
if(element.hasAttribute("after"))
val=TQMAX(0, element.attribute("after").toDouble());
layout.margins[TQStyleSheetItem::MarginBottom] = val;
}
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 );
}
KoTabulatorList tabList;
element = parentElem.firstChild().toElement();
for ( ; !element.isNull() ; element = element.nextSibling().toElement() )
{
if ( element.tagName() == "TABULATOR" )
{
KoTabulator tab;
tab.type=T_LEFT;
if(element.hasAttribute("type"))
tab.type = static_cast<KoTabulators>( element.attribute("type").toInt());
tab.ptPos=0.0;
if(element.hasAttribute("ptpos"))
tab.ptPos=element.attribute("ptpos").toDouble();
tab.filling=TF_BLANK;
if(element.hasAttribute("filling"))
tab.filling = static_cast<KoTabulatorFilling>( element.attribute("filling").toInt());
tab.ptWidth=0.5;
if(element.hasAttribute("width"))
tab.ptWidth=element.attribute("width").toDouble();
tabList.append( tab );
}
}
layout.setTabList( tabList );
return layout;
}
void KPrTextObject::saveParagLayout( const KoParagLayout& layout, TQDomElement & parentElem )
{
TQDomDocument doc = parentElem.ownerDocument();
TQDomElement element = doc.createElement( "NAME" );
parentElem.appendChild( element );
if ( layout.style )
element.setAttribute( "value", layout.style->name() );
else
kdWarning() << "KWTextParag::saveParagLayout: style==0L!" << endl;
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 != KoParagLayout::LS_SINGLE )
{
element = doc.createElement( "LINESPACING" );
parentElem.appendChild( element );
if ( layout.lineSpacingType == KoParagLayout::LS_ONEANDHALF )
element.setAttribute( "type", "oneandhalf" );
else if ( layout.lineSpacingType == KoParagLayout::LS_DOUBLE )
element.setAttribute( "type", "double" );
else if ( layout.lineSpacingType == KoParagLayout::LS_CUSTOM )
{
element.setAttribute( "type", "custom" );
element.setAttribute( "spacingvalue", layout.lineSpacingValue());
}
else if ( layout.lineSpacingType == KoParagLayout::LS_AT_LEAST )
{
element.setAttribute( "type", "atleast" );
element.setAttribute( "spacingvalue", layout.lineSpacingValue());
}
else if ( layout.lineSpacingType == KoParagLayout::LS_MULTIPLE )
{
element.setAttribute( "type", "multiple" );
element.setAttribute( "spacingvalue", layout.lineSpacingValue());
}
else
kdDebug(33001) << " error in lineSpacing Type" << endl;
}
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 );
element.setAttribute( "width", (*it).ptWidth );
}
}
void KPrTextObject::recalcPageNum( KPrPage *page )
{
int pgnum=m_doc->pageList().findRef(page);
pgnum+=1;
TQPtrListIterator<KoTextCustomItem> cit( textDocument()->allCustomItems() );
for ( ; cit.current() ; ++cit )
{
KPrPgNumVariable * var = dynamic_cast<KPrPgNumVariable *>( cit.current() );
if ( var && !var->isDeleted() )
{
switch ( var->subType() ) {
case KPrPgNumVariable::VST_PGNUM_CURRENT:
var->setPgNum( pgnum + kPresenterDocument()->getVariableCollection()->variableSetting()->startingPageNumber()-1);
break;
case KPrPgNumVariable::VST_CURRENT_SECTION:
var->setSectionTitle( page->pageTitle() );
break;
case KPrPgNumVariable::VST_PGNUM_PREVIOUS:
var->setPgNum( TQMAX( pgnum -1 , 0) +
kPresenterDocument()->getVariableCollection()->variableSetting()->startingPageNumber());
break;
case KPrPgNumVariable::VST_PGNUM_NEXT:
var->setPgNum( TQMIN( (int)m_doc->getPageNums(), pgnum+1 ) +
kPresenterDocument()->getVariableCollection()->variableSetting()->startingPageNumber());
break;
default:
break;
}
var->resize();
var->paragraph()->invalidate( 0 ); // size may have changed -> need reformatting !
var->paragraph()->setChanged( true );
}
}
}
void KPrTextObject::layout()
{
invalidate();
// Get the thing going though, repainting doesn't call formatMore
m_textobj->formatMore( 2 );
}
void KPrTextObject::invalidate()
{
//kdDebug(33001) << "KWTextFrameSet::invalidate " << getName() << endl;
m_textobj->setLastFormattedParag( textDocument()->firstParag() );
textDocument()->formatter()->setViewFormattingChars( m_doc->viewFormattingChars() );
textDocument()->invalidate(); // lazy layout, real update follows upon next repaint
}
// For the "paragraph after paragraph" effect
void KPrTextObject::drawParags( TQPainter *painter, KoTextZoomHandler* zoomHandler, const TQColorGroup& cg, int from, int to )
{
// The fast and difficult way would be to call drawParagWYSIWYG
// only on the paragraphs to be drawn. Then we have duplicate quite some code
// (or lose double-buffering).
// Easy (and not so slow) way:
// we call KoTextDocument::drawWYSIWYG with a cliprect.
Q_ASSERT( from <= to );
int i = 0;
bool editMode=false;
if( m_doc->firstView() && m_doc->firstView()->getCanvas())
editMode = m_doc->firstView()->getCanvas()->getEditMode();
TQRect r = zoomHandler->zoomRect( KoRect( 0, 0, innerWidth(), innerHeight() ) );
KoTextParag *parag = textDocument()->firstParag();
while ( parag ) {
if ( !parag->isValid() )
parag->format();
if ( i == from )
r.setTop( m_doc->zoomHandler()->layoutUnitToPixelY( parag->rect().top() ) );
if ( i == to ) {
r.setBottom( m_doc->zoomHandler()->layoutUnitToPixelY( parag->rect().bottom() ) );
break;
}
++i;
parag = parag->next();
}
uint drawingFlags = 0; // don't draw selections
if ( m_doc->backgroundSpellCheckEnabled() && editMode )
drawingFlags |= KoTextDocument::DrawMisspelledLine;
textDocument()->drawWYSIWYG(
painter, r.x(), r.y(), r.width(), r.height(),
cg, m_doc->zoomHandler(), // TODO (long term) the view's zoomHandler
false /*onlyChanged*/, false /*cursor != 0*/, 0 /*cursor*/,
true /*resetChanged*/, drawingFlags );
}
void KPrTextObject::drawCursor( TQPainter *p, KoTextCursor *cursor, bool cursorVisible, KPrCanvas* canvas )
{
// The implementation is very related to KWord's KWTextFrameSet::drawCursor
KoTextZoomHandler *zh = m_doc->zoomHandler();
TQPoint origPix = zh->zoomPoint( orig+KoPoint(bLeft(), bTop()+alignVertical) );
// Painter is already translated for diffx/diffy, but not for the object yet
p->translate( origPix.x(), origPix.y() );
if ( angle != 0 )
rotateObject( p, zh );
KoTextParag* parag = cursor->parag();
TQPoint topLeft = parag->rect().topLeft(); // in TQRT coords
int lineY;
// Cursor height, in pixels
int cursorHeight = zh->layoutUnitToPixelY( topLeft.y(), parag->lineHeightOfChar( cursor->index(), 0, &lineY ) );
TQPoint iPoint( topLeft.x() + cursor->x(),
topLeft.y() + lineY );
// from now on, iPoint will be in pixels
iPoint = zh->layoutUnitToPixel( iPoint );
TQPoint vPoint = iPoint; // vPoint and iPoint are the same currently
// do not simplify this, will be useful with viewmodes.
//int xadj = parag->at( cursor->index() )->pixelxadj;
//iPoint.rx() += xadj;
//vPoint.rx() += xadj;
// very small clipping around the cursor
TQRect clip( vPoint.x() - 5, vPoint.y() , 10, cursorHeight );
setupClipRegion( p, clip );
// for debug only!
//p->fillRect( clip, TQt::blue );
TQPixmap *pix = 0;
TQColorGroup cg = TQApplication::palette().active();
cg.setColor( TQColorGroup::Base, m_doc->txtBackCol() );
uint drawingFlags = KoTextDocument::DrawSelections;
if ( m_doc->backgroundSpellCheckEnabled() )
drawingFlags |= KoTextDocument::DrawMisspelledLine;
if ( m_doc->viewFormattingChars() )
drawingFlags |= KoTextDocument::DrawFormattingChars;
// To force the drawing to happen:
bool wasChanged = parag->hasChanged();
int oldLineChanged = parag->lineChanged();
int line; // line number
parag->lineStartOfChar( cursor->index(), 0, &line );
parag->setChanged( false ); // not all changed, only from a given line
parag->setLineChanged( line );
//kdDebug(33001) << "KPrTextObject::drawCursor cursorVisible=" << cursorVisible << " line=" << line << endl;
textDocument()->drawParagWYSIWYG(
p, parag,
TQMAX(0, iPoint.x() - 5), // negative values create problems
iPoint.y(), clip.width(), clip.height(),
pix, cg, m_doc->zoomHandler(),
cursorVisible, cursor, FALSE /*resetChanged*/, drawingFlags );
if ( wasChanged ) // Maybe we have more changes to draw, than those in the small cliprect
cursor->parag()->setLineChanged( oldLineChanged ); // -1 = all
else
cursor->parag()->setChanged( false );
// XIM Position
TQPoint ximPoint = vPoint;
TQFont f = parag->at( cursor->index() )->format()->font();
canvas->setXimPosition( ximPoint.x() + origPix.x(), ximPoint.y() + origPix.y(),
0, cursorHeight - parag->lineSpacing( line ), &f );
}
KPrTextDocument * KPrTextObject::textDocument() const
{
return static_cast<KPrTextDocument*>(m_textobj->textDocument());
}
void KPrTextObject::slotNewCommand( KCommand * cmd)
{
m_doc->addCommand(cmd);
}
int KPrTextObject::availableHeight() const
{
return m_textobj->availableHeight();
}
void KPrTextObject::slotAvailableHeightNeeded()
{
int ah = m_doc->zoomHandler()->ptToLayoutUnitPixY( innerHeight() );
m_textobj->setAvailableHeight( ah );
//kdDebug(33001)<<"slotAvailableHeightNeeded: height=:"<<ah<<endl;
}
void KPrTextObject::slotRepaintChanged()
{
emit repaintChanged( this );
}
KPrTextView * KPrTextObject::createKPTextView( KPrCanvas * _canvas, bool temp )
{
return new KPrTextView( this, _canvas, temp );
}
void KPrTextObject::removeHighlight ()
{
m_textobj->removeHighlight( true /*repaint*/ );
}
void KPrTextObject::highlightPortion( KoTextParag * parag, int index, int length, KPrCanvas* canvas, bool repaint, KDialogBase* dialog )
{
m_textobj->highlightPortion( parag, index, length, repaint );
if ( repaint )
{
KPrDocument* doc = canvas->getView()->kPresenterDoc();
// Is this object in the current active page?
if ( canvas->activePage()->findTextObject( this ) )
{
kdDebug(33001) << k_funcinfo << "object in current page" << endl;
}
else
{
// No -> find the right page and activate it
// ** slow method **
KPrPage* page = doc->findPage( this );
if ( page ) {
int pageNum = doc->pageList().findRef( page );
// if the pageNum is -1 the object is located on the master slide
if ( pageNum > -1 )
{
canvas->getView()->skipToPage( pageNum );
}
} else
kdWarning(33001) << "object " << this << " not found in any page!?" << endl;
}
// Now ensure text is fully visible
TQRect rect = m_doc->zoomHandler()->zoomRect( getRect() );
TQRect expose = m_doc->zoomHandler()->layoutUnitToPixel( parag->rect() );
expose.moveBy( rect.x(), rect.y() );
canvas->ensureVisible( (expose.left()+expose.right()) / 2, // point = center of the rect
(expose.top()+expose.bottom()) / 2,
(expose.right()-expose.left()) / 2, // margin = half-width of the rect
(expose.bottom()-expose.top()) / 2);
#if KDE_IS_VERSION(3,1,90)
if ( dialog ) {
TQRect globalRect( expose );
globalRect.moveTopLeft( canvas->mapToGlobal( globalRect.topLeft() ) );
KDialog::avoidArea( dialog, globalRect );
}
#endif
}
}
KCommand * KPrTextObject::pasteOasis( KoTextCursor * cursor, const TQByteArray & data, bool removeSelected )
{
//kdDebug(33001) << "KPrTextObject::pasteOasis" << endl;
KMacroCommand * macroCmd = new KMacroCommand( i18n("Paste Text") );
if ( removeSelected && textDocument()->hasSelection( KoTextDocument::Standard ) )
macroCmd->addCommand( m_textobj->removeSelectedTextCommand( cursor, KoTextDocument::Standard ) );
m_textobj->emitHideCursor();
m_textobj->setLastFormattedParag( cursor->parag()->prev() ?
cursor->parag()->prev() : cursor->parag() );
// We have our own command for this.
// Using insert() wouldn't help storing the parag stuff for redo
KPrOasisPasteTextCommand * cmd = new KPrOasisPasteTextCommand( textDocument(), cursor->parag()->paragId(), cursor->index(), data );
textDocument()->addCommand( cmd );
macroCmd->addCommand( new KoTextCommand( m_textobj, /*cmd, */TQString() ) );
*cursor = *( cmd->execute( cursor ) );
m_textobj->formatMore( 2 );
emit repaintChanged( this );
m_textobj->emitEnsureCursorVisible();
m_textobj->emitUpdateUI( true );
m_textobj->emitShowCursor();
m_textobj->selectionChangedNotify();
return macroCmd;
}
void KPrTextObject::setShadowParameter(int _distance,ShadowDirection _direction,const TQColor &_color)
{
int sx = 0;
int sy = 0;
switch ( _direction )
{
case SD_LEFT_BOTTOM:
case SD_LEFT:
case SD_LEFT_UP:
sx = - _distance;
case SD_RIGHT_UP:
case SD_RIGHT:
case SD_RIGHT_BOTTOM:
sx = _distance;
default:
break;
}
switch ( _direction )
{
case SD_LEFT_UP:
case SD_UP:
case SD_RIGHT_UP:
sy = - _distance;
case SD_LEFT_BOTTOM:
case SD_BOTTOM:
case SD_RIGHT_BOTTOM:
sy = _distance;
default:
break;
}
KoTextFormat tmpFormat;
tmpFormat.setShadow( sx, sy, _color );
KCommand* cmd = m_textobj->setFormatCommand( &tmpFormat, KoTextFormat::ShadowText );
if ( cmd )
m_doc->addCommand(cmd);
}
void KPrTextObject::slotFormatChanged(const KoTextFormat &_format)
{
if(m_doc && m_doc->firstView())
m_doc->firstView()->showFormat( _format );
}
void KPrTextObject::applyStyleChange( KoStyleChangeDefMap changed )
{
m_textobj->applyStyleChange( changed );
}
void KPrTextObject::slotAfterFormatting( int bottom, KoTextParag* lastFormatted, bool* abort)
{
recalcVerticalAlignment();
int availHeight = availableHeight() - m_doc->zoomHandler()->ptToLayoutUnitPixY(alignmentValue());
if ( ( bottom > availHeight ) || // this parag is already below the avail height
( lastFormatted && (bottom + lastFormatted->rect().height() > availHeight) ) ) // or next parag will be below it
{
int difference = ( bottom + 2 ) - availHeight; // in layout unit pixels
if( lastFormatted && bottom + lastFormatted->rect().height() > availHeight )
{
difference += lastFormatted->rect().height();
}
#if 0
if(lastFormatted)
kdDebug(33001) << "slotAfterFormatting We need more space in " << this
<< " bottom=" << bottom + lastFormatted->rect().height()
<< " availHeight=" << availHeight
<< " ->difference=" << difference << endl;
else
kdDebug(33001) << "slotAfterFormatting We need more space in " << this
<< " bottom2=" << bottom << " availHeight=" << availHeight
<< " ->difference=" << difference << endl;
#endif
// We only auto-grow. We don't auto-shrink.
if(difference > 0 && !isProtect())
{
double wantedPosition = m_doc->zoomHandler()->layoutUnitPtToPt( m_doc->zoomHandler()->pixelYToPt( difference ) )
+ getRect().bottom();
const KoPageLayout& p = m_doc->pageLayout();
double pageBottom = p.ptHeight - p.ptBottom;
double newBottom = TQMIN( wantedPosition, pageBottom ); // don't grow bigger than the page
newBottom = TQMAX( newBottom, getOrig().y() ); // avoid negative heights
//kdDebug(33001) << k_funcinfo << " current bottom=" << getRect().bottom() << " newBottom=" << newBottom << endl;
if ( getRect().bottom() != newBottom )
{
// We resize the text object, but skipping the KPrTextObject::setSize code
// (which invalidates everything etc.)
KPrObject::setSize( getSize().width(), newBottom - getOrig().y() );
// Do recalculate the new available height though
slotAvailableHeightNeeded();
m_doc->updateRuler();
m_doc->repaint( true );
*abort = false;
}
}
else if ( isProtect() )
m_textobj->setLastFormattedParag( 0 );
}
}
// "Extend Contents to Object Height"
KCommand * KPrTextObject::textContentsToHeight()
{
if (isProtect() )
return 0L;
// Count total number of lines and sum up their height (linespacing excluded)
KoTextParag * parag = textDocument()->firstParag();
int numLines = 0;
int textHeightLU = 0;
bool lineSpacingEqual = false;
int oldLineSpacing = 0;
for ( ; parag ; parag = parag->next() )
{
int lines = parag->lines();
numLines += lines;
for ( int line = 0 ; line < lines ; ++line )
{
int y, h, baseLine;
parag->lineInfo( line, y, h, baseLine );
int ls = parag->lineSpacing( line );
lineSpacingEqual = (oldLineSpacing == ls);
oldLineSpacing = ls;
textHeightLU += h - ls;
}
}
double textHeight = m_doc->zoomHandler()->layoutUnitPtToPt( textHeightLU );
double lineSpacing = ( innerHeight() - textHeight ) / numLines; // this gives the linespacing diff to apply, in pt
//kdDebug(33001) << k_funcinfo << "lineSpacing=" << lineSpacing << endl;
if ( KABS( innerHeight() - textHeight ) < DBL_EPSILON ) // floating-point equality test
return 0L; // nothing to do
bool oneLine =(textDocument()->firstParag() == textDocument()->lastParag() && numLines == 1);
if ( lineSpacing < 0 || oneLine) // text object is too small
lineSpacing = 0; // we can't do smaller linespacing than that, but we do need to apply it
// (in case there's some bigger linespacing in use)
if ( (oneLine || lineSpacingEqual) && (textDocument()->firstParag()->kwLineSpacing() == lineSpacing))
return 0L;
// Apply the new linespacing to the whole object
textDocument()->selectAll( KoTextDocument::Temp );
KCommand* cmd = m_textobj->setLineSpacingCommand( 0L, lineSpacing, KoParagLayout::LS_CUSTOM, KoTextDocument::Temp );
textDocument()->removeSelection( KoTextDocument::Temp );
return cmd;
}
// "Resize Object to fit Contents"
KCommand * KPrTextObject::textObjectToContents()
{
if ( isProtect() )
return 0L;
// Calculate max parag width (in case all parags are short, otherwise - with wrapping -
// the width is more or less the current object's width anyway).
KoTextParag * parag = textDocument()->firstParag();
double txtWidth = 10;
for ( ; parag ; parag = parag->next() )
txtWidth = TQMAX( txtWidth, m_doc->zoomHandler()->layoutUnitPtToPt( parag->widthUsed() ));
// Calculate text height
int heightLU = textDocument()->height();
double txtHeight = m_doc->zoomHandler()->layoutUnitPtToPt( heightLU );
// Compare with current object's size
KoSize sizeDiff = KoSize( txtWidth, txtHeight ) - innerRect().size();
if( !sizeDiff.isNull() )
{
// The command isn't named since it's always put into a macro command.
return new KPrResizeCmd( TQString(), KoPoint( 0, 0 ), sizeDiff, this, m_doc);
}
return 0L;
}
void KPrTextObject::setTextMargins( double _left, double _top, double _right, double _bottom)
{
bleft = _left;
btop = _top;
bright = _right;
bbottom = _bottom;
}
KoRect KPrTextObject::innerRect() const
{
KoRect inner( getRect());
inner.moveBy( bLeft(), bTop());
inner.setWidth( inner.width() - bLeft() - bRight() );
inner.setHeight( inner.height() - bTop() - bBottom() );
return inner;
}
double KPrTextObject::innerWidth() const
{
return getSize().width() - bLeft() - bRight();
}
double KPrTextObject::innerHeight() const
{
return getSize().height() - bTop() - bBottom();
}
void KPrTextObject::setVerticalAligment( VerticalAlignmentType _type)
{
m_textVertAlign = _type;
recalcVerticalAlignment();
}
void KPrTextObject::recalcVerticalAlignment()
{
double txtHeight = m_doc->zoomHandler()->layoutUnitPtToPt( m_doc->zoomHandler()->pixelYToPt( textDocument()->height() ) ) + btop + bbottom;
double diffy = getSize().height() - txtHeight;
//kdDebug(33001) << k_funcinfo << "txtHeight: " << txtHeight << " rectHeight:" << getSize().height() << " -> diffy=" << diffy << endl;
if ( diffy <= 0.0 ) {
alignVertical = 0.0;
return;
}
switch( m_textVertAlign )
{
case KP_CENTER:
alignVertical = diffy/2.0;
break;
case KP_TOP:
alignVertical = 0.0;
break;
case KP_BOTTOM:
alignVertical = diffy;
break;
}
}
TQPoint KPrTextObject::cursorPos(KPrCanvas *canvas, KoTextCursor *cursor) const
{
KoTextZoomHandler *zh = m_doc->zoomHandler();
TQPoint origPix = zh->zoomPoint( orig+KoPoint(bLeft(), bTop()+alignVertical) );
KoTextParag* parag = cursor->parag();
TQPoint topLeft = parag->rect().topLeft(); // in TQRT coords
int lineY = 0;
// Cursor height, in pixels
//int cursorHeight = zh->layoutUnitToPixelY( topLeft.y(), parag->lineHeightOfChar( cursor->index(), 0, &lineY ) );
TQPoint iPoint( topLeft.x() + cursor->x(), topLeft.y() + lineY );
iPoint = zh->layoutUnitToPixel( iPoint );
iPoint.rx() -= canvas->diffx();
iPoint.ry() -= canvas->diffy();
return origPix+iPoint;
}
KPrTextView::KPrTextView( KPrTextObject * txtObj, KPrCanvas *_canvas, bool temp )
: KoTextView( txtObj->textObject() )
{
setBackSpeller( txtObj->kPresenterDocument()->backSpeller() );
m_canvas=_canvas;
m_kptextobj=txtObj;
if (temp)
return;
connect( txtObj->textObject(), TQ_SIGNAL( selectionChanged(bool) ),
m_canvas, TQ_SIGNAL( selectionChanged(bool) ) );
KoTextView::setReadWrite( txtObj->kPresenterDocument()->isReadWrite() );
connect( textView(), TQ_SIGNAL( cut() ), TQ_SLOT( cut() ) );
connect( textView(), TQ_SIGNAL( copy() ), TQ_SLOT( copy() ) );
connect( textView(), TQ_SIGNAL( paste() ), TQ_SLOT( paste() ) );
updateUI( true, true );
txtObj->setEditingTextObj( true );
}
KPrTextView::~KPrTextView()
{
}
KoTextViewIface* KPrTextView::dcopObject()
{
if ( !dcop )
dcop = new KPrTextViewIface( this );
return dcop;
}
void KPrTextView::terminate(bool removeSelection)
{
disconnect( textView()->textObject(), TQ_SIGNAL( selectionChanged(bool) ),
m_canvas, TQ_SIGNAL( selectionChanged(bool) ) );
textView()->terminate(removeSelection);
}
void KPrTextView::cut()
{
if ( textDocument()->hasSelection( KoTextDocument::Standard ) ) {
copy();
textObject()->removeSelectedText( cursor() );
}
}
void KPrTextView::copy()
{
//kdDebug(33001)<<"void KPrTextView::copy() "<<endl;
if ( textDocument()->hasSelection( KoTextDocument::Standard ) ) {
TQDragObject *drag = newDrag( 0 );
TQApplication::clipboard()->setData( drag );
}
}
void KPrTextView::paste()
{
//kdDebug(33001) << "KPrTextView::paste()" << endl;
TQMimeSource *data = TQApplication::clipboard()->data();
TQCString returnedMimeType = KoTextObject::providesOasis( data );
if ( !returnedMimeType.isEmpty() )
{
TQByteArray arr = data->encodedData( returnedMimeType );
if ( arr.size() )
{
#if 0
TQFile paste( "/tmp/oasis.tmp" );
paste.open( IO_WriteOnly );
paste.writeBlock( arr );
paste.close();
#endif
KCommand *cmd = kpTextObject()->pasteOasis( cursor(), arr, true );
if ( cmd )
kpTextObject()->kPresenterDocument()->addCommand(cmd);
}
}
else
{
// Note: TQClipboard::text() seems to do a better job than encodedData( "text/plain" )
// In particular it handles charsets (in the mimetype).
TQString text = TQApplication::clipboard()->text();
if ( !text.isEmpty() )
textObject()->pasteText( cursor(), text, currentFormat(), true /*removeSelected*/ );
}
kpTextObject()->layout();
}
void KPrTextView::updateUI( bool updateFormat, bool force )
{
KoTextView::updateUI( updateFormat, force );
// Paragraph settings
KoTextParag * parag = static_cast<KoTextParag*>( cursor()->parag());
if ( m_paragLayout.alignment != parag->resolveAlignment() || force ) {
m_paragLayout.alignment = parag->resolveAlignment();
m_canvas->getView()->alignChanged( m_paragLayout.alignment );
}
// Counter
if ( !m_paragLayout.counter )
m_paragLayout.counter = new KoParagCounter; // we can afford to always have one here
KoParagCounter::Style cstyle = m_paragLayout.counter->style();
if ( parag->counter() )
*m_paragLayout.counter = *parag->counter();
else
{
m_paragLayout.counter->setNumbering( KoParagCounter::NUM_NONE );
m_paragLayout.counter->setStyle( KoParagCounter::STYLE_NONE );
}
if ( m_paragLayout.counter->style() != cstyle || force )
m_canvas->getView()->showCounter( * m_paragLayout.counter );
if(m_paragLayout.leftBorder!=parag->leftBorder() ||
m_paragLayout.rightBorder!=parag->rightBorder() ||
m_paragLayout.topBorder!=parag->topBorder() ||
m_paragLayout.bottomBorder!=parag->bottomBorder() || force )
{
m_paragLayout.leftBorder = parag->leftBorder();
m_paragLayout.rightBorder = parag->rightBorder();
m_paragLayout.topBorder = parag->topBorder();
m_paragLayout.bottomBorder = parag->bottomBorder();
//todo
//m_canvas->gui()->getView()->showParagBorders( m_paragLayout.leftBorder, m_paragLayout.rightBorder, m_paragLayout.topBorder, m_paragLayout.bottomBorder );
}
if ( !parag->style() )
kdWarning(33001) << "Paragraph " << parag->paragId() << " has no style" << endl;
else if ( m_paragLayout.style != parag->style() || force )
{
m_paragLayout.style = parag->style();
m_canvas->getView()->showStyle( m_paragLayout.style->name() );
}
if( m_paragLayout.margins[TQStyleSheetItem::MarginLeft] != parag->margin(TQStyleSheetItem::MarginLeft)
|| m_paragLayout.margins[TQStyleSheetItem::MarginFirstLine] != parag->margin(TQStyleSheetItem::MarginFirstLine)
|| m_paragLayout.margins[TQStyleSheetItem::MarginRight] != parag->margin(TQStyleSheetItem::MarginRight)
|| force )
{
m_paragLayout.margins[TQStyleSheetItem::MarginFirstLine] = parag->margin(TQStyleSheetItem::MarginFirstLine);
m_paragLayout.margins[TQStyleSheetItem::MarginLeft] = parag->margin(TQStyleSheetItem::MarginLeft);
m_paragLayout.margins[TQStyleSheetItem::MarginRight] = parag->margin(TQStyleSheetItem::MarginRight);
m_canvas->getView()->showRulerIndent( m_paragLayout.margins[TQStyleSheetItem::MarginLeft],
m_paragLayout.margins[TQStyleSheetItem::MarginFirstLine],
m_paragLayout.margins[TQStyleSheetItem::MarginRight],
parag->string()->isRightToLeft() );
}
if( m_paragLayout.tabList() != parag->tabList() || force )
{
m_paragLayout.setTabList( parag->tabList() );
KoRuler * hr = m_canvas->getView()->getHRuler();
if ( hr )
hr->setTabList( parag->tabList() );
}
}
void KPrTextView::ensureCursorVisible()
{
//kdDebug(33001) << "KWTextFrameSetEdit::ensureCursorVisible paragId=" << cursor()->parag()->paragId() << endl;
KoTextParag * parag = cursor()->parag();
kpTextObject()->textObject()->ensureFormatted( parag );
KoTextStringChar *chr = parag->at( cursor()->index() );
int h = parag->lineHeightOfChar( cursor()->index() );
int x = parag->rect().x() + chr->x;
int y = 0; int dummy;
parag->lineHeightOfChar( cursor()->index(), &dummy, &y );
y += parag->rect().y();
int w = 1;
KPrDocument *doc= m_kptextobj->kPresenterDocument();
KoPoint pt= kpTextObject()->getOrig();
pt.setX( doc->zoomHandler()->layoutUnitPtToPt( doc->zoomHandler()->pixelXToPt( x) ) +pt.x());
pt.setY( doc->zoomHandler()->layoutUnitPtToPt( doc->zoomHandler()->pixelYToPt( y ))+pt.y() );
TQPoint p = m_kptextobj->kPresenterDocument()->zoomHandler()->zoomPoint( pt );
w = m_kptextobj->kPresenterDocument()->zoomHandler()->layoutUnitToPixelX( w );
h = m_kptextobj->kPresenterDocument()->zoomHandler()->layoutUnitToPixelY( h );
m_canvas->ensureVisible( p.x(), p.y() + h / 2, w, h / 2 + 2 );
}
bool KPrTextView::doCompletion( KoTextCursor* cursor, KoTextParag *parag, int index )
{
if( m_kptextobj->kPresenterDocument()->allowAutoFormat() )
{
KoAutoFormat * autoFormat = m_kptextobj->kPresenterDocument()->getAutoFormat();
if( autoFormat )
return autoFormat->doCompletion( cursor, parag, index, textObject());
}
return false;
}
bool KPrTextView::doToolTipCompletion( KoTextCursor* cursor, KoTextParag *parag, int index,int keyPress )
{
if( m_kptextobj->kPresenterDocument()->allowAutoFormat() )
{
KoAutoFormat * autoFormat = m_kptextobj->kPresenterDocument()->getAutoFormat();
if( autoFormat )
return autoFormat->doToolTipCompletion( cursor, parag, index, textObject(), keyPress);
}
return false;
}
void KPrTextView::showToolTipBox(KoTextParag *parag, int index, TQWidget *widget, const TQPoint &pos)
{
if( m_kptextobj->kPresenterDocument()->allowAutoFormat() )
{
KoAutoFormat * autoFormat = m_kptextobj->kPresenterDocument()->getAutoFormat();
if( autoFormat )
autoFormat->showToolTipBox(parag, index, widget, pos);
}
}
void KPrTextView::removeToolTipCompletion()
{
if( m_kptextobj->kPresenterDocument()->allowAutoFormat() )
{
KoAutoFormat * autoFormat = m_kptextobj->kPresenterDocument()->getAutoFormat();
if( autoFormat )
autoFormat->removeToolTipCompletion();
}
}
void KPrTextView::textIncreaseIndent()
{
m_canvas->setTextDepthPlus();
}
bool KPrTextView::textDecreaseIndent()
{
if (m_paragLayout.margins[TQStyleSheetItem::MarginLeft]>0)
{
m_canvas->setTextDepthMinus();
return true;
}
else
return false;
}
void KPrTextView::doAutoFormat( KoTextCursor* cursor, KoTextParag *parag, int index, TQChar ch )
{
if( m_kptextobj->kPresenterDocument()->allowAutoFormat())
{
KoAutoFormat * autoFormat = m_kptextobj->kPresenterDocument()->getAutoFormat();
if ( autoFormat )
autoFormat->doAutoFormat( cursor, parag, index, ch, textObject());
}
}
bool KPrTextView::doIgnoreDoubleSpace(KoTextParag * parag, int index,TQChar ch )
{
if( m_kptextobj->kPresenterDocument()->allowAutoFormat())
{
KoAutoFormat * autoFormat = m_kptextobj->kPresenterDocument()->getAutoFormat();
if( autoFormat )
return autoFormat->doIgnoreDoubleSpace( parag, index,ch );
}
return false;
}
void KPrTextView::startDrag()
{
textView()->dragStarted();
m_canvas->dragStarted();
TQDragObject *drag = newDrag( m_canvas );
if ( !kpTextObject()->kPresenterDocument()->isReadWrite() )
drag->dragCopy();
else
{
if ( drag->drag() && TQDragObject::target() != m_canvas )
textObject()->removeSelectedText( cursor() );
}
}
void KPrTextView::showFormat( KoTextFormat *format )
{
m_canvas->getView()->showFormat( *format );
}
bool KPrTextView::pgUpKeyPressed()
{
KoTextCursor *cursor = textView()->cursor();
KoTextParag *s = cursor->parag();
s = textDocument()->firstParag();
textView()->cursor()->setParag( s );
textView()->cursor()->setIndex( 0 );
return true;
}
bool KPrTextView::pgDownKeyPressed()
{
KoTextCursor *cursor = textView()->cursor();
KoTextParag *s = cursor->parag();
s = textDocument()->lastParag();
cursor->setParag( s );
cursor->setIndex( s->length() - 1 );
return true;
}
void KPrTextView::keyPressEvent( TQKeyEvent *e )
{
//Calculate position of tooltip for autocompletion
const TQPoint pos = kpTextObject()->cursorPos(m_canvas, cursor());
textView()->handleKeyPressEvent( e, m_canvas, pos );
}
void KPrTextView::keyReleaseEvent( TQKeyEvent *e )
{
handleKeyReleaseEvent(e);
}
void KPrTextView::imStartEvent( TQIMEvent *e )
{
handleImStartEvent(e);
}
void KPrTextView::imComposeEvent( TQIMEvent *e )
{
handleImComposeEvent(e);
}
void KPrTextView::imEndEvent( TQIMEvent *e )
{
handleImEndEvent(e);
}
void KPrTextView::clearSelection()
{
if ( textDocument()->hasSelection( KoTextDocument::Standard ) )
textDocument()->removeSelection(KoTextDocument::Standard );
}
void KPrTextView::selectAll(bool select)
{
textObject()->selectAll( select );
}
void KPrTextView::drawCursor( bool b )
{
KoTextView::drawCursor( b );
if ( !cursor()->parag() )
return;
if ( !kpTextObject()->kPresenterDocument()->isReadWrite() )
return;
TQPainter painter( m_canvas );
painter.translate( -m_canvas->diffx(), -m_canvas->diffy() );
painter.setBrushOrigin( -m_canvas->diffx(), -m_canvas->diffy() );
kpTextObject()->drawCursor( &painter, cursor(), b, m_canvas );
}
// Convert a mouse position into a TQRT document position
TQPoint KPrTextView::viewToInternal( const TQPoint & pos ) const
{
#if 0
KoTextZoomHandler* zh = kpTextObject()->kPresenterDocument()->zoomHandler();
TQPoint tmp(pos);
TQWMatrix m;
m.translate( zh->zoomItX(kpTextObject()->getSize().width() / 2.0),
zh->zoomItY(kpTextObject()->getSize().height() / 2.0) );
m.rotate( kpTextObject()->getAngle() );
m.translate( zh->zoomItX(kpTextObject()->getOrig().x()),
zh->zoomItY(kpTextObject()->getOrig().y()) );
//m = m.invert();
tmp = m * pos;
kdDebug(33001)<<" tmp.x() :"<<tmp.x()<<" tmp.y() "<<tmp.y()<<endl;
KoRect br = KoRect( 0, 0, kpTextObject()->getSize().width(), kpTextObject()->getSize().height() );
double pw = br.width();
double ph = br.height();
KoRect rr = br;
double yPos = -rr.y();
double xPos = -rr.x();
rr.moveTopLeft( KoPoint( -rr.width() / 2.0, -rr.height() / 2.0 ) );
m.translate( zh->zoomItX(pw / 2.0),
zh->zoomItY(ph / 2.0 ));
m.rotate( kpTextObject()->getAngle() );
m.translate( zh->zoomItX(rr.left() + xPos),
zh->zoomItY(rr.top() + yPos) );
m = m.invert();
tmp = m * pos;
kdDebug(33001)<<" tmp.x() :"<<tmp.x()<<" tmp.y() "<<tmp.y()<<endl;
#endif
return kpTextObject()->viewToInternal( pos, m_canvas );
}
void KPrTextView::mousePressEvent( TQMouseEvent *e, const TQPoint &/*_pos*/)
{
bool addParag = handleMousePressEvent( e, viewToInternal( e->pos() ),true /*bool canStartDrag*/,
kpTextObject()->kPresenterDocument()->insertDirectCursor() );
if ( addParag )
kpTextObject()->kPresenterDocument()->setModified( true );
}
void KPrTextView::mouseDoubleClickEvent( TQMouseEvent *e, const TQPoint &pos)
{
handleMouseDoubleClickEvent( e, pos );
}
void KPrTextView::mouseMoveEvent( TQMouseEvent *e, const TQPoint &_pos )
{
if ( textView()->maybeStartDrag( e ) )
return;
if ( _pos.y() > 0 )
textView()->handleMouseMoveEvent( e,viewToInternal( e->pos() ) );
}
bool KPrTextView::isLinkVariable( const TQPoint & pos )
{
const TQPoint iPoint = viewToInternal( pos );
KoLinkVariable* linkVariable = dynamic_cast<KoLinkVariable *>( textObject()->variableAtPoint( iPoint ) );
return linkVariable != 0;
}
void KPrTextView::openLink()
{
KPrDocument * doc = kpTextObject()->kPresenterDocument();
if ( doc->getVariableCollection()->variableSetting()->displayLink() ) {
KoLinkVariable* v = linkVariable();
if ( v )
KoTextView::openLink( v );
}
}
void KPrTextView::mouseReleaseEvent( TQMouseEvent *, const TQPoint & )
{
handleMouseReleaseEvent();
}
void KPrTextView::showPopup( KPrView *view, const TQPoint &point, TQPtrList<TDEAction>& actionList )
{
TQString word = wordUnderCursor( *cursor() );
view->unplugActionList( "datatools" );
view->unplugActionList( "datatools_link" );
view->unplugActionList( "spell_result_action" );
view->unplugActionList( "variable_action" );
TQPtrList<TDEAction> &variableList = view->variableActionList();
variableList.clear();
actionList.clear();
view->kPresenterDoc()->getVariableCollection()->setVariableSelected(variable());
KoVariable* var = variable();
if ( var )
{
variableList = view->kPresenterDoc()->getVariableCollection()->popupActionList();
}
if( variableList.count()>0)
{
view->plugActionList( "variable_action", variableList );
TQPopupMenu * popup = view->popupMenu("variable_popup");
Q_ASSERT(popup);
if (popup)
popup->popup( point ); // using exec() here breaks the spellcheck tool (event loop pb)
}
else
{
bool singleWord= false;
actionList = dataToolActionList(view->kPresenterDoc()->instance(), word, singleWord);
//kdDebug(33001) << "KWView::openPopupMenuInsideFrame plugging actionlist with " << actionList.count() << " actions" << endl;
KoLinkVariable* linkVar = dynamic_cast<KoLinkVariable *>( var );
TQPopupMenu * popup;
if ( !linkVar )
{
view->plugActionList( "datatools", actionList );
KoNoteVariable * noteVar = dynamic_cast<KoNoteVariable *>( var );
KoCustomVariable * customVar = dynamic_cast<KoCustomVariable *>( var );
if( noteVar )
popup = view->popupMenu("note_popup");
else if( customVar )
popup = view->popupMenu("custom_var_popup");
else
{
if ( singleWord )
{
TQPtrList<TDEAction> actionCheckSpellList =view->listOfResultOfCheckWord( word );
if ( actionCheckSpellList.count()>0)
{
view->plugActionList( "spell_result_action", actionCheckSpellList );
popup = view->popupMenu("text_popup_spell_with_result");
}
else
popup = view->popupMenu("text_popup_spell");
}
else
popup = view->popupMenu("text_popup");
}
}
else
{
view->plugActionList( "datatools_link", actionList );
popup = view->popupMenu("text_popup_link");
}
Q_ASSERT(popup);
if (popup)
popup->popup( point ); // using exec() here breaks the spellcheck tool (event loop pb)
}
}
void KPrTextView::insertCustomVariable( const TQString &name)
{
KPrDocument * doc = kpTextObject()->kPresenterDocument();
KoVariable * var = new KoCustomVariable( textDocument(), name, doc->variableFormatCollection()->format( "STRING" ),
doc->getVariableCollection());
insertVariable( var );
}
void KPrTextView::insertLink(const TQString &_linkName, const TQString & hrefName)
{
KPrDocument * doc = kpTextObject()->kPresenterDocument();
KoVariable * var = new KoLinkVariable( textDocument(), _linkName, hrefName,
doc->variableFormatCollection()->format( "STRING" ),
doc->getVariableCollection());
insertVariable( var );
}
void KPrTextView::insertComment(const TQString &_comment)
{
KPrDocument * doc = kpTextObject()->kPresenterDocument();
KoVariable * var = new KoNoteVariable( textDocument(), _comment,
doc->variableFormatCollection()->format( "STRING" ),
doc->getVariableCollection());
insertVariable( var );
}
void KPrTextView::insertVariable( int type, int subtype )
{
KPrDocument * doc = kpTextObject()->kPresenterDocument();
bool refreshCustomMenu = false;
KoVariable * var = 0L;
if ( type == VT_CUSTOM )
{
KoCustomVarDialog dia( m_canvas );
if ( dia.exec() == TQDialog::Accepted )
{
KoCustomVariable *v = new KoCustomVariable( textDocument(), dia.name(),
doc->variableFormatCollection()->format( "STRING" ),
doc->getVariableCollection() );
v->setValue( dia.value() );
var = v;
refreshCustomMenu = true;
}
}
else
var = doc->getVariableCollection()->createVariable( type, subtype, doc->variableFormatCollection(), 0L, textDocument(),doc, 0);
if ( var )
{
insertVariable( var, 0, refreshCustomMenu);
doc->recalcPageNum();
}
}
void KPrTextView::insertVariable( KoVariable *var, KoTextFormat *format, bool refreshCustomMenu )
{
if ( var )
{
CustomItemsMap customItemsMap;
customItemsMap.insert( 0, var );
if (!format)
format = currentFormat();
//kdDebug(33001) << "KPrTextView::insertVariable inserting into paragraph" << endl;
#ifdef DEBUG_FORMATS
kdDebug(33001) << "KPrTextView::insertVariable currentFormat=" << currentFormat() << endl;
#endif
textObject()->insert( cursor(), format, KoTextObject::customItemChar(),
i18n("Insert Variable"),
KoTextDocument::Standard,
KoTextObject::DoNotRemoveSelected,
customItemsMap );
if ( refreshCustomMenu && var->type() == VT_CUSTOM )
kpTextObject()->kPresenterDocument()->refreshMenuCustomVariable();
kpTextObject()->kPresenterDocument()->repaint( kpTextObject() );
}
}
bool KPrTextView::canDecode( TQMimeSource *e )
{
return kpTextObject()->kPresenterDocument()->isReadWrite() && ( !KoTextObject::providesOasis( e ).isNull() || TQTextDrag::canDecode( e ) );
}
TQDragObject * KPrTextView::newDrag( TQWidget * parent )
{
TQBuffer buffer;
const TQCString mimeType = "application/vnd.oasis.opendocument.text";
KoStore * store = KoStore::createStore( &buffer, KoStore::Write, mimeType );
Q_ASSERT( store );
Q_ASSERT( !store->bad() );
KoOasisStore oasisStore( store );
//KoXmlWriter* manifestWriter = oasisStore.manifestWriter( mimeType );
KPrDocument * doc = kpTextObject()->kPresenterDocument();
doc->getVariableCollection()->variableSetting()->setModificationDate( TQDateTime::currentDateTime() );
doc->recalcVariables( VT_DATE );
doc->recalcVariables( VT_TIME );
doc->recalcVariables( VT_STATISTIC );
KoGenStyles mainStyles;
KoSavingContext savingContext( mainStyles, 0, false, KoSavingContext::Store );
doc->styleCollection()->saveOasis( mainStyles, KoGenStyle::STYLE_USER, savingContext );
KoXmlWriter* bodyWriter = oasisStore.bodyWriter();
bodyWriter->startElement( "office:body" );
bodyWriter->startElement( "office:text" );
const TQString plainText = textDocument()->copySelection( *bodyWriter, savingContext, KoTextDocument::Standard );
bodyWriter->endElement(); // office:text
bodyWriter->endElement(); // office:body
KoXmlWriter* contentWriter = oasisStore.contentWriter();
Q_ASSERT( contentWriter );
//KPrDocument * doc = kpTextObject()->kPresenterDocument();
doc->writeAutomaticStyles( *contentWriter, mainStyles, savingContext, false );
oasisStore.closeContentWriter();
if ( !store->open( "styles.xml" ) )
return 0;
//manifestWriter->addManifestEntry( "styles.xml", "text/xml" );
doc->saveOasisDocumentStyles( store, mainStyles, 0, savingContext, KPrDocument::SaveSelected /* simply means not SaveAll */ );
if ( !store->close() ) // done with styles.xml
return 0;
delete store;
KMultipleDrag* multiDrag = new KMultipleDrag( parent );
if ( !plainText.isEmpty() )
multiDrag->addDragObject( new TQTextDrag( plainText, 0 ) );
KoStoreDrag* storeDrag = new KoStoreDrag( mimeType, 0 );
kdDebug() << k_funcinfo << "setting zip data: " << buffer.buffer().size() << " bytes." << endl;
storeDrag->setEncodedData( buffer.buffer() );
multiDrag->addDragObject( storeDrag );
return multiDrag;
}
void KPrTextView::dragEnterEvent( TQDragEnterEvent *e )
{
if ( !canDecode( e ) )
{
e->ignore();
return;
}
e->acceptAction();
}
void KPrTextView::dragMoveEvent( TQDragMoveEvent *e, const TQPoint & )
{
if ( !canDecode( e ) )
{
e->ignore();
return;
}
TQPoint iPoint = viewToInternal( e->pos() );
textObject()->emitHideCursor();
placeCursor( iPoint );
textObject()->emitShowCursor();
e->acceptAction(); // here or out of the if ?
}
void KPrTextView::dropEvent( TQDropEvent * e )
{
if ( canDecode( e ) )
{
KPrDocument *doc = kpTextObject()->kPresenterDocument();
e->acceptAction();
KoTextCursor dropCursor( textDocument() );
TQPoint dropPoint = viewToInternal( e->pos() );
KMacroCommand *macroCmd=new KMacroCommand(i18n("Paste Text"));
bool addMacroCmd = false;
dropCursor.place( dropPoint, textDocument()->firstParag() );
kdDebug(33001) << "KPrTextView::dropEvent dropCursor at parag=" << dropCursor.parag()->paragId() << " index=" << dropCursor.index() << endl;
if ( ( e->source() == m_canvas ) &&
e->action() == TQDropEvent::Move &&
// this is the indicator that the source and dest text objects are the same
textDocument()->hasSelection( KoTextDocument::Standard )
) {
//kdDebug(33001)<<"decodeFrameSetNumber( TQMimeSource *e ) :"<<numberFrameSet<<endl;
KCommand *cmd = textView()->prepareDropMove( dropCursor );
if(cmd)
{
kpTextObject()->layout();
macroCmd->addCommand(cmd);
addMacroCmd = true;
}
else
{
delete macroCmd;
return;
}
}
else
{ // drop coming from outside -> forget about current selection
textDocument()->removeSelection( KoTextDocument::Standard );
textObject()->selectionChangedNotify();
}
TQCString returnedTypeMime = KoTextObject::providesOasis( e );
if ( !returnedTypeMime.isEmpty() )
{
TQByteArray arr = e->encodedData( returnedTypeMime );
if ( arr.size() )
{
KCommand *cmd = kpTextObject()->pasteOasis( cursor(), arr, false );
if ( cmd )
{
macroCmd->addCommand(cmd);
addMacroCmd = true;
}
}
}
else
{
TQString text;
if ( TQTextDrag::decode( e, text ) )
textObject()->pasteText( cursor(), text, currentFormat(),
false /*do not remove selected text*/ );
}
if ( addMacroCmd )
doc->addCommand(macroCmd);
else
delete macroCmd;
}
}
void KPrTextObject::saveParagraph( TQDomDocument& doc,KoTextParag * parag,TQDomElement &parentElem,
int from /* default 0 */,
int to /* default length()-2 */ )
{
if(!parag)
return;
TQDomElement paragraph=doc.createElement(tagP);
int tmpAlign=0;
switch(parag->resolveAlignment())
{
case TQt::AlignLeft:
tmpAlign=1;
break;
case TQt::AlignRight:
tmpAlign=2;
break;
case TQt::AlignHCenter:
tmpAlign=4;
break;
case TQt::AlignJustify:
tmpAlign=8;
}
if(tmpAlign!=1)
paragraph.setAttribute(attrAlign, tmpAlign);
saveParagLayout( parag->paragLayout(), paragraph );
KoTextFormat *lastFormat = 0;
TQString tmpText;
for ( int i = from; i <= to; ++i ) {
KoTextStringChar &c = parag->string()->at(i);
if ( c.isCustom() )
{
TQDomElement variable = doc.createElement("CUSTOM");
variable.setAttribute("pos", (i-from));
saveFormat( variable, c.format() );
paragraph.appendChild( variable );
static_cast<KoTextCustomItem *>( c.customItem() )->save(variable );
}
if ( !lastFormat || c.format()->key() != lastFormat->key() ) {
if ( lastFormat )
paragraph.appendChild(saveHelper(tmpText, lastFormat, doc));
lastFormat = static_cast<KoTextFormat*> (c.format());
tmpText=TQString();
}
tmpText+=TQString(c.c);
}
if ( lastFormat )
paragraph.appendChild(saveHelper(tmpText, lastFormat, doc));
else
paragraph.appendChild(saveHelper(tmpText, parag->string()->at(0).format(), doc));
parentElem.appendChild(paragraph);
}
KoPen KPrTextObject::defaultPen() const
{
return KoPen( TQt::black, 1.0, TQt::NoPen );
}
TQPoint KPrTextObject::viewToInternal( const TQPoint & pos, KPrCanvas* canvas ) const
{
KoTextZoomHandler* zh = kPresenterDocument()->zoomHandler();
TQPoint iPoint = pos - zh->zoomPoint(
getOrig() + KoPoint( bLeft(),
bTop() + alignmentValue()) );
iPoint = zh->pixelToLayoutUnit(
TQPoint( iPoint.x() + canvas->diffx(), iPoint.y() + canvas->diffy() ) );
return iPoint;
}