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/lib/kformula/fractionelement.cc

658 lines
20 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 <tqpainter.h>
#include <kdebug.h>
#include <tdelocale.h>
#include "elementvisitor.h"
#include "formulaelement.h"
#include "formulacursor.h"
#include "fractionelement.h"
#include "sequenceelement.h"
KFORMULA_NAMESPACE_BEGIN
using namespace std;
FractionElement::FractionElement(BasicElement* parent) : BasicElement(parent),
m_lineThicknessType( NoSize ),
m_numAlign( NoHorizontalAlign ),
m_denomAlign( NoHorizontalAlign ),
m_customBevelled( false )
{
numerator = new SequenceElement(this);
denominator = new SequenceElement(this);
}
FractionElement::~FractionElement()
{
delete denominator;
delete numerator;
}
FractionElement::FractionElement( const FractionElement& other )
: BasicElement( other ),
m_lineThicknessType( other.m_lineThicknessType ),
m_lineThickness( other.m_lineThickness ),
m_numAlign( other.m_numAlign ),
m_denomAlign( other.m_denomAlign ),
m_customBevelled( other.m_customBevelled ),
m_bevelled( other.m_bevelled )
{
numerator = new SequenceElement( *( other.numerator ) );
denominator = new SequenceElement( *( other.denominator ) );
numerator->setParent( this );
denominator->setParent( this );
}
bool FractionElement::accept( ElementVisitor* visitor )
{
return visitor->visit( this );
}
void FractionElement::entered( SequenceElement* child )
{
if ( child == numerator ) {
formula()->tell( i18n( "Numerator" ) );
}
else {
formula()->tell( i18n( "Denominator" ) );
}
}
BasicElement* FractionElement::goToPos( FormulaCursor* cursor, bool& handled,
const LuPixelPoint& point, const LuPixelPoint& parentOrigin )
{
BasicElement* e = BasicElement::goToPos(cursor, handled, point, parentOrigin);
if (e != 0) {
LuPixelPoint myPos(parentOrigin.x() + getX(),
parentOrigin.y() + getY());
e = numerator->goToPos(cursor, handled, point, myPos);
if (e != 0) {
return e;
}
e = denominator->goToPos(cursor, handled, point, myPos);
if (e != 0) {
return e;
}
luPixel dx = point.x() - myPos.x();
luPixel dy = point.y() - myPos.y();
// the positions after the numerator / denominator
if ((dx > numerator->getX()) &&
(dy < numerator->getHeight())) {
numerator->moveLeft(cursor, this);
handled = true;
return numerator;
}
else if ((dx > denominator->getX()) &&
(dy > denominator->getY())) {
denominator->moveLeft(cursor, this);
handled = true;
return denominator;
}
return this;
}
return 0;
}
/**
* Calculates our width and height and
* our children's parentPosition.
*/
void FractionElement::calcSizes( const ContextStyle& context,
ContextStyle::TextStyle tstyle,
ContextStyle::IndexStyle istyle,
StyleAttributes& style )
{
ContextStyle::TextStyle i_tstyle = context.convertTextStyleFraction( tstyle );
ContextStyle::IndexStyle u_istyle = context.convertIndexStyleUpper( istyle );
ContextStyle::IndexStyle l_istyle = context.convertIndexStyleLower( istyle );
double factor = style.sizeFactor();
numerator->calcSizes( context, i_tstyle, u_istyle, style );
denominator->calcSizes( context, i_tstyle, l_istyle, style );
luPixel distY = context.ptToPixelY( context.getThinSpace( tstyle, factor ) );
double linethickness = lineThickness( context, factor );
setWidth( TQMAX( numerator->getWidth(), denominator->getWidth() ) );
setHeight( numerator->getHeight() + denominator->getHeight() +
2*distY + linethickness );
setBaseline( tqRound( numerator->getHeight() + distY + .5*linethickness
+ context.axisHeight( tstyle, factor ) ) );
numerator->setX( ( getWidth() - numerator->getWidth() ) / 2 );
denominator->setX( ( getWidth() - denominator->getWidth() ) / 2 );
numerator->setY( 0 );
denominator->setY( getHeight() - denominator->getHeight() );
}
/**
* Draws the whole element including its children.
* The `parentOrigin' is the point this element's parent starts.
* We can use our parentPosition to get our own origin then.
*/
void FractionElement::draw( TQPainter& painter, const LuPixelRect& r,
const ContextStyle& context,
ContextStyle::TextStyle tstyle,
ContextStyle::IndexStyle istyle,
StyleAttributes& style,
const LuPixelPoint& parentOrigin )
{
LuPixelPoint myPos( parentOrigin.x()+getX(), parentOrigin.y()+getY() );
//if ( !LuPixelRect( myPos.x(), myPos.y(), getWidth(), getHeight() ).intersects( r ) )
// return;
numerator->draw( painter, r, context,
context.convertTextStyleFraction( tstyle ),
context.convertIndexStyleUpper( istyle ), style, myPos);
if (denominator) { // Can be temporarily 0 see FractionElement::remove
denominator->draw( painter, r, context,
context.convertTextStyleFraction( tstyle ),
context.convertIndexStyleLower( istyle ), style,
myPos);
}
if ( withLine() ) {
// TODO: thickness
double factor = style.sizeFactor();
double linethickness = lineThickness( context, factor );
painter.setPen( TQPen( style.color(),
context.layoutUnitToPixelY( linethickness ) ) );
painter.drawLine( context.layoutUnitToPixelX( myPos.x() ),
context.layoutUnitToPixelY( myPos.y() + axis( context, tstyle, factor ) ),
context.layoutUnitToPixelX( myPos.x() + getWidth() ),
context.layoutUnitToPixelY( myPos.y() + axis( context, tstyle, factor ) ) );
}
}
void FractionElement::dispatchFontCommand( FontCommand* cmd )
{
numerator->dispatchFontCommand( cmd );
denominator->dispatchFontCommand( cmd );
}
/**
* Enters this element while moving to the left starting inside
* the element `from'. Searches for a cursor position inside
* this element or to the left of it.
*/
void FractionElement::moveLeft(FormulaCursor* cursor, BasicElement* from)
{
if (cursor->isSelectionMode()) {
getParent()->moveLeft(cursor, this);
}
else {
bool linear = cursor->getLinearMovement();
if (from == getParent()) {
if (linear) {
denominator->moveLeft(cursor, this);
}
else {
numerator->moveLeft(cursor, this);
}
}
else if (from == denominator) {
numerator->moveLeft(cursor, this);
}
else {
getParent()->moveLeft(cursor, this);
}
}
}
/**
* Enters this element while moving to the right starting inside
* the element `from'. Searches for a cursor position inside
* this element or to the right of it.
*/
void FractionElement::moveRight(FormulaCursor* cursor, BasicElement* from)
{
if (cursor->isSelectionMode()) {
getParent()->moveRight(cursor, this);
}
else {
bool linear = cursor->getLinearMovement();
if (from == getParent()) {
numerator->moveRight(cursor, this);
}
else if (from == numerator) {
if (linear) {
denominator->moveRight(cursor, this);
}
else {
getParent()->moveRight(cursor, this);
}
}
else {
getParent()->moveRight(cursor, this);
}
}
}
/**
* Enters this element while moving up starting inside
* the element `from'. Searches for a cursor position inside
* this element or above it.
*/
void FractionElement::moveUp(FormulaCursor* cursor, BasicElement* from)
{
if (cursor->isSelectionMode()) {
getParent()->moveUp(cursor, this);
}
else {
if (from == getParent()) {
denominator->moveRight(cursor, this);
}
else if (from == denominator) {
numerator->moveRight(cursor, this);
}
else {
getParent()->moveUp(cursor, this);
}
}
}
/**
* Enters this element while moving down starting inside
* the element `from'. Searches for a cursor position inside
* this element or below it.
*/
void FractionElement::moveDown(FormulaCursor* cursor, BasicElement* from)
{
if (cursor->isSelectionMode()) {
getParent()->moveDown(cursor, this);
}
else {
if (from == getParent()) {
numerator->moveRight(cursor, this);
}
else if (from == numerator) {
denominator->moveRight(cursor, this);
}
else {
getParent()->moveDown(cursor, this);
}
}
}
/**
* Reinserts the denominator if it has been removed.
*/
void FractionElement::insert(FormulaCursor* cursor,
TQPtrList<BasicElement>& newChildren,
Direction direction)
{
if (cursor->getPos() == denominatorPos) {
denominator = static_cast<SequenceElement*>(newChildren.take(0));
denominator->setParent(this);
if (direction == beforeCursor) {
denominator->moveLeft(cursor, this);
}
else {
denominator->moveRight(cursor, this);
}
cursor->setSelection(false);
formula()->changed();
}
}
/**
* Removes all selected children and returns them. Places the
* cursor to where the children have been.
*
* We remove ourselve if we are requested to remove our numerator.
*
* It is possible to remove the denominator. But after this we
* are senseless and the caller is required to replace us.
*/
void FractionElement::remove(FormulaCursor* cursor,
TQPtrList<BasicElement>& removedChildren,
Direction direction)
{
switch (cursor->getPos()) {
case numeratorPos:
getParent()->selectChild(cursor, this);
getParent()->remove(cursor, removedChildren, direction);
break;
case denominatorPos:
removedChildren.append(denominator);
formula()->elementRemoval(denominator);
denominator = 0;
cursor->setTo(this, denominatorPos);
formula()->changed();
break;
}
}
/**
* Returns wether the element has no more useful
* children (except its main child) and should therefore
* be replaced by its main child's content.
*/
bool FractionElement::isSenseless()
{
return denominator == 0;
}
// main child
//
// If an element has children one has to become the main one.
SequenceElement* FractionElement::getMainChild()
{
return numerator;
}
// void FractionElement::setMainChild(SequenceElement* child)
// {
// formula()->elementRemoval(numerator);
// numerator = child;
// numerator->setParent(this);
// formula()->changed();
// }
/**
* Sets the cursor to select the child. The mark is placed before,
* the position behind it.
*/
void FractionElement::selectChild(FormulaCursor* cursor, BasicElement* child)
{
if (child == numerator) {
cursor->setTo(this, numeratorPos);
}
else if (child == denominator) {
cursor->setTo(this, denominatorPos);
}
}
/**
* Appends our attributes to the dom element.
*/
void FractionElement::writeDom(TQDomElement element)
{
BasicElement::writeDom(element);
TQDomDocument doc = element.ownerDocument();
if (!withLine()) element.setAttribute("NOLINE", 1);
TQDomElement num = doc.createElement("NUMERATOR");
num.appendChild(numerator->getElementDom(doc));
element.appendChild(num);
TQDomElement den = doc.createElement("DENOMINATOR");
den.appendChild(denominator->getElementDom(doc));
element.appendChild(den);
}
/**
* Reads our attributes from the element.
* Returns false if it failed.
*/
bool FractionElement::readAttributesFromDom(TQDomElement element)
{
if (!BasicElement::readAttributesFromDom(element)) {
return false;
}
TQString lineStr = element.attribute("NOLINE");
if(!lineStr.isNull()) {
m_lineThicknessType = RelativeSize;
m_lineThickness = lineStr.toInt();
}
return true;
}
/**
* Reads our attributes from the MathML element.
* Returns false if it failed.
*/
bool FractionElement::readAttributesFromMathMLDom(const TQDomElement& element)
{
if ( ! BasicElement::readAttributesFromMathMLDom( element ) ) {
return false;
}
TQString linethicknessStr = element.attribute( "linethickness" ).lower();
if ( ! linethicknessStr.isNull() ) {
if ( linethicknessStr == "thin" ) {
m_lineThicknessType = RelativeSize;
m_lineThickness = 0.5; // ### Arbitrary size
}
else if ( linethicknessStr == "medium" ) {
m_lineThicknessType = RelativeSize;
m_lineThickness = 1.0;
}
else if ( linethicknessStr == "thick" ) {
m_lineThicknessType = RelativeSize;
m_lineThickness = 2.0; // ### Arbitrary size
}
else {
m_lineThickness = getSize( linethicknessStr, &m_lineThicknessType );
}
}
TQString numalignStr = element.attribute( "numalign" ).lower();
if ( ! numalignStr.isNull() ) {
if ( numalignStr == "left" ) {
m_numAlign = LeftHorizontalAlign;
}
else if ( numalignStr == "center" ) {
m_numAlign = CenterHorizontalAlign;
}
else if ( numalignStr == "right" ) {
m_numAlign = RightHorizontalAlign;
}
}
TQString denomalignStr = element.attribute( "denomalign" ).lower();
if ( ! denomalignStr.isNull() ) {
if ( denomalignStr == "left" ) {
m_denomAlign = LeftHorizontalAlign;
}
else if ( denomalignStr == "center" ) {
m_denomAlign = CenterHorizontalAlign;
}
else if ( denomalignStr == "right" ) {
m_denomAlign = RightHorizontalAlign;
}
}
TQString bevelledStr = element.attribute( "bevelled" ).lower();
if ( ! bevelledStr.isNull() ) {
m_customBevelled = true;
if ( bevelledStr == "true" ) {
m_bevelled = true;
}
else {
m_bevelled = false;
}
}
return true;
}
/**
* Reads our content from the node. Sets the node to the next node
* that needs to be read.
* Returns false if it failed.
*/
bool FractionElement::readContentFromDom(TQDomNode& node)
{
if (!BasicElement::readContentFromDom(node)) {
return false;
}
if ( !buildChild( numerator, node, "NUMERATOR" ) ) {
kdWarning( DEBUGID ) << "Empty numerator in FractionElement." << endl;
return false;
}
node = node.nextSibling();
if ( !buildChild( denominator, node, "DENOMINATOR" ) ) {
kdWarning( DEBUGID ) << "Empty denominator in FractionElement." << endl;
return false;
}
node = node.nextSibling();
return true;
}
/**
* Reads our content from the MathML node. Sets the node to the next node
* that needs to be read.
* Returns false if it failed.
*/
int FractionElement::readContentFromMathMLDom(TQDomNode& node)
{
if ( BasicElement::readContentFromMathMLDom( node ) == -1 ) {
return -1;
}
int numeratorNumber = numerator->buildMathMLChild( node );
if ( numeratorNumber == -1 ) {
kdWarning( DEBUGID ) << "Empty numerator in FractionElement." << endl;
return -1;
}
for (int i = 0; i < numeratorNumber; i++ ) {
if ( node.isNull() ) {
return -1;
}
node = node.nextSibling();
}
if ( denominator->buildMathMLChild( node ) == -1 ) {
kdWarning( DEBUGID ) << "Empty denominator in FractionElement." << endl;
return -1;
}
return 1;
}
TQString FractionElement::toLatex()
{
if ( withLine() ) {
return "\\frac{" + numerator->toLatex() +"}{" + denominator->toLatex() + "}";
}
else {
return "{" + numerator->toLatex() + "\\atop " + denominator->toLatex() + "}";
}
}
TQString FractionElement::formulaString()
{
return "(" + numerator->formulaString() + ")/(" + denominator->formulaString() + ")";
}
void FractionElement::writeMathMLAttributes( TQDomElement& element ) const
{
switch ( m_lineThicknessType ) {
case AbsoluteSize:
element.setAttribute( "linethickness", TQString( "%1pt" ).arg( m_lineThickness ) );
break;
case RelativeSize:
element.setAttribute( "linethickness", TQString( "%1%" ).arg( m_lineThickness * 100.0 ) );
break;
case PixelSize:
element.setAttribute( "linethickness", TQString( "%1px" ).arg( m_lineThickness ) );
break;
default:
break;
}
switch ( m_numAlign ) {
case LeftHorizontalAlign:
element.setAttribute( "numalign", "left" );
break;
case CenterHorizontalAlign:
element.setAttribute( "numalign", "center" );
break;
case RightHorizontalAlign:
element.setAttribute( "numalign", "right" );
break;
default:
break;
}
switch ( m_denomAlign ) {
case LeftHorizontalAlign:
element.setAttribute( "denomalign", "left" );
break;
case CenterHorizontalAlign:
element.setAttribute( "denomalign", "center" );
break;
case RightHorizontalAlign:
element.setAttribute( "denomalign", "right" );
break;
default:
break;
}
if ( m_customBevelled ) {
element.setAttribute( "bevelled", m_bevelled ? "true" : "false" );
}
}
void FractionElement::writeMathMLContent( TQDomDocument& doc,
TQDomElement& element,
bool oasisFormat ) const
{
numerator->writeMathML( doc, element, oasisFormat );
denominator->writeMathML( doc, element, oasisFormat );
}
double FractionElement::lineThickness( const ContextStyle& context, double factor )
{
double linethickness = context.getLineWidth( factor );
switch ( m_lineThicknessType ) {
case AbsoluteSize:
linethickness = context.ptToLayoutUnitPixX( m_lineThickness );
break;
case RelativeSize:
linethickness *= m_lineThickness;
break;
case PixelSize:
linethickness = m_lineThickness;
break;
default:
break;
}
return linethickness;
}
KFORMULA_NAMESPACE_END