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.
740 lines
26 KiB
740 lines
26 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@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 "KWVariable.h"
|
|
|
|
#include "KWTextFrameSet.h"
|
|
#include "KWTextDocument.h"
|
|
#include "KWMailMergeDataBase.h"
|
|
#include "KWDocument.h"
|
|
#include "KWCommand.h"
|
|
#include "KWViewMode.h"
|
|
#include "KWPageManager.h"
|
|
|
|
#include <KoVariable.h>
|
|
#include <KoXmlWriter.h>
|
|
#include <KoXmlNS.h>
|
|
#include <KoDom.h>
|
|
|
|
#include <tdelocale.h>
|
|
#include <kdebug.h>
|
|
|
|
KWVariableSettings::KWVariableSettings() : KoVariableSettings()
|
|
{
|
|
m_footNoteCounter.setSuffix( TQString() );
|
|
m_endNoteCounter.setSuffix( TQString() );
|
|
// By default endnotes are numbered in lowercase roman numbers, in other WPs.
|
|
m_endNoteCounter.setStyle( KoParagCounter::STYLE_ROM_NUM_L );
|
|
}
|
|
|
|
void KWVariableSettings::changeFootNoteCounter( KoParagCounter _c )
|
|
{
|
|
m_footNoteCounter = _c;
|
|
}
|
|
|
|
void KWVariableSettings::changeEndNoteCounter( KoParagCounter _c )
|
|
{
|
|
m_endNoteCounter = _c;
|
|
}
|
|
|
|
void KWVariableSettings::saveNoteConfiguration( KoXmlWriter& writer ) const
|
|
{
|
|
writer.startElement( "text:notes-configuration" );
|
|
writer.addAttribute( "text:note-class", "footnote" );
|
|
// let the counter save: num-prefix num-suffix num-format start-value
|
|
m_footNoteCounter.saveOasisListLevel( writer, false );
|
|
writer.addAttribute( "text:footnotes-position", "page" ); // tell OO what we do
|
|
writer.addAttribute( "text:start-numbering-at", "document" ); // tell OO what we do
|
|
writer.endElement();
|
|
writer.startElement( "text:notes-configuration" );
|
|
writer.addAttribute( "text:note-class", "endnote" );
|
|
// let the counter save: num-prefix num-suffix num-format start-value
|
|
m_endNoteCounter.saveOasisListLevel( writer, false );
|
|
writer.addAttribute( "text:start-numbering-at", "document" ); // tell OO what we do
|
|
writer.endElement();
|
|
}
|
|
|
|
void KWVariableSettings::loadNoteConfiguration( const TQDomElement& parent )
|
|
{
|
|
TQDomElement e;
|
|
forEachElement( e, parent )
|
|
{
|
|
if ( e.localName() == "notes-configuration" && e.namespaceURI() == KoXmlNS::text )
|
|
{
|
|
const TQString noteClass = e.attributeNS( KoXmlNS::text, "note-class", TQString() );
|
|
if ( noteClass == "footnote" ) {
|
|
m_footNoteCounter.loadOasisListStyle( e, TQDomElement(), TQDomElement(), -1, true, false, 1, false );
|
|
m_footNoteCounter.setNumbering( KoParagCounter::NUM_FOOTNOTE );
|
|
m_footNoteCounter.setRestartCounter( false );
|
|
}
|
|
else if ( noteClass == "endnote" ) {
|
|
m_endNoteCounter.loadOasisListStyle( e, TQDomElement(), TQDomElement(), -1, true, false, 1, false );
|
|
m_endNoteCounter.setNumbering( KoParagCounter::NUM_FOOTNOTE );
|
|
m_endNoteCounter.setRestartCounter( false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void KWVariableSettings::save( TQDomElement &parentElem )
|
|
{
|
|
KoVariableSettings::save( parentElem );
|
|
TQDomDocument doc = parentElem.ownerDocument();
|
|
TQDomElement footNoteSettingElem = doc.createElement( "FOOTNOTESETTING" );
|
|
parentElem.appendChild( footNoteSettingElem );
|
|
m_footNoteCounter.save( footNoteSettingElem );
|
|
TQDomElement endNoteSettingElem = doc.createElement( "ENDNOTESETTING" );
|
|
parentElem.appendChild( endNoteSettingElem );
|
|
m_endNoteCounter.save( endNoteSettingElem );
|
|
}
|
|
|
|
void KWVariableSettings::load( TQDomElement &elem )
|
|
{
|
|
KoVariableSettings::load( elem );
|
|
TQDomElement footNoteSettings = elem.namedItem( "FOOTNOTESETTING" ).toElement();
|
|
if ( !footNoteSettings.isNull() )
|
|
m_footNoteCounter.load( footNoteSettings );
|
|
TQDomElement endNoteSettings = elem.namedItem( "ENDNOTESETTING" ).toElement();
|
|
if ( !endNoteSettings.isNull() )
|
|
m_endNoteCounter.load( endNoteSettings );
|
|
}
|
|
|
|
KWVariableCollection::KWVariableCollection(KWVariableSettings *_setting, KoVariableFormatCollection* coll)
|
|
: KoVariableCollection(_setting, coll)
|
|
{
|
|
}
|
|
|
|
KoVariable* KWVariableCollection::loadOasisField( KoTextDocument* textdoc, const TQDomElement& tag, KoOasisContext& context )
|
|
{
|
|
const TQString localName( tag.localName() );
|
|
const bool isTextNS = tag.namespaceURI() == KoXmlNS::text;
|
|
if ( isTextNS )
|
|
{
|
|
//kdDebug()<<" localName :"<<localName<<endl;
|
|
if ( localName == "note" )
|
|
{
|
|
TQString key = "STRING";
|
|
int type = VT_FOOTNOTE;
|
|
return loadOasisFieldCreateVariable( textdoc, tag, context, key, type );
|
|
}
|
|
else if ( localName == "table-count" ||
|
|
localName == "object-count" ||
|
|
localName == "picture-count" ||
|
|
localName == "paragraph-count" ||
|
|
localName == "word-count" ||
|
|
localName == "character-count" ||
|
|
localName == "sentence-count" ||
|
|
localName == "line-count" ||
|
|
localName == "frame-count" ||
|
|
localName == "non-whitespace-character-count" ||
|
|
localName == "syllable-count")
|
|
{
|
|
TQString key = "NUMBER";
|
|
int type = VT_STATISTIC;
|
|
return loadOasisFieldCreateVariable( textdoc, tag, context, key, type );
|
|
}
|
|
else
|
|
return KoVariableCollection::loadOasisField( textdoc, tag, context );
|
|
}
|
|
else
|
|
return KoVariableCollection::loadOasisField( textdoc, tag, context );
|
|
}
|
|
|
|
KoVariable *KWVariableCollection::createVariable( int type, short int subtype, KoVariableFormatCollection * coll, KoVariableFormat *varFormat,KoTextDocument *textdoc, KoDocument * doc, int _correct,bool _forceDefaultFormat, bool loadFootNote )
|
|
{
|
|
KWDocument *m_doc = static_cast<KWDocument *>(doc);
|
|
KoVariable * var = 0L;
|
|
switch(type) {
|
|
case VT_PGNUM:
|
|
if ( !varFormat )
|
|
varFormat = (subtype == KoPageVariable::VST_CURRENT_SECTION) ? coll->format("STRING") : coll->format("NUMBER");
|
|
var = new KWPgNumVariable( textdoc, subtype, varFormat, this, m_doc );
|
|
break;
|
|
case VT_MAILMERGE:
|
|
var = new KWMailMergeVariable( textdoc, TQString(), coll->format("STRING"), this, m_doc );
|
|
break;
|
|
case VT_FOOTNOTE:
|
|
if ( !loadFootNote )
|
|
return 0L;
|
|
if ( !varFormat )
|
|
varFormat = coll->format("STRING");
|
|
var = new KWFootNoteVariable( textdoc, varFormat, this, m_doc );
|
|
break;
|
|
case VT_STATISTIC:
|
|
if ( !varFormat )
|
|
varFormat = coll->format("NUMBER");
|
|
var = new KWStatisticVariable( textdoc, subtype, varFormat, this, m_doc );
|
|
break;
|
|
default:
|
|
return KoVariableCollection::createVariable( type, subtype, coll, varFormat, textdoc, doc, _correct, _forceDefaultFormat );
|
|
}
|
|
return var;
|
|
}
|
|
|
|
/******************************************************************/
|
|
/* Class: KWPgNumVariable */
|
|
/******************************************************************/
|
|
KWPgNumVariable::KWPgNumVariable( KoTextDocument *textdoc, int subtype, KoVariableFormat *varFormat ,KoVariableCollection *_varColl, KWDocument *doc )
|
|
: KoPageVariable( textdoc, subtype, varFormat ,_varColl ), m_doc(doc)
|
|
{
|
|
}
|
|
|
|
void KWPgNumVariable::recalc()
|
|
{
|
|
if ( !m_doc->layoutViewMode()->hasPages() ) // ModeText
|
|
{
|
|
//necessary to resize it in this mode because in this mode
|
|
//we don't call KWTextFrameSet::drawFrame()
|
|
resize();
|
|
return;
|
|
}
|
|
|
|
if ( m_subtype == VST_PGNUM_TOTAL )
|
|
{
|
|
m_varValue = TQVariant(m_doc->pageCount()+m_varColl->variableSetting()->startingPageNumber()-1);
|
|
resize();
|
|
}
|
|
// The other cases are handled by the more dynamic code in KWTextFrameSet::drawFrame()
|
|
// But we don't want to keep a width of -1 ...
|
|
if ( width == -1 )
|
|
width = 0;
|
|
}
|
|
|
|
TQString KWPgNumVariable::text(bool realValue)
|
|
{
|
|
if (m_varColl->variableSetting()->displayFieldCode()&& !realValue)
|
|
return fieldCode();
|
|
// #### ??? What?
|
|
else if ( m_subtype != VST_CURRENT_SECTION && !m_doc->layoutViewMode()->hasPages() && !realValue)
|
|
return fieldCode();
|
|
else
|
|
return m_varFormat->convert( m_varValue );
|
|
}
|
|
|
|
/******************************************************************/
|
|
/* Class: KWMailMergeVariable */
|
|
/******************************************************************/
|
|
KWMailMergeVariable::KWMailMergeVariable( KoTextDocument *textdoc, const TQString &name, KoVariableFormat *varFormat,KoVariableCollection *_varColl, KWDocument *doc )
|
|
: KoMailMergeVariable( textdoc, name, varFormat,_varColl ), m_doc(doc)
|
|
{
|
|
}
|
|
|
|
TQString KWMailMergeVariable::value() const
|
|
{
|
|
return m_doc->mailMergeDataBase()->getValue( m_varValue.toString() );
|
|
}
|
|
|
|
TQString KWMailMergeVariable::text(bool realValue)
|
|
{
|
|
if (m_varColl->variableSetting()->displayFieldCode()&& !realValue)
|
|
return fieldCode();
|
|
// ## should use a format maybe
|
|
TQString v = value();
|
|
if ( m_doc->mailMergeDataBase()->isSampleRecord() )
|
|
return "<" + v + ">";
|
|
return v;
|
|
}
|
|
|
|
void KWMailMergeVariable::recalc()
|
|
{
|
|
resize();
|
|
}
|
|
|
|
/////////////
|
|
|
|
KWFootNoteVariable::KWFootNoteVariable( KoTextDocument *textdoc, KoVariableFormat *varFormat, KoVariableCollection *varColl, KWDocument *doc )
|
|
: KoVariable( textdoc, varFormat, varColl ),
|
|
m_doc(doc),
|
|
m_frameset( 0L ),
|
|
m_numberingType( Auto ),
|
|
m_num( -1 ),
|
|
m_numDisplay( -1 )
|
|
{
|
|
m_varValue = TQVariant( TQString() );
|
|
}
|
|
|
|
void KWFootNoteVariable::setNumberingType( Numbering _type )
|
|
{
|
|
m_numberingType = _type;
|
|
//delete m_varFormat;
|
|
setVariableFormat(m_doc->variableFormatCollection()->format("STRING"));
|
|
}
|
|
|
|
void KWFootNoteVariable::loadOasis( const TQDomElement& footNoteTag, KoOasisContext& context )
|
|
{
|
|
/*<text:note text:id="ftn0" text:note-class="footnote"><text:note-citation>1</text:note-citation><text:note-body>
|
|
<text:p text:style-name="Footnote"></text:p></text:note-body></text:note> */
|
|
const TQString id = footNoteTag.attributeNS( KoXmlNS::text, "id", TQString() );
|
|
|
|
if ( footNoteTag.hasAttributeNS( KoXmlNS::text, "note-class" ) )
|
|
{
|
|
const TQString str = footNoteTag.attributeNS( KoXmlNS::text, "note-class", TQString() );
|
|
if ( str == "footnote" )
|
|
m_noteType = FootNote;
|
|
else if ( str == "endnote" )
|
|
m_noteType = EndNote;
|
|
else {
|
|
kdWarning()<<" Unknown footnote type: '" << str << "'" << endl;
|
|
m_noteType = FootNote;
|
|
}
|
|
}
|
|
|
|
TQDomElement element;
|
|
TQDomElement bodyElement;
|
|
forEachElement( element, footNoteTag )
|
|
{
|
|
if ( element.namespaceURI() != KoXmlNS::text )
|
|
continue;
|
|
|
|
const TQString localName = element.localName();
|
|
if( localName == "note-citation" )
|
|
{
|
|
if ( element.hasAttributeNS( KoXmlNS::text, "label" ) )
|
|
m_numberingType = Manual;
|
|
else
|
|
m_numberingType = Auto;
|
|
if ( m_numberingType == Auto )
|
|
{
|
|
//kdDebug()<<" automatic \n";
|
|
m_numDisplay = element.text().toInt();
|
|
formatedNote();
|
|
}
|
|
else
|
|
{
|
|
// kdDebug()<<" manual \n";
|
|
m_varValue = TQVariant( element.text() );
|
|
}
|
|
} else if ( localName == "note-body" ) {
|
|
bodyElement = element;
|
|
}
|
|
}
|
|
Q_ASSERT( !bodyElement.isNull() );
|
|
|
|
Q_ASSERT( !m_frameset );
|
|
m_frameset = new KWFootNoteFrameSet( m_doc, id );
|
|
m_frameset->setFrameSetInfo( KWFrameSet::FI_FOOTNOTE );
|
|
|
|
m_frameset->setFootNoteVariable( this );
|
|
m_frameset->createInitialFrame( 0 );
|
|
m_doc->addFrameSet( m_frameset );
|
|
|
|
// Load the body of the footnote
|
|
m_frameset->loadOasisContent( bodyElement, context );
|
|
}
|
|
|
|
void KWFootNoteVariable::saveOasis( KoXmlWriter& writer, KoSavingContext& context ) const
|
|
{
|
|
if(! m_frameset) return; // see bug #126007
|
|
|
|
//<text:note text:id="ftn0" text:note-class="footnote"><text:note-citation>1</text:note-citation><text:note-body><text:p text:style-name="Footnote"/></text:note-body></text:note>
|
|
//<text:note text:id="ftn1" text:note-class="endnote"><text:note-citation>i</text:note-citation><text:note-body><text:p text:style-name="Endnote"/></text:note-body></text:note>
|
|
//<text:note text:id="ftn2" text:note-class="footnote"><text:note-citation text:label="vv">vv</text:note-citation><text:note-body><text:p text:style-name="Footnote"/></text:note-body></text:note>
|
|
writer.startElement( "text:note" );
|
|
writer.addAttribute( "text:id",m_frameset->name() );
|
|
writer.addAttribute( "text:note-class", m_noteType == FootNote ? "footnote" : "endnote" );
|
|
|
|
writer.startElement( "text:note-citation" );
|
|
if ( m_numberingType == Auto )
|
|
writer.addTextNode( TQString( "%1" ).arg( m_numDisplay ) );
|
|
else
|
|
{
|
|
writer.addAttribute( "text:label", m_varValue.toString() );
|
|
writer.addTextNode(m_varValue.toString() );
|
|
}
|
|
writer.endElement();
|
|
|
|
writer.startElement( "text:note-body" );
|
|
//save text from end/footnote
|
|
m_frameset->saveOasisContent( writer, context );
|
|
writer.endElement();
|
|
|
|
writer.endElement();
|
|
}
|
|
|
|
void KWFootNoteVariable::saveVariable( TQDomElement &parentElem )
|
|
{
|
|
TQDomElement footnoteElem = parentElem.ownerDocument().createElement( "FOOTNOTE" );
|
|
parentElem.appendChild( footnoteElem );
|
|
//footnoteElem.setAttribute( "subtype", 0 );
|
|
if ( m_numberingType == Auto )
|
|
footnoteElem.setAttribute( "value", m_numDisplay );
|
|
else
|
|
footnoteElem.setAttribute( "value", m_varValue.toString() );
|
|
footnoteElem.setAttribute( "notetype", m_noteType == FootNote ? "footnote" : "endnote" );
|
|
footnoteElem.setAttribute( "numberingtype", m_numberingType == Auto ? "auto" : "manual" );
|
|
Q_ASSERT( m_frameset );
|
|
if( m_frameset )
|
|
footnoteElem.setAttribute( "frameset", m_frameset->name() );
|
|
}
|
|
|
|
void KWFootNoteVariable::load( TQDomElement &elem )
|
|
{
|
|
KoVariable::load( elem );
|
|
TQDomElement footnoteElem = elem.namedItem( "FOOTNOTE" ).toElement();
|
|
if (!footnoteElem.isNull())
|
|
{
|
|
//m_subtype = footnoteElem.attribute("subtype").toInt();
|
|
TQString str = footnoteElem.attribute("notetype").lower();
|
|
if ( str == "footnote" )
|
|
m_noteType = FootNote;
|
|
else if ( str == "endnote" )
|
|
m_noteType = EndNote;
|
|
else
|
|
kdWarning() << "Unknown footnote type: '" << str << "'" << endl;
|
|
|
|
str = footnoteElem.attribute("numberingtype").lower();
|
|
if ( str == "auto" )
|
|
m_numberingType = Auto;
|
|
else if ( str == "manual")
|
|
m_numberingType = Manual;
|
|
else
|
|
kdWarning() << "Unknown footnote numbering: '" << str << "'" << endl;
|
|
|
|
if ( m_numberingType == Auto )
|
|
{
|
|
m_numDisplay = footnoteElem.attribute("value").toInt();
|
|
formatedNote();
|
|
}
|
|
else
|
|
m_varValue = TQVariant(footnoteElem.attribute("value"));
|
|
|
|
str = footnoteElem.attribute("frameset");
|
|
m_doc->addFootNoteRequest( str, this );
|
|
}
|
|
}
|
|
|
|
void KWFootNoteVariable::formatedNote()
|
|
{
|
|
if ( m_numberingType == Auto )
|
|
{
|
|
m_varValue = TQVariant(applyStyle());
|
|
}
|
|
}
|
|
|
|
TQString KWFootNoteVariable::applyStyle()
|
|
{
|
|
KWVariableSettings* settings = static_cast<KWVariableSettings*>(m_varColl->variableSetting());
|
|
KoParagCounter tmpCounter = (m_noteType == FootNote) ? settings->footNoteCounter() : settings->endNoteCounter();
|
|
|
|
TQString tmp;
|
|
int val = m_numDisplay + tmpCounter.startNumber()-1;
|
|
Q_ASSERT( val >= 0 );
|
|
if ( val < 0 ) // let's not go into makeRomanNumber with a negative number :}
|
|
return i18n("ERROR");
|
|
switch ( tmpCounter.style() )
|
|
{
|
|
case KoParagCounter::STYLE_NUM:
|
|
tmp.setNum( val );
|
|
break;
|
|
case KoParagCounter::STYLE_ALPHAB_L:
|
|
tmp=KoParagCounter::makeAlphaLowerNumber( val );
|
|
break;
|
|
case KoParagCounter::STYLE_ALPHAB_U:
|
|
tmp=KoParagCounter::makeAlphaUpperNumber( val );
|
|
break;
|
|
case KoParagCounter::STYLE_ROM_NUM_L:
|
|
tmp = KoParagCounter::makeRomanNumber( val ).lower();
|
|
break;
|
|
case KoParagCounter::STYLE_ROM_NUM_U:
|
|
tmp = KoParagCounter::makeRomanNumber( val ).upper();
|
|
break;
|
|
case KoParagCounter::STYLE_CUSTOMBULLET:
|
|
//todo change font
|
|
tmp = tmpCounter.customBulletCharacter();
|
|
break;
|
|
default:
|
|
tmp.setNum( val );
|
|
break;
|
|
}
|
|
|
|
tmp.prepend( tmpCounter.prefix() );
|
|
tmp.append( tmpCounter.suffix() );
|
|
return tmp;
|
|
}
|
|
|
|
TQString KWFootNoteVariable::text(bool realValue)
|
|
{
|
|
if (m_varColl->variableSetting()->displayFieldCode()&& !realValue)
|
|
return fieldCode();
|
|
return m_varFormat->convert( m_varValue );
|
|
}
|
|
|
|
void KWFootNoteVariable::setNumDisplay( int val )
|
|
{
|
|
m_numDisplay = val;
|
|
if ( val != -1 ) // -1 is used to 'invalidate so that renumberFootNotes recalcs'
|
|
formatedNote();
|
|
}
|
|
|
|
TQString KWFootNoteVariable::fieldCode()
|
|
{
|
|
return (noteType()==FootNote) ?i18n("Footnote"):i18n("Endnote");
|
|
}
|
|
|
|
void KWFootNoteVariable::drawCustomItem( TQPainter* p, int x, int y, int wpix, int hpix, int ascentpix, int /*cx*/, int /*cy*/, int /*cw*/, int /*ch*/, const TQColorGroup& cg, bool selected, int _offset, bool drawingShadow )
|
|
{
|
|
KoTextFormat * fmt = format();
|
|
KoTextZoomHandler * zh = textDocument()->paintingZoomHandler();
|
|
|
|
// Force drawing as "superscript" - hmm, the formatting will use too big font metrics though.
|
|
TQFont font( fmt->screenFont( zh ) );
|
|
int pointSize = ( ( font.pointSize() * 2 ) / 3 );
|
|
font.setPointSize( pointSize );
|
|
|
|
int offset = _offset;
|
|
if ( offset == 0 )
|
|
{
|
|
int h = zh->layoutUnitToPixelY( /*_y HACK,*/ height );
|
|
offset = -( h - TQFontMetrics(font).height() );
|
|
}
|
|
|
|
TQColor textColor( fmt->color() );
|
|
drawCustomItemHelper( p, x, y, wpix, hpix, ascentpix, cg, selected, offset, fmt, font, textColor, drawingShadow );
|
|
}
|
|
|
|
void KWFootNoteVariable::finalize()
|
|
{
|
|
Q_ASSERT( m_frameset );
|
|
if (!m_frameset )
|
|
return;
|
|
Q_ASSERT( !m_frameset->isDeleted() );
|
|
if ( m_frameset->isDeleted() )
|
|
return;
|
|
|
|
//kdDebug(32001) << "KWFootNoteVariable::finalize" << endl;
|
|
|
|
int pageNum = this->pageNum();
|
|
if ( pageNum == -1 )
|
|
return;
|
|
|
|
KWFrame* footNoteFrame = m_frameset->frame( 0 );
|
|
int framePage = footNoteFrame->pageNumber();
|
|
if ( framePage != pageNum )
|
|
{
|
|
//kdDebug(32001) << "Footnote var '" << text() << "' at page " << pageNum << ", footnote frame at page " << framePage << " -> abortFormatting() and recalcFrames()" << endl;
|
|
KWTextFrameSet * fs = static_cast<KWTextDocument *>(textDocument())->textFrameSet();
|
|
fs->textObject()->abortFormatting();
|
|
|
|
// abortFormatting is a bool in kotextobject. So we need to return there before
|
|
// starting text layout again.
|
|
m_doc->delayedRecalcFrames( TQMIN( pageNum, framePage ) );
|
|
m_doc->delayedRepaintAllViews();
|
|
}
|
|
}
|
|
|
|
void KWFootNoteVariable::resize()
|
|
{
|
|
if ( m_deleted )
|
|
return;
|
|
KoTextFormat *fmt = format();
|
|
TQFont font( fmt->refFont() ); // LU font
|
|
if ( fmt->vAlign() == KoTextFormat::AlignNormal ) // if it's still normal...
|
|
{
|
|
int pointSize = ( ( font.pointSize() * 2 ) / 3 ); // ...force superscript
|
|
font.setPointSize( pointSize );
|
|
}
|
|
TQFontMetrics fm( font );
|
|
TQString txt = text();
|
|
width = 0;
|
|
for ( int i = 0 ; i < (int)txt.length() ; ++i )
|
|
width += fm.charWidth( txt, i ); // size at 100%
|
|
// zoom to LU
|
|
width = tqRound( KoTextZoomHandler::ptToLayoutUnitPt( width ) );
|
|
height = fmt->height();
|
|
m_ascent = fmt->ascent();
|
|
//kdDebug() << "KWFootNoteVariable::resize text=" << txt << " width=" << width << " height=" << height << endl;
|
|
}
|
|
|
|
void KWFootNoteVariable::setDeleted( bool del )
|
|
{
|
|
kdDebug() << "KWFootNoteVariable::setDeleted " << del << endl;
|
|
if ( del )
|
|
{
|
|
Q_ASSERT( m_frameset );
|
|
if ( m_frameset ) {
|
|
m_frameset->deleteAllFrames(); // Important, because we don't want to save it!
|
|
m_frameset->setVisible( false );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Q_ASSERT( m_frameset );
|
|
if ( m_frameset ) {
|
|
kdDebug() << "Making frameset " << m_frameset << " visible" << endl;
|
|
m_frameset->setVisible( true );
|
|
if ( m_frameset->isDeleted() )
|
|
m_frameset->createInitialFrame( 0 ); // Page number shouldn't matter (see recalcFrames below).
|
|
Q_ASSERT( m_frameset->isVisible() );
|
|
}
|
|
}
|
|
|
|
// hmm, maybe compress all the stuff below and do only once
|
|
// (e.g. when deleting multiple footnotes)?
|
|
// (but we can't really delay it with a sst, the formatMore after undo/redo
|
|
// needs this to be done already, I think). Bah.
|
|
|
|
// Re-number footnote variables
|
|
KWTextFrameSet * textfs = static_cast<KWTextDocument *>(textDocument())->textFrameSet();
|
|
textfs->renumberFootNotes();
|
|
|
|
m_doc->recalcFrames();
|
|
|
|
if (!del)
|
|
m_frameset->layout(); // format its text, so that it resizes the frame
|
|
KoVariable::setDeleted( del );
|
|
// Does this compress? Probably not.
|
|
m_doc->delayedRepaintAllViews();
|
|
}
|
|
|
|
int KWFootNoteVariable::pageNum() const
|
|
{
|
|
int page = m_doc->pageManager()->pageNumber(varY());
|
|
Q_ASSERT( page <= m_doc->lastPage() );
|
|
return page;
|
|
}
|
|
|
|
double KWFootNoteVariable::varY() const
|
|
{
|
|
// Find out the position of the footnote variable in document coordinates.
|
|
int paragy = paragraph()->rect().y();
|
|
KWTextFrameSet * fs = static_cast<KWTextDocument *>(textDocument())->textFrameSet();
|
|
if ( !fs->hasFramesInPageArray() ) // we need it for internalToDocument
|
|
{
|
|
kdDebug(32001) << "KWFootNoteVariable::varY too early, no updateFrames yet" << endl;
|
|
return 0; // this happens on loading - frame layout is done before text layout
|
|
}
|
|
// What we need is "has never been formatted". Not "has just been invalidated"...
|
|
//if ( !paragraph()->isValid() )
|
|
//{
|
|
// kdDebug(32001) << "KWFootNoteVariable::varY called but paragraph " << paragraph()->paragId() << " not valid" << endl;
|
|
// return 0;
|
|
//}
|
|
KoPoint dPoint;
|
|
//kdDebug(32001) << "KWFootNoteVariable::pageNum position of variable (LU): " << TQPoint( x(), paragy + y() + height ) << endl;
|
|
KWFrame* containingFrame = fs->internalToDocument( TQPoint( x(), paragy + y() + height ), dPoint );
|
|
if ( containingFrame )
|
|
{
|
|
// Ok, the (bottom of the) footnote variable is at dPoint.
|
|
double varY = dPoint.y();
|
|
//kdDebug(32001) << " found containingFrame " << containingFrame << " page:" << containingFrame->pageNumber() << " varY=" << varY << endl;
|
|
//int pageNum = containingFrame->pageNumber(); // and at page pageNum
|
|
return varY;
|
|
} else
|
|
{
|
|
// This can happen if the page hasn't been created yet
|
|
//kdDebug(32001) << "KWFootNoteVariable::pageNum internalToDocument returned 0L for " << x << ", " << y+paragy << endl;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
KWStatisticVariable::KWStatisticVariable( KoTextDocument *textdoc, int subtype, KoVariableFormat *varFormat,KoVariableCollection *_varColl, KWDocument *doc )
|
|
: KoStatisticVariable( textdoc, subtype, varFormat, _varColl ),
|
|
m_doc(doc)
|
|
{
|
|
}
|
|
|
|
void KWStatisticVariable::recalc()
|
|
{
|
|
int nb = 0;
|
|
ulong charsWithSpace = 0L;
|
|
ulong charsWithoutSpace = 0L;
|
|
ulong words = 0L;
|
|
ulong sentences = 0L;
|
|
ulong lines = 0L;
|
|
ulong syllables = 0L;
|
|
bool frameInfo = ( m_subtype == VST_STATISTIC_NB_WORD ||
|
|
m_subtype == VST_STATISTIC_NB_SENTENCE ||
|
|
m_subtype == VST_STATISTIC_NB_LINES ||
|
|
m_subtype == VST_STATISTIC_NB_CHARACTERE);
|
|
TQPtrListIterator<KWFrameSet> framesetIt( m_doc->framesetsIterator() );
|
|
//TODO change int to ulong
|
|
for ( framesetIt.toFirst(); framesetIt.current(); ++framesetIt )
|
|
{
|
|
KWFrameSet *frameSet = framesetIt.current();
|
|
if ( frameSet->isVisible() )
|
|
{
|
|
if ( m_subtype == VST_STATISTIC_NB_FRAME )
|
|
{
|
|
++nb;
|
|
}
|
|
else if( m_subtype == VST_STATISTIC_NB_PICTURE && frameSet->type() == FT_PICTURE )
|
|
{
|
|
++nb;
|
|
}
|
|
else if( m_subtype == VST_STATISTIC_NB_TABLE && frameSet->type() == FT_TABLE )
|
|
{
|
|
++nb;
|
|
}
|
|
else if( m_subtype == VST_STATISTIC_NB_EMBEDDED && frameSet->type() == FT_PART )
|
|
{
|
|
++nb;
|
|
}
|
|
if ( frameInfo
|
|
&& (frameSet->frameSetInfo() == KWFrameSet::FI_FOOTNOTE || frameSet->frameSetInfo() == KWFrameSet::FI_BODY)
|
|
&& frameSet->isVisible() )
|
|
{
|
|
frameSet->statistics( 0L, charsWithSpace, charsWithoutSpace,
|
|
words, sentences, syllables, lines, false );
|
|
}
|
|
}
|
|
if ( frameInfo )
|
|
{
|
|
if( m_subtype == VST_STATISTIC_NB_WORD )
|
|
{
|
|
nb = words;
|
|
}
|
|
else if( m_subtype == VST_STATISTIC_NB_SENTENCE )
|
|
{
|
|
nb = sentences;
|
|
}
|
|
else if( m_subtype == VST_STATISTIC_NB_LINES )
|
|
{
|
|
nb = lines;
|
|
}
|
|
else if ( m_subtype == VST_STATISTIC_NB_CHARACTERE )
|
|
{
|
|
nb = charsWithSpace;
|
|
}
|
|
else if ( m_subtype == VST_STATISTIC_NB_NON_WHITESPACE_CHARACTERE )
|
|
{
|
|
nb = charsWithoutSpace;
|
|
}
|
|
else if ( m_subtype == VST_STATISTIC_NB_SYLLABLE )
|
|
{
|
|
nb = syllables;
|
|
}
|
|
else
|
|
nb = 0;
|
|
}
|
|
}
|
|
m_varValue = TQVariant(nb);
|
|
resize();
|
|
if ( width == -1 )
|
|
width = 0;
|
|
}
|
|
|
|
TQString KWStatisticVariable::text(bool realValue)
|
|
{
|
|
if ( m_varColl->variableSetting()->displayFieldCode() && !realValue )
|
|
return fieldCode();
|
|
else
|
|
return m_varFormat->convert( m_varValue );
|
|
}
|