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.
1795 lines
60 KiB
1795 lines
60 KiB
/* This file is part of the KDE project
|
|
Copyright (C) 2001 Andrea Rizzi <rizzi@kde.org>
|
|
Ulrich Kuettler <ulrich.kuettler@mailbox.tu-dresden.de>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <tqstring.h>
|
|
#include <tqfontmetrics.h>
|
|
|
|
#include <tdelocale.h>
|
|
#include <tdemessagebox.h>
|
|
|
|
//#include <KoUnit.h>
|
|
|
|
#include "kformulamathmlread.h"
|
|
#include "symboltable.h"
|
|
|
|
KFORMULA_NAMESPACE_BEGIN
|
|
using namespace std;
|
|
|
|
class MathML2KFormulaPrivate
|
|
{
|
|
friend class MathML2KFormula;
|
|
|
|
public:
|
|
MathML2KFormulaPrivate( MathML2KFormula* mml_filter,
|
|
const ContextStyle& contextStyle,
|
|
const TQDomDocument& formuladoc );
|
|
~MathML2KFormulaPrivate();
|
|
|
|
void math( TQDomElement element );
|
|
|
|
// Token Elements
|
|
void mi( TQDomElement element, TQDomNode docnode );
|
|
void mn( TQDomElement element, TQDomNode docnode );
|
|
void mo( TQDomElement element, TQDomNode docnode );
|
|
void mtext( TQDomElement element, TQDomNode docnode );
|
|
void mspace( TQDomElement element, TQDomNode docnode );
|
|
void ms( TQDomElement element, TQDomNode docnode );
|
|
// mglyph not supported
|
|
|
|
// General Layout Schemata
|
|
void mrow( TQDomElement element, TQDomNode docnode );
|
|
void mfrac( TQDomElement element, TQDomNode docnode );
|
|
void msqrt( TQDomElement element, TQDomNode docnode );
|
|
void mroot( TQDomElement element, TQDomNode docnode );
|
|
void mstyle( TQDomElement element, TQDomNode docnode );
|
|
// merror not supported
|
|
// mpadded not supported
|
|
// mphantom not supported
|
|
void mfenced( TQDomElement element, TQDomNode docnode );
|
|
// menclose not supported
|
|
|
|
// Script and Limit Schemata
|
|
void msub_msup( TQDomElement element, TQDomNode docnode );
|
|
void msubsup( TQDomElement element, TQDomNode docnode );
|
|
void munder( TQDomElement element, TQDomNode docnode, bool oasisFormat );
|
|
void mover( TQDomElement element, TQDomNode docnode, bool oasisFormat );
|
|
void munderover( TQDomElement element, TQDomNode docnode, bool oasisFormat );
|
|
// mmultiscripts not supported
|
|
|
|
// Tables and Matrices
|
|
void mtable( TQDomElement element, TQDomNode docnode );
|
|
// not much supported
|
|
|
|
// Enlivening Expressions
|
|
// maction not supported
|
|
|
|
protected:
|
|
void createTextElements( TQString text, TQDomNode docnode );
|
|
void createNameSequence( TQString text, TQDomNode docnode );
|
|
double convertToPoint( TQString value, bool* ok );
|
|
bool isEmbellishedOperator( TQDomNode node, TQDomElement* mo, bool oasisFormat );
|
|
bool isSpaceLike( TQDomNode node, bool oasisFormat );
|
|
|
|
enum MathVariant {
|
|
normal,
|
|
bold,
|
|
italic,
|
|
bold_italic,
|
|
double_struck,
|
|
bold_fraktur,
|
|
script,
|
|
bold_script,
|
|
fraktur,
|
|
sans_serif,
|
|
bold_sans_serif,
|
|
sans_serif_italic,
|
|
sans_serif_bold_italic,
|
|
monospace
|
|
};
|
|
|
|
struct MathStyle {
|
|
MathStyle()
|
|
: scriptsizemultiplier( 0.71 ),
|
|
scriptminsize( 8 ),
|
|
veryverythinmathspace( 1.0/18.0 ),
|
|
verythinmathspace( 2.0/18.0 ),
|
|
thinmathspace( 3.0/18.0 ),
|
|
mediummathspace( 4.0/18.0 ),
|
|
thickmathspace( 5.0/18.0 ),
|
|
verythickmathspace( 6.0/18.0 ),
|
|
veryverythickmathspace( 7.0/18.0 ),
|
|
|
|
useVariant( false )
|
|
{
|
|
}
|
|
|
|
void styleChange()
|
|
{
|
|
kdDebug( DEBUGID ) << "Style Change:"
|
|
<< "\n scriptlevel = " << scriptlevel
|
|
<< "\n displaystyle = " << displaystyle
|
|
<< "\n scriptsizemultiplier = "
|
|
<< scriptsizemultiplier
|
|
<< "\n scriptminsize = " << scriptminsize
|
|
<< endl;
|
|
}
|
|
|
|
void setStyles( TQDomElement element )
|
|
{
|
|
if ( !useVariant )
|
|
return;
|
|
|
|
switch ( mathvariant )
|
|
{
|
|
case normal:
|
|
element.setAttribute( "STYLE", "normal" );
|
|
break;
|
|
case bold:
|
|
element.setAttribute( "STYLE", "bold" );
|
|
break;
|
|
|
|
case bold_italic:
|
|
element.setAttribute( "STYLE", "bolditalic" );
|
|
break;
|
|
case italic:
|
|
element.setAttribute( "STYLE", "italic" );
|
|
break;
|
|
|
|
case double_struck:
|
|
element.setAttribute( "FAMILY", "doublestruck" );
|
|
break;
|
|
|
|
case bold_fraktur:
|
|
element.setAttribute( "STYLE", "bold" );
|
|
case fraktur:
|
|
element.setAttribute( "FAMILY", "fraktur" );
|
|
break;
|
|
|
|
case bold_script:
|
|
element.setAttribute( "STYLE", "bold" );
|
|
case script:
|
|
element.setAttribute( "FAMILY", "script" );
|
|
break;
|
|
|
|
case bold_sans_serif:
|
|
element.setAttribute( "STYLE", "bold" );
|
|
case sans_serif:
|
|
element.setAttribute( "FAMILY", "normal" );
|
|
break;
|
|
case sans_serif_bold_italic:
|
|
element.setAttribute( "STYLE", "bolditalic" );
|
|
element.setAttribute( "FAMILY", "normal" );
|
|
break;
|
|
case sans_serif_italic:
|
|
element.setAttribute( "STYLE", "italic" );
|
|
element.setAttribute( "FAMILY", "normal" );
|
|
break;
|
|
|
|
//case monospace:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void readStyles( TQDomElement mmlElement )
|
|
{
|
|
if ( mmlElement.hasAttribute( "mathvariant" ) )
|
|
{
|
|
useVariant = true;
|
|
|
|
if ( mmlElement.attribute( "mathvariant" ) == "normal" )
|
|
mathvariant = normal;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "bold" )
|
|
mathvariant = bold;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "italic" )
|
|
mathvariant = italic;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "bold-italic" )
|
|
mathvariant = bold_italic;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "double-struck" )
|
|
mathvariant = double_struck;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "bold-fraktur" )
|
|
mathvariant = bold_fraktur;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "script" )
|
|
mathvariant = script;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "bold-script" )
|
|
mathvariant = bold_script;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "fraktur" )
|
|
mathvariant = fraktur;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "sans-serif" )
|
|
mathvariant = sans_serif;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "bold-sans-serif" )
|
|
mathvariant = bold_sans_serif;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "sans-serif-italic" )
|
|
mathvariant = sans_serif_italic;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "sans-serif-bold-italic" )
|
|
mathvariant = sans_serif_bold_italic;
|
|
else if ( mmlElement.attribute( "mathvariant" ) == "monospace" )
|
|
mathvariant = monospace;
|
|
}
|
|
}
|
|
|
|
// Styles, set by <mstyle> // default
|
|
|
|
int scriptlevel; // inherited
|
|
bool displaystyle; // inherited
|
|
double scriptsizemultiplier; // 0.71
|
|
double scriptminsize; // 8pt
|
|
// color
|
|
// background
|
|
double veryverythinmathspace; // 1/18em = 0.0555556em
|
|
double verythinmathspace; // 2/18em = 0.111111em
|
|
double thinmathspace; // 3/18em = 0.166667em
|
|
double mediummathspace; // 4/18em = 0.222222em
|
|
double thickmathspace; // 5/18em = 0.277778em
|
|
double verythickmathspace; // 6/18em = 0.333333em
|
|
double veryverythickmathspace; // 7/18em = 0.388889em
|
|
|
|
// 'Local' styles
|
|
|
|
MathVariant mathvariant;
|
|
bool useVariant;
|
|
//int mathsize;
|
|
};
|
|
|
|
MathStyle style;
|
|
TQDomDocument doc;
|
|
|
|
private:
|
|
const ContextStyle& context;
|
|
MathML2KFormula* filter;
|
|
};
|
|
|
|
MathML2KFormulaPrivate::MathML2KFormulaPrivate( MathML2KFormula* mml_filter, const ContextStyle& cs, const TQDomDocument& formuladoc )
|
|
: doc( formuladoc ), context( cs ), filter( mml_filter )
|
|
{
|
|
}
|
|
|
|
MathML2KFormulaPrivate::~MathML2KFormulaPrivate()
|
|
{
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::math( TQDomElement element )
|
|
{
|
|
TQDomElement formula = doc.createElement( "FORMULA" );
|
|
TQDomNode n = element.firstChild();
|
|
|
|
TQString display = element.attribute( "display" );
|
|
|
|
if ( display == "block" ) {
|
|
style.displaystyle = true;
|
|
}
|
|
else {
|
|
// if display == "inline" (default) or illegal (then use default)
|
|
style.displaystyle = false;
|
|
}
|
|
|
|
style.scriptlevel = 0;
|
|
|
|
/*kdDebug( DEBUGID ) << "<math> element:\n displaystyle = "
|
|
<< style.displaystyle << "\n scriptlevel = "
|
|
<< style.scriptlevel << endl;*/
|
|
|
|
while ( !n.isNull() ) {
|
|
filter->processElement( n, doc, formula );
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
doc.appendChild( formula );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mi( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
MathStyle previousStyle( style );
|
|
TQString text = element.text().stripWhiteSpace();
|
|
if ( text.length() == 1 ) { // Default italic, only when content is one char
|
|
style.mathvariant = italic;
|
|
style.useVariant = true;
|
|
style.readStyles( element );
|
|
createTextElements( text, docnode );
|
|
} else { // If length is 0 or >1, it should be a text sequence
|
|
style.readStyles( element );
|
|
createNameSequence( text, docnode );
|
|
}
|
|
style = previousStyle;
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mo( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
MathStyle previousStyle( style );
|
|
style.readStyles( element );
|
|
|
|
TQString text = element.text().stripWhiteSpace();
|
|
createTextElements( text, docnode );
|
|
|
|
style = previousStyle;
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mn( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
MathStyle previousStyle( style );
|
|
style.readStyles( element );
|
|
|
|
TQString text = element.text().stripWhiteSpace();
|
|
createTextElements( text, docnode );
|
|
|
|
style = previousStyle;
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mtext( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
MathStyle previousStyle( style );
|
|
style.readStyles( element );
|
|
|
|
TQDomNode n = element.firstChild();
|
|
|
|
while ( !n.isNull() ) {
|
|
if ( n.isText() ) {
|
|
TQString text = n.toText().data().stripWhiteSpace();
|
|
createTextElements( text, docnode );
|
|
}
|
|
else if ( n.isElement() ) {
|
|
filter->processElement( n, doc, docnode );
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<mtext> child: " << n.nodeName() << endl;
|
|
}
|
|
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
style = previousStyle;
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::ms( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQString lquote = element.attribute( "lquote", "\"" );
|
|
TQString rquote = element.attribute( "rquote", "\"" );
|
|
TQString text;
|
|
|
|
text = lquote;
|
|
text += element.text().stripWhiteSpace();
|
|
text += rquote;
|
|
|
|
createTextElements( text, docnode );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mspace( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
// we support only horizontal space
|
|
TQString width = element.attribute( "width" );
|
|
|
|
TQDomElement spaceelement = doc.createElement( "SPACE" );
|
|
|
|
// check for namedspace. We don't support much...
|
|
if ( width == "veryverythinmathspace" ) {
|
|
spaceelement.setAttribute( "WIDTH", "thin" );
|
|
}
|
|
else if ( width == "verythinmathspace" ) {
|
|
spaceelement.setAttribute( "WIDTH", "thin" );
|
|
}
|
|
else if ( width == "thinmathspace" ) {
|
|
spaceelement.setAttribute( "WIDTH", "thin" );
|
|
}
|
|
else if ( width == "mediummathspace" ) {
|
|
spaceelement.setAttribute( "WIDTH", "medium" );
|
|
}
|
|
else if ( width == "thickmathspace" ) {
|
|
spaceelement.setAttribute( "WIDTH", "thick" );
|
|
}
|
|
else if ( width == "verythickmathspace" ) {
|
|
spaceelement.setAttribute( "WIDTH", "thick" );
|
|
}
|
|
else if ( width == "veryverythickmathspace" ) {
|
|
spaceelement.setAttribute( "WIDTH", "quad" );
|
|
}
|
|
|
|
else {
|
|
// units
|
|
|
|
double w = 0;
|
|
bool ok;
|
|
|
|
if ( width.endsWith( "em" ) ) {
|
|
// See MathML specification, Appendix H
|
|
w = context.getDefaultFont().pointSize();
|
|
if ( w == -1 ) {
|
|
TQFontMetrics fm( context.getDefaultFont() );
|
|
w = fm.width( 'm' );
|
|
}
|
|
w = w * width.remove( width.length() - 2, 2 ).toDouble( &ok );
|
|
// w in points?
|
|
}
|
|
else if ( width.endsWith( "px" ) ) {
|
|
w = width.remove( width.length() - 2, 2 ).toDouble( &ok );
|
|
// w in pixels
|
|
}
|
|
else if ( width.endsWith( "in" ) ) {
|
|
w = width.remove( width.length() - 2, 2 ).toDouble( &ok );
|
|
w *= 72; // w in points
|
|
}
|
|
else if ( width.endsWith( "cm" ) ) {
|
|
w = width.remove( width.length() - 2, 2 ).toDouble( &ok );
|
|
w *= 1/2.54 * 72; // w in points
|
|
}
|
|
else if ( width.endsWith( "mm" ) ) {
|
|
w = width.remove( width.length() - 2, 2 ).toDouble( &ok );
|
|
w *= 1/25.4 * 72; // w in points
|
|
}
|
|
else if ( width.endsWith( "pt" ) ) {
|
|
w = width.remove( width.length() - 2, 2 ).toDouble( &ok );
|
|
// w in points
|
|
}
|
|
else if ( width.endsWith( "pc" ) ) {
|
|
w = width.remove( width.length() - 2, 2 ).toDouble( &ok );
|
|
w /= 12; // w in points
|
|
}
|
|
else {
|
|
w = width.toDouble( &ok );
|
|
}
|
|
|
|
if ( !ok )
|
|
return;
|
|
|
|
if ( w < 20 )
|
|
spaceelement.setAttribute( "WIDTH", "thin" );
|
|
else if ( w < 40 )
|
|
spaceelement.setAttribute( "WIDTH", "medium" );
|
|
else if ( w < 80 )
|
|
spaceelement.setAttribute( "WIDTH", "thick" );
|
|
else
|
|
spaceelement.setAttribute( "WIDTH", "quad" );
|
|
}
|
|
|
|
docnode.appendChild( spaceelement );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mrow( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQDomNode n = element.firstChild();
|
|
while ( !n.isNull() ) {
|
|
if ( n.isElement () ) {
|
|
TQDomElement e = n.toElement();
|
|
// We do not allow sequence inside sequence
|
|
filter->processElement( e, doc, docnode );
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<mrow> child: " << n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mfrac( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQDomNode n = element.firstChild();
|
|
TQDomElement fraction = doc.createElement( "FRACTION" );
|
|
|
|
MathStyle previousStyle( style );
|
|
style.displaystyle ? style.displaystyle = false : style.scriptlevel += 1;
|
|
style.styleChange();
|
|
|
|
int i = 0;
|
|
while ( !n.isNull() && i < 2 ) {
|
|
if ( n.isElement() ) {
|
|
++i;
|
|
if ( i == 1 ) { //first is numerator
|
|
TQDomElement numerator =
|
|
doc.createElement( "NUMERATOR" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
numerator.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
fraction.appendChild( numerator );
|
|
|
|
}
|
|
else {
|
|
TQDomElement denominator =
|
|
doc.createElement( "DENOMINATOR" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
denominator.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
fraction.appendChild( denominator );
|
|
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<mfrac> child: " << n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
style = previousStyle;
|
|
docnode.appendChild( fraction );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mroot( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQDomNode n = element.firstChild();
|
|
int i = 0;
|
|
TQDomElement root = doc.createElement( "ROOT" );
|
|
|
|
while ( !n.isNull() && i < 2 ) {
|
|
if ( n.isElement() ) {
|
|
++i;
|
|
if ( i == 1 ) { //first is content (base)
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
|
|
root.appendChild(content);
|
|
}
|
|
else { // index
|
|
MathStyle previousStyle( style );
|
|
style.scriptlevel += 2;
|
|
style.displaystyle = false;
|
|
style.styleChange();
|
|
|
|
TQDomElement index = doc.createElement( "INDEX" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
|
|
style = previousStyle;
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<mroot> child: " << n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
docnode.appendChild( root );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::msqrt( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQDomNode n = element.firstChild();
|
|
TQDomElement root = doc.createElement( "ROOT" );
|
|
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
root.appendChild( content );
|
|
|
|
while ( !n.isNull() ) {
|
|
if ( n.isElement() ) {
|
|
filter->processElement( n.toElement(), doc, sequence );
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<msqrt> child: " << n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
docnode.appendChild( root );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mstyle( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
bool ok;
|
|
|
|
MathStyle previousStyle( style );
|
|
style.readStyles( element );
|
|
|
|
if ( element.hasAttribute( "scriptlevel" ) ) {
|
|
TQString scriptlevel = element.attribute( "scriptlevel" );
|
|
if ( scriptlevel.startsWith( "+" ) || scriptlevel.startsWith( "-" ) )
|
|
style.scriptlevel += scriptlevel.toInt( &ok );
|
|
else
|
|
style.scriptlevel = scriptlevel.toInt( &ok );
|
|
if ( !ok )
|
|
style.scriptlevel = previousStyle.scriptlevel;
|
|
}
|
|
if ( element.hasAttribute( "displaystyle" ) ) {
|
|
TQString displaystyle = element.attribute( "displaystyle" );
|
|
if ( displaystyle == "true" )
|
|
style.displaystyle = true;
|
|
else if ( displaystyle == "false" )
|
|
style.displaystyle = false;
|
|
}
|
|
if ( element.hasAttribute( "scriptsizemultiplier" ) ) {
|
|
style.scriptsizemultiplier =
|
|
element.attribute( "scriptsizemultiplier" ).toDouble( &ok );
|
|
if ( !ok )
|
|
style.scriptsizemultiplier = previousStyle.scriptsizemultiplier;
|
|
}
|
|
if ( element.hasAttribute( "scriptminsize" ) ) {
|
|
TQString scriptminsize = element.attribute( "scriptminsize" );
|
|
style.scriptminsize = convertToPoint( scriptminsize, &ok );
|
|
if ( !ok )
|
|
style.scriptminsize = previousStyle.scriptminsize;
|
|
}
|
|
|
|
if ( element.hasAttribute( "veryverythinmathspace" ) ) {
|
|
TQString vvthinmspace = element.attribute( "veryverythinmathspace" );
|
|
style.veryverythinmathspace = convertToPoint( vvthinmspace, &ok );
|
|
if ( !ok )
|
|
style.veryverythinmathspace = previousStyle.veryverythinmathspace;
|
|
}
|
|
if ( element.hasAttribute( "verythinmathspace" ) ) {
|
|
TQString vthinmspace = element.attribute( "verythinmathspace" );
|
|
style.verythinmathspace = convertToPoint( vthinmspace, &ok );
|
|
if ( !ok )
|
|
style.verythinmathspace = previousStyle.verythinmathspace;
|
|
}
|
|
if ( element.hasAttribute( "thinmathspace" ) ) {
|
|
TQString thinmathspace = element.attribute( "thinmathspace" );
|
|
style.thinmathspace = convertToPoint( thinmathspace, &ok );
|
|
if ( !ok )
|
|
style.thinmathspace = previousStyle.thinmathspace;
|
|
}
|
|
if ( element.hasAttribute( "mediummathspace" ) ) {
|
|
TQString mediummathspace = element.attribute( "mediummathspace" );
|
|
style.mediummathspace = convertToPoint( mediummathspace, &ok );
|
|
if ( !ok )
|
|
style.mediummathspace = previousStyle.mediummathspace;
|
|
}
|
|
if ( element.hasAttribute( "thickmathspace" ) ) {
|
|
TQString thickmathspace = element.attribute( "thickmathspace" );
|
|
style.thickmathspace = convertToPoint( thickmathspace, &ok );
|
|
if ( !ok )
|
|
style.thickmathspace = previousStyle.thickmathspace;
|
|
}
|
|
if ( element.hasAttribute( "verythickmathspace" ) ) {
|
|
TQString vthickmspace = element.attribute( "verythickmathspace" );
|
|
style.verythickmathspace = convertToPoint( vthickmspace, &ok );
|
|
if ( !ok )
|
|
style.verythickmathspace = previousStyle.verythickmathspace;
|
|
}
|
|
if ( element.hasAttribute( "veryverythickmathspace" ) ) {
|
|
TQString vvthickmspace = element.attribute( "veryverythickmathspace" );
|
|
style.veryverythickmathspace = convertToPoint( vvthickmspace, &ok );
|
|
if ( !ok )
|
|
style.veryverythickmathspace =
|
|
previousStyle.veryverythickmathspace;
|
|
}
|
|
|
|
style.styleChange();
|
|
|
|
TQDomNode n = element.firstChild();
|
|
while ( !n.isNull() ) {
|
|
filter->processElement( n, doc, docnode );
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
style = previousStyle;
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mfenced( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQDomElement bracket = doc.createElement( "BRACKET" );
|
|
TQString value = element.attribute( "open", "(" );
|
|
bracket.setAttribute( "LEFT", TQString::number( value.at( 0 ).latin1() ) );
|
|
value = element.attribute( "close", ")" );
|
|
bracket.setAttribute( "RIGHT", TQString::number( value.at( 0 ).latin1() ) );
|
|
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
|
|
TQString separators = element.attribute( "separators", "," );
|
|
|
|
TQDomNode n = element.firstChild();
|
|
uint i = 0;
|
|
while ( !n.isNull() ) {
|
|
if ( n.isElement() ) {
|
|
if ( i != 0 && !separators.isEmpty() ) {
|
|
TQDomElement textelement = doc.createElement( "TEXT" );
|
|
if ( i > separators.length() )
|
|
i = separators.length();
|
|
textelement.setAttribute( "CHAR", TQString( separators.at( i - 1 ) ) );
|
|
//style.setStyles( textelement );
|
|
sequence.appendChild( textelement );
|
|
}
|
|
++i;
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<mfenced> child: " << n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
bracket.appendChild( content );
|
|
docnode.appendChild( bracket );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mtable( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
MathStyle previousStyle( style );
|
|
TQString displaystyle = element.attribute( "displaystyle", "false" );
|
|
if ( displaystyle == "true" ) {
|
|
style.displaystyle = true;
|
|
}
|
|
else {
|
|
// false is default and also used for illegal values
|
|
style.displaystyle = false;
|
|
}
|
|
style.styleChange();
|
|
|
|
TQString subtag;
|
|
int rows = 0; int cols = 0;
|
|
TQDomNode n = element.firstChild();
|
|
|
|
while ( !n.isNull() ) {
|
|
if ( n.isElement() ) {
|
|
TQDomElement e = n.toElement();
|
|
subtag = e.tagName();
|
|
if (subtag == "mtr")
|
|
{
|
|
++rows;
|
|
|
|
/* Determins the number of columns */
|
|
|
|
TQDomNode cellnode = e.firstChild();
|
|
int cc = 0;
|
|
|
|
while ( !cellnode.isNull() ) {
|
|
if ( cellnode.isElement() )
|
|
cc++;
|
|
cellnode = cellnode.nextSibling();
|
|
}
|
|
|
|
if ( cc > cols )
|
|
cols = cc;
|
|
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<mtable> child: " << n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
/* Again createing elements, I need to know the number
|
|
of rows and cols to leave empty spaces */
|
|
|
|
n = element.firstChild();
|
|
TQDomElement matrix = doc.createElement( "MATRIX" );
|
|
matrix.setAttribute( "COLUMNS", cols );
|
|
matrix.setAttribute( "ROWS", rows );
|
|
|
|
while ( !n.isNull() ) {
|
|
if ( n.isElement() ) {
|
|
TQDomElement e = n.toElement();
|
|
subtag = e.tagName();
|
|
if ( subtag == "mtr" ) {
|
|
TQDomNode cellnode = e.firstChild();
|
|
int cc = 0;
|
|
while ( !cellnode.isNull() ) {
|
|
if ( cellnode.isElement() ) {
|
|
++cc;
|
|
TQDomElement cell = doc.createElement( "SEQUENCE" );
|
|
TQDomElement cellelement = cellnode.toElement();
|
|
filter->processElement( cellelement, doc, cell );
|
|
matrix.appendChild( cell );
|
|
}
|
|
cellnode = cellnode.nextSibling();
|
|
}
|
|
|
|
/* Add empty elements */
|
|
for(; cc < cols; cc++ ) {
|
|
TQDomElement cell = doc.createElement( "SEQUENCE" );
|
|
matrix.appendChild( cell );
|
|
}
|
|
}
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
style = previousStyle;
|
|
docnode.appendChild(matrix);
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::msub_msup( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQDomNode n = element.firstChild();
|
|
int i = 0;
|
|
TQDomElement root = doc.createElement( "INDEX" );
|
|
|
|
while ( !n.isNull() && i < 2 ) {
|
|
if ( n.isElement() ) {
|
|
++i;
|
|
if ( i == 1 ) { // first is content (base)
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
|
|
root.appendChild( content );
|
|
}
|
|
else {
|
|
TQDomElement index;
|
|
if ( element.tagName() == "msup" )
|
|
index = doc.createElement( "UPPERRIGHT" );
|
|
else
|
|
index = doc.createElement( "LOWERRIGHT" );
|
|
|
|
MathStyle previousStyle( style );
|
|
style.scriptlevel += 1;
|
|
style.displaystyle = false;
|
|
style.styleChange();
|
|
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
|
|
style = previousStyle;
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<" << element.tagName() << "> child: "
|
|
<< n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
docnode.appendChild( root );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::munder( TQDomElement element, TQDomNode docnode, bool oasisFormat )
|
|
{
|
|
bool accentunder;
|
|
|
|
TQString au = element.attribute( "accentunder" );
|
|
if ( au == "true" )
|
|
accentunder = true;
|
|
else if ( au == "false" )
|
|
accentunder = false;
|
|
else {
|
|
// use default
|
|
|
|
TQDomElement mo;
|
|
// is underscript an embellished operator?
|
|
if ( isEmbellishedOperator( element.childNodes().item( 1 ), &mo, oasisFormat ) ) {
|
|
if ( mo.attribute( "accent" ) == "true" )
|
|
accentunder = true;
|
|
else
|
|
accentunder = false;
|
|
}
|
|
else
|
|
accentunder = false;
|
|
}
|
|
|
|
TQDomNode n = element.firstChild();
|
|
int i = 0;
|
|
TQDomElement root = doc.createElement( "INDEX" );
|
|
|
|
while ( !n.isNull() && i < 2 ) {
|
|
if ( n.isElement() ) {
|
|
++i;
|
|
if ( i == 1 ) { // first is content (base)
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
|
|
root.appendChild( content );
|
|
}
|
|
else { // underscript
|
|
MathStyle previousStyle( style );
|
|
style.displaystyle = false;
|
|
if ( !accentunder ) {
|
|
style.scriptlevel += 1;
|
|
style.styleChange();
|
|
}
|
|
|
|
TQDomElement mo; TQDomElement index;
|
|
if ( isEmbellishedOperator( n.previousSibling(), &mo, oasisFormat ) &&
|
|
!previousStyle.displaystyle &&
|
|
mo.attribute( "movablelimits" ) == "true" )
|
|
{
|
|
index = doc.createElement( "LOWERRIGHT" );
|
|
}
|
|
else {
|
|
index = doc.createElement( "LOWERMIDDLE" );
|
|
}
|
|
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
|
|
style = previousStyle;
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<" << element.tagName() << "> child: "
|
|
<< n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
docnode.appendChild( root );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::mover( TQDomElement element, TQDomNode docnode, bool oasisFormat )
|
|
{
|
|
bool accent;
|
|
|
|
TQString ac = element.attribute( "accent" );
|
|
if ( ac == "true" )
|
|
accent = true;
|
|
else if ( ac == "false" )
|
|
accent = false;
|
|
else {
|
|
// use default
|
|
|
|
TQDomElement mo;
|
|
// is overscript an embellished operator?
|
|
if ( isEmbellishedOperator( element.childNodes().item( 1 ), &mo, oasisFormat ) ) {
|
|
if ( mo.attribute( "accent" ) == "true" )
|
|
accent = true;
|
|
else
|
|
accent = false;
|
|
}
|
|
else
|
|
accent = false;
|
|
}
|
|
|
|
TQDomNode n = element.firstChild();
|
|
int i = 0;
|
|
TQDomElement root = doc.createElement( "INDEX" );
|
|
|
|
while ( !n.isNull() && i < 2 ) {
|
|
if ( n.isElement() ) {
|
|
++i;
|
|
if ( i == 1 ) { // first is content (base)
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
|
|
root.appendChild( content );
|
|
}
|
|
else { // overscript
|
|
MathStyle previousStyle( style );
|
|
style.displaystyle = false;
|
|
if ( !accent ) {
|
|
style.scriptlevel += 1;
|
|
style.styleChange();
|
|
}
|
|
|
|
TQDomElement mo; TQDomElement index;
|
|
if ( isEmbellishedOperator( n.previousSibling(), &mo, oasisFormat ) &&
|
|
!previousStyle.displaystyle &&
|
|
mo.attribute( "movablelimits" ) == "true" )
|
|
{
|
|
index = doc.createElement( "UPPERRIGHT" );
|
|
}
|
|
else {
|
|
index = doc.createElement( "UPPERMIDDLE" );
|
|
}
|
|
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
|
|
style = previousStyle;
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<" << element.tagName() << "> child: "
|
|
<< n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
docnode.appendChild( root );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::munderover( TQDomElement element, TQDomNode docnode, bool oasisFormat )
|
|
{
|
|
bool accent;
|
|
bool accentunder;
|
|
|
|
TQString value = element.attribute( "accentunder" );
|
|
if ( value == "true" )
|
|
accentunder = true;
|
|
else if ( value == "false" )
|
|
accentunder = false;
|
|
else {
|
|
// use default
|
|
|
|
TQDomElement mo;
|
|
// is underscript an embellished operator?
|
|
if ( isEmbellishedOperator( element.childNodes().item( 1 ), &mo, oasisFormat ) ) {
|
|
if ( mo.attribute( "accent" ) == "true" )
|
|
accentunder = true;
|
|
else
|
|
accentunder = false;
|
|
}
|
|
else
|
|
accentunder = false;
|
|
}
|
|
value = element.attribute( "accent" );
|
|
if ( value == "true" )
|
|
accent = true;
|
|
else if ( value == "false" )
|
|
accent = false;
|
|
else {
|
|
// use default
|
|
|
|
TQDomElement mo;
|
|
// is overscript an embellished operator?
|
|
if ( isEmbellishedOperator( element.childNodes().item( 2 ), &mo,oasisFormat ) ) {
|
|
kdDebug( DEBUGID ) << "embellished operator" << endl;
|
|
if ( mo.attribute( "accent" ) == "true" )
|
|
accent = true;
|
|
else
|
|
accent = false;
|
|
}
|
|
else
|
|
accent = false;
|
|
}
|
|
kdDebug( DEBUGID ) << "munderover:\n accentunder = " << accentunder
|
|
<< "\n accent = " << accent << endl;
|
|
|
|
TQDomNode n = element.firstChild();
|
|
int i = 0;
|
|
TQDomElement root = doc.createElement( "INDEX" );
|
|
|
|
while ( !n.isNull() && i < 3 ) {
|
|
if ( n.isElement() ) {
|
|
++i;
|
|
if ( i == 1 ) { // base
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
|
|
root.appendChild( content );
|
|
}
|
|
else if ( i == 2 ) { // underscript
|
|
MathStyle previousStyle( style );
|
|
style.displaystyle = false;
|
|
if ( !accentunder ) {
|
|
style.scriptlevel += 1;
|
|
style.styleChange();
|
|
}
|
|
|
|
TQDomElement mo; TQDomElement index;
|
|
// is the base an embellished operator?
|
|
if ( isEmbellishedOperator( element.firstChild(), &mo, oasisFormat ) &&
|
|
!previousStyle.displaystyle &&
|
|
mo.attribute( "movablelimits" ) == "true" )
|
|
{
|
|
index = doc.createElement( "LOWERRIGHT" );
|
|
}
|
|
else {
|
|
index = doc.createElement( "LOWERMIDDLE" );
|
|
}
|
|
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
|
|
style = previousStyle;
|
|
}
|
|
else { // overscript
|
|
MathStyle previousStyle( style );
|
|
style.displaystyle = false;
|
|
if ( !accent ) {
|
|
style.scriptlevel += 1;
|
|
style.styleChange();
|
|
}
|
|
|
|
TQDomElement mo; TQDomElement index;
|
|
if ( isEmbellishedOperator( element.firstChild(), &mo, oasisFormat ) &&
|
|
!previousStyle.displaystyle &&
|
|
mo.attribute( "movablelimits" ) == "true" )
|
|
{
|
|
index = doc.createElement( "UPPERRIGHT" );
|
|
}
|
|
else {
|
|
index = doc.createElement( "UPPERMIDDLE" );
|
|
}
|
|
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
|
|
style = previousStyle;
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<" << element.tagName() << "> child: "
|
|
<< n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
docnode.appendChild( root );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::msubsup( TQDomElement element, TQDomNode docnode )
|
|
{
|
|
TQDomNode n = element.firstChild();
|
|
int i = 0;
|
|
TQDomElement root = doc.createElement("INDEX");
|
|
MathStyle previousStyle( style );
|
|
|
|
while ( !n.isNull() && i < 2 ) {
|
|
if ( n.isElement() ) {
|
|
++i;
|
|
if ( i == 1 ) { // base
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
content.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
|
|
root.appendChild( content );
|
|
}
|
|
else if ( i == 2 ) { // subscript
|
|
style.scriptlevel += 1;
|
|
style.displaystyle = false;
|
|
style.styleChange();
|
|
|
|
TQDomElement index;
|
|
index = doc.createElement( "LOWERRIGHT" );
|
|
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
}
|
|
else { // superscript
|
|
TQDomElement index;
|
|
index = doc.createElement( "UPPERRIGHT" );
|
|
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
index.appendChild( sequence );
|
|
TQDomElement e = n.toElement();
|
|
filter->processElement( e, doc, sequence );
|
|
root.appendChild( index );
|
|
|
|
style = previousStyle;
|
|
|
|
}
|
|
}
|
|
else {
|
|
kdDebug( DEBUGID ) << "<msubsup> child: " << n.nodeName() << endl;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
docnode.appendChild( root );
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::createTextElements( TQString text, TQDomNode docnode )
|
|
{
|
|
for ( uint i = 0; i < text.length(); ++i ) {
|
|
TQDomElement textelement = doc.createElement( "TEXT" );
|
|
textelement.setAttribute( "CHAR", TQString( text.at( i ) ) );
|
|
style.setStyles( textelement );
|
|
if ( context.symbolTable().inTable( text.at( i ) ) ) {
|
|
// The element is a symbol.
|
|
textelement.setAttribute( "SYMBOL", "3" );
|
|
}
|
|
docnode.appendChild( textelement );
|
|
}
|
|
}
|
|
|
|
void MathML2KFormulaPrivate::createNameSequence( TQString text, TQDomNode docnode )
|
|
{
|
|
TQDomElement namesequence = doc.createElement( "NAMESEQUENCE" );
|
|
for ( uint i = 0; i < text.length(); ++i ) {
|
|
TQDomElement textelement = doc.createElement( "TEXT" );
|
|
textelement.setAttribute( "CHAR", TQString( text.at( i ) ) );
|
|
style.setStyles( textelement );
|
|
if ( context.symbolTable().inTable( text.at( i ) ) ) {
|
|
// The element is a symbol.
|
|
textelement.setAttribute( "SYMBOL", "3" );
|
|
}
|
|
namesequence.appendChild( textelement );
|
|
}
|
|
docnode.appendChild( namesequence );
|
|
}
|
|
|
|
double MathML2KFormulaPrivate::convertToPoint( TQString value, bool* ok )
|
|
{
|
|
double pt = 0;
|
|
|
|
if ( value.endsWith( "em" ) ) {
|
|
// See MathML specification, Appendix H
|
|
pt = context.getDefaultFont().pointSize();
|
|
if ( pt == -1 ) {
|
|
TQFontMetrics fm( context.getDefaultFont() );
|
|
pt = fm.width( 'M' );
|
|
// PIXELS!
|
|
}
|
|
pt = pt * value.remove( value.length() - 2, 2 ).toDouble( ok );
|
|
}
|
|
else if ( value.endsWith( "ex" ) ) {
|
|
TQFontMetrics fm( context.getDefaultFont() );
|
|
pt = fm.height();
|
|
// PIXELS, and totally wrong!
|
|
}
|
|
else if ( value.endsWith( "px" ) ) {
|
|
pt = value.remove( value.length() - 2, 2 ).toDouble( ok );
|
|
// PIXELS!
|
|
}
|
|
else if ( value.endsWith( "in" ) ) {
|
|
pt = value.remove( value.length() - 2, 2 ).toDouble( ok );
|
|
pt *= 72;
|
|
}
|
|
else if ( value.endsWith( "cm" ) ) {
|
|
pt = value.remove( value.length() - 2, 2 ).toDouble( ok );
|
|
pt *= 1/2.54 * 72;
|
|
}
|
|
else if ( value.endsWith( "mm" ) ) {
|
|
pt = value.remove( value.length() - 2, 2 ).toDouble( ok );
|
|
pt *= 1/25.4 * 72;
|
|
}
|
|
else if ( value.endsWith( "pt" ) ) {
|
|
pt = value.remove( value.length() - 2, 2 ).toDouble( ok );
|
|
}
|
|
else if ( value.endsWith( "pc" ) ) {
|
|
pt = value.remove( value.length() - 2, 2 ).toDouble( ok );
|
|
pt /= 12;
|
|
}
|
|
else {
|
|
pt = value.toDouble( ok );
|
|
}
|
|
|
|
return pt;
|
|
}
|
|
|
|
bool MathML2KFormulaPrivate::isEmbellishedOperator( TQDomNode node,
|
|
TQDomElement* mo, bool oasisFormat )
|
|
{
|
|
// See MathML 2.0 specification: 3.2.5.7
|
|
|
|
if ( !node.isElement() )
|
|
return false;
|
|
|
|
TQDomElement element = node.toElement();
|
|
TQString tag = element.tagName();
|
|
|
|
if ( tag == "mo" )
|
|
{
|
|
*mo = element;
|
|
return true;
|
|
}
|
|
if ( tag == "msub" || tag == "msup" || tag == "msubsup" ||
|
|
tag == "munder" || tag == "mover" || tag == "munderover" ||
|
|
tag == "mmultiscripts" || tag == "mfrac" || tag == "semantics" )
|
|
{
|
|
return isEmbellishedOperator( element.firstChild(), mo,oasisFormat );
|
|
}
|
|
if ( tag == "maction" )
|
|
{
|
|
return false; // not supported
|
|
}
|
|
if ( tag == "mrow" || tag == "mstyle" || tag == "mphantom" || tag == "mpadded" ) {
|
|
TQDomNode n = element.firstChild();
|
|
int i = 0;
|
|
|
|
while ( !n.isNull() ) {
|
|
if ( isEmbellishedOperator( n, mo,oasisFormat ) ) {
|
|
if ( ++i > 1 ) // one (only one) embellished operator
|
|
return false;
|
|
}
|
|
else if ( !isSpaceLike( n, oasisFormat ) ) { // zero or more space-like elements
|
|
return false;
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
return ( i == 1 );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MathML2KFormulaPrivate::isSpaceLike( TQDomNode node, bool oasisFormat )
|
|
{
|
|
// See MathML 2.0 specification: 3.2.7.3
|
|
|
|
if ( !node.isElement() )
|
|
return false;
|
|
|
|
TQDomElement element = node.toElement();
|
|
TQString tag = element.tagName();
|
|
|
|
if ( tag == "mtext" || tag == "mspace" ||
|
|
tag == "maligngroup" || tag == "malignmark" ) {
|
|
return true;
|
|
}
|
|
if ( tag == "mstyle" || tag == "mphantom" || tag == "mpadded" || tag == "mrow" ) {
|
|
TQDomNode n = element.firstChild();
|
|
while ( !n.isNull() ) {
|
|
if ( isSpaceLike( n,oasisFormat ) )
|
|
n = n.nextSibling();
|
|
else
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if ( tag == "maction" ) {
|
|
return false; // not supported
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
MathML2KFormula::MathML2KFormula( const TQDomDocument& mmldoc, const ContextStyle &contextStyle, bool _oasisFormat )
|
|
: m_error( false ), oasisFormat( _oasisFormat ), context( contextStyle )
|
|
{
|
|
orig_element = mmldoc.documentElement();
|
|
done = false;
|
|
}
|
|
|
|
MathML2KFormula::MathML2KFormula( const TQDomElement& mmlelm, const ContextStyle &contextStyle, bool _oasisFormat )
|
|
: m_error( false ), orig_element( mmlelm ), oasisFormat( _oasisFormat ), context( contextStyle )
|
|
{
|
|
done = false;
|
|
}
|
|
|
|
TQDomDocument MathML2KFormula::getKFormulaDom()
|
|
{
|
|
return formuladoc;
|
|
}
|
|
|
|
|
|
|
|
void MathML2KFormula::startConversion()
|
|
{
|
|
//TODO:let it be async
|
|
//kdDebug() << origdoc.toString() << endl;
|
|
done = false;
|
|
formuladoc = TQDomDocument( "KFORMULA" );
|
|
impl = new MathML2KFormulaPrivate( this, context, formuladoc );
|
|
if ( orig_element.tagName() == "math" ) {
|
|
impl->math( orig_element );
|
|
m_error = false;
|
|
}
|
|
else {
|
|
kdError() << "Not a MathML document!" << endl;
|
|
KMessageBox::error( 0, i18n( "The document does not seem to be MathML." ), i18n( "MathML Import Error" ) );
|
|
m_error = true;
|
|
}
|
|
done = true;
|
|
}
|
|
|
|
bool MathML2KFormula::processElement( TQDomNode node, TQDomDocument& doc, TQDomNode docnode )
|
|
{
|
|
|
|
//TQDomElement *element;
|
|
Type type = UNKNOWN;
|
|
|
|
if ( node.isElement() ) {
|
|
TQDomElement element = node.toElement();
|
|
TQString tag = element.tagName();
|
|
|
|
if ( tag == "mi" ) {
|
|
type = TOKEN;
|
|
impl->mi( element, docnode );
|
|
}
|
|
else if ( tag == "mo" ) {
|
|
type = TOKEN;
|
|
impl->mo( element, docnode );
|
|
}
|
|
else if ( tag == "mn" ) {
|
|
type = TOKEN;
|
|
impl->mn( element, docnode );
|
|
}
|
|
else if ( tag == "mtext" ) {
|
|
type = TOKEN;
|
|
impl->mtext( element, docnode );
|
|
}
|
|
else if ( tag == "ms" ) {
|
|
type = TOKEN;
|
|
impl->ms( element, docnode );
|
|
}
|
|
else if ( tag == "mspace" ) {
|
|
type = TOKEN;
|
|
impl->mspace( element, docnode );
|
|
}
|
|
else if ( tag == "mrow" ) {
|
|
type = LAYOUT;
|
|
impl->mrow( element, docnode );
|
|
}
|
|
else if ( tag == "mfrac" ) {
|
|
type = LAYOUT;
|
|
impl->mfrac( element, docnode );
|
|
}
|
|
else if ( tag == "mroot" ) {
|
|
type = LAYOUT;
|
|
impl->mroot( element, docnode );
|
|
}
|
|
else if ( tag == "msqrt" ) {
|
|
type = LAYOUT;
|
|
impl->msqrt( element, docnode );
|
|
}
|
|
else if ( tag == "mstyle" ) {
|
|
type = LAYOUT;
|
|
impl->mstyle( element, docnode );
|
|
}
|
|
else if ( tag == "mfenced" ) {
|
|
type = LAYOUT;
|
|
impl->mfenced( element, docnode );
|
|
}
|
|
else if ( tag == "mtable" ) {
|
|
type = TABLE;
|
|
impl->mtable( element, docnode );
|
|
}
|
|
else if ( tag == "msub" || tag == "msup" ) {
|
|
type = SCRIPT;
|
|
impl->msub_msup( element, docnode );
|
|
}
|
|
else if ( tag == "munder" ) {
|
|
type = SCRIPT;
|
|
impl->munder( element, docnode,oasisFormat );
|
|
}
|
|
else if ( tag == "mover" ) {
|
|
type = SCRIPT;
|
|
impl->mover( element, docnode,oasisFormat );
|
|
}
|
|
else if ( tag == "munderover" ) {
|
|
type = SCRIPT;
|
|
impl->munderover( element, docnode, oasisFormat );
|
|
}
|
|
else if ( tag == "msubsup" ) {
|
|
type = SCRIPT;
|
|
impl->msubsup( element, docnode );
|
|
}
|
|
|
|
// content markup (not yet complete)
|
|
else if ( tag == "apply" ) {
|
|
type = CONTENT;
|
|
TQDomNode n = element.firstChild();
|
|
TQDomElement op = n.toElement();
|
|
uint count = element.childNodes().count();
|
|
//adding explicit brackets to replace "apply"s implicit ones
|
|
TQDomElement brackets = doc.createElement("BRACKET");
|
|
brackets.setAttribute("RIGHT", "41");
|
|
brackets.setAttribute("LEFT", "40");
|
|
TQDomElement content = doc.createElement("CONTENT");
|
|
brackets.appendChild(content);
|
|
TQDomElement base = doc.createElement("SEQUENCE");
|
|
content.appendChild(base);
|
|
docnode.appendChild(brackets);
|
|
//Arithmetic, Algebra and Logic operators status
|
|
// quotient X
|
|
// factorial O
|
|
// divide O
|
|
// max, min X
|
|
// minus O
|
|
// plus O
|
|
// power O
|
|
// rem X
|
|
// times O
|
|
// root X
|
|
// gcd X
|
|
// and O
|
|
// or O
|
|
// xor O
|
|
// not O
|
|
// implies O
|
|
// forall X
|
|
// exists X
|
|
// abs O
|
|
// conjugate X
|
|
// arg X
|
|
// real X
|
|
// imaginary X
|
|
// lcm X
|
|
// floor X
|
|
// ceiling X
|
|
|
|
// n-ary
|
|
if ( op.tagName() == "plus" || op.tagName() == "times" ||
|
|
op.tagName() == "and" || op.tagName() == "or" ||
|
|
op.tagName() == "xor" ) {
|
|
|
|
n = n.nextSibling();
|
|
bool first = true;
|
|
|
|
while ( !n.isNull() ) {
|
|
if ( n.isElement() ) {
|
|
if ( !first ) {
|
|
TQDomElement text = doc.createElement( "TEXT" );
|
|
TQString value;
|
|
|
|
if ( op.tagName() == "plus" )
|
|
value = "+";
|
|
else if ( op.tagName() == "times" )
|
|
value = "*";
|
|
else if ( op.tagName() == "and" )
|
|
value = "&";
|
|
else if ( op.tagName() == "or" )
|
|
value = "|";
|
|
else if ( op.tagName() == "xor" )
|
|
value = "^"; // ???
|
|
|
|
text.setAttribute( "CHAR", value ); //switch to createTextElements?
|
|
base.appendChild( text );
|
|
}
|
|
first = false;
|
|
TQDomElement e = n.toElement();
|
|
processElement( e, doc, base );
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
}
|
|
|
|
else if ( op.tagName() == "factorial" ) {
|
|
TQDomElement e = n.nextSibling().toElement();
|
|
processElement( e, doc, docnode );
|
|
impl->createTextElements( "!", base );
|
|
}
|
|
else if ( op.tagName() == "minus" ) {
|
|
n = n.nextSibling();
|
|
if ( count == 2 ) { // unary
|
|
impl->createTextElements( "-", base );
|
|
TQDomElement e = n.toElement();
|
|
processElement( e, doc, base );
|
|
}
|
|
else if ( count == 3 ) { // binary
|
|
TQDomElement e = n.toElement();
|
|
processElement( e, doc, base );
|
|
impl->createTextElements( "-", base );
|
|
n = n.nextSibling();
|
|
e = n.toElement();
|
|
processElement( e, doc, base );
|
|
}
|
|
}
|
|
|
|
else if ( op.tagName() == "divide" && count == 3 ) {
|
|
n = n.nextSibling();
|
|
TQDomElement e = n.toElement();
|
|
processElement( e, doc, base );
|
|
impl->createTextElements("/", base);
|
|
n = n.nextSibling();
|
|
e = n.toElement();
|
|
processElement( e, doc, base );
|
|
}
|
|
else if ( op.tagName() == "power" && count == 3 ) {
|
|
//code duplication of msub_sup(), but I can't find a way to cleanly call it
|
|
n = n.nextSibling();
|
|
TQDomElement e = n.toElement();
|
|
TQDomElement index = doc.createElement("INDEX");
|
|
base.appendChild(index);
|
|
TQDomElement content = doc.createElement("CONTENT");
|
|
index.appendChild(content);
|
|
TQDomElement sequence = doc.createElement("SEQUENCE");
|
|
content.appendChild(sequence);
|
|
processElement(e, doc, sequence);
|
|
TQDomElement upper = doc.createElement("UPPERRIGHT");
|
|
index.appendChild(upper);
|
|
sequence = doc.createElement("SEQUENCE");
|
|
upper.appendChild(sequence);
|
|
n = n.nextSibling();
|
|
e = n.toElement();
|
|
processElement(e, doc, sequence);
|
|
}
|
|
else if ( op.tagName() == "abs" && count == 2) {
|
|
n = n.nextSibling();
|
|
TQDomElement e = n.toElement();
|
|
TQDomElement bracket = doc.createElement("BRACKET");
|
|
bracket.setAttribute("RIGHT", "257");
|
|
bracket.setAttribute("LEFT", "256");
|
|
base.appendChild(bracket);
|
|
TQDomElement content = doc.createElement("CONTENT");
|
|
bracket.appendChild(content);
|
|
TQDomElement sequence = doc.createElement("SEQUENCE");
|
|
content.appendChild(sequence);
|
|
processElement(e, doc, sequence);
|
|
}
|
|
else if ( op.tagName() == "not" && count == 2) {
|
|
n = n.nextSibling();
|
|
TQDomElement e = n.toElement();
|
|
impl->createTextElements(TQString(TQChar(0xAC)), base);
|
|
processElement(e, doc, base);
|
|
}
|
|
else if ( op.tagName() == "implies" && count == 3 ) {
|
|
n = n.nextSibling();
|
|
TQDomElement e = n.toElement();
|
|
processElement( e, doc, base );
|
|
impl->createTextElements(TQString(TQChar(0x21D2)), base);
|
|
n = n.nextSibling();
|
|
e = n.toElement();
|
|
processElement( e, doc, base );
|
|
}
|
|
// many, many more...
|
|
|
|
}
|
|
|
|
else if ( tag == "cn" ) {
|
|
type = CONTENT;
|
|
TQString type = element.attribute( "type", "real" );
|
|
|
|
if ( type == "real" || type == "constant" ) {
|
|
impl->createTextElements( element.text().stripWhiteSpace(),
|
|
docnode );
|
|
}
|
|
else if ( type == "integer" ) {
|
|
TQString base = element.attribute( "base" );
|
|
if ( !base ) {
|
|
impl->createTextElements( element.text().stripWhiteSpace(),
|
|
docnode );
|
|
}
|
|
else {
|
|
TQDomElement index = doc.createElement( "INDEX" );
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
impl->createTextElements( element.text().stripWhiteSpace(),
|
|
sequence );
|
|
content.appendChild( sequence );
|
|
index.appendChild( content );
|
|
|
|
TQDomElement lowerright = doc.createElement( "LOWERRIGHT" );
|
|
sequence = doc.createElement( "SEQUENCE" );
|
|
|
|
impl->createTextElements( base, sequence );
|
|
|
|
lowerright.appendChild( sequence );
|
|
index.appendChild( lowerright );
|
|
|
|
docnode.appendChild( index );
|
|
}
|
|
}
|
|
else if ( type == "rational" ) {
|
|
TQDomNode n = element.firstChild();
|
|
impl->createTextElements( n.toText().data().stripWhiteSpace(),
|
|
docnode );
|
|
|
|
n = n.nextSibling(); // <sep/>
|
|
impl->createTextElements( "/", docnode );
|
|
|
|
n = n.nextSibling();
|
|
impl->createTextElements( n.toText().data().stripWhiteSpace(),
|
|
docnode );
|
|
}
|
|
else if ( type == "complex-cartesian" ) {
|
|
TQDomNode n = element.firstChild();
|
|
impl->createTextElements( n.toText().data().stripWhiteSpace(),
|
|
docnode );
|
|
|
|
n = n.nextSibling(); // <sep/>
|
|
impl->createTextElements( "+", docnode );
|
|
|
|
n = n.nextSibling();
|
|
impl->createTextElements( n.toText().data().stripWhiteSpace(),
|
|
docnode );
|
|
|
|
impl->createTextElements( "i", docnode );
|
|
}
|
|
|
|
else if ( type == "complex-polar" ) {
|
|
TQDomNode n = element.firstChild();
|
|
impl->createTextElements( n.toText().data().stripWhiteSpace(),
|
|
docnode );
|
|
|
|
n = n.nextSibling(); // <sep/>
|
|
TQDomElement index = doc.createElement( "INDEX" );
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
TQDomElement textelement = doc.createElement( "TEXT" );
|
|
textelement.setAttribute( "CHAR", "e" );
|
|
sequence.appendChild( textelement );
|
|
content.appendChild( sequence );
|
|
index.appendChild( content );
|
|
|
|
TQDomElement upperright = doc.createElement( "UPPERRIGHT" );
|
|
sequence = doc.createElement( "SEQUENCE" );
|
|
textelement = doc.createElement( "TEXT" );
|
|
textelement.setAttribute( "CHAR", "i" );
|
|
sequence.appendChild( textelement );
|
|
|
|
n = n.nextSibling();
|
|
impl->createTextElements( n.toText().data().stripWhiteSpace(),
|
|
sequence );
|
|
|
|
upperright.appendChild( sequence );
|
|
index.appendChild( upperright );
|
|
|
|
docnode.appendChild( index );
|
|
}
|
|
}
|
|
|
|
else if ( tag == "ci" ) {
|
|
type = CONTENT;
|
|
TQDomNode n = element.firstChild();
|
|
|
|
if ( n.isText() ) {
|
|
impl->createTextElements( n.toText().data().stripWhiteSpace(),
|
|
docnode );
|
|
}
|
|
else if ( n.isElement() ) {
|
|
TQDomElement e = n.toElement();
|
|
processElement( e, doc, docnode );
|
|
}
|
|
else if ( n.isEntityReference() ) {
|
|
kdDebug( DEBUGID ) << "isEntityReference: "
|
|
<< n.toEntityReference().nodeName().latin1()
|
|
<< endl;
|
|
}
|
|
else
|
|
kdDebug( DEBUGID ) << "ci: " << n.nodeName().latin1() << endl;
|
|
}
|
|
|
|
else if ( tag == "list" ) {
|
|
type = CONTENT;
|
|
TQDomNode n = element.firstChild();
|
|
|
|
TQDomElement bracket = doc.createElement( "BRACKET" );
|
|
bracket.setAttribute( "LEFT", 91 ); // [
|
|
bracket.setAttribute( "RIGHT", 93 ); // ]
|
|
TQDomElement content = doc.createElement( "CONTENT" );
|
|
TQDomElement sequence = doc.createElement( "SEQUENCE" );
|
|
|
|
bool first = true;
|
|
|
|
while ( !n.isNull() ) {
|
|
if ( n.isElement() ) {
|
|
if ( !first ) {
|
|
TQDomElement textelement = doc.createElement( "TEXT" );
|
|
textelement.setAttribute( "CHAR", "," );
|
|
sequence.appendChild( textelement );
|
|
}
|
|
first = false;
|
|
TQDomElement e = n.toElement();
|
|
processElement( e, doc, sequence );
|
|
}
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
content.appendChild( sequence );
|
|
bracket.appendChild( content );
|
|
docnode.appendChild( bracket );
|
|
}
|
|
}
|
|
|
|
if ( type == UNKNOWN && node.nodeType() != TQDomNode::AttributeNode ) {
|
|
kdDebug() << "Not an element: " << node.nodeName() << endl;
|
|
TQDomNode n = node.firstChild();
|
|
while ( !n.isNull() ) {
|
|
processElement( n, doc, docnode );
|
|
n = n.nextSibling();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
KFORMULA_NAMESPACE_END
|
|
|
|
using namespace KFormula;
|
|
#include "kformulamathmlread.moc"
|