summaryrefslogtreecommitdiffstats
path: root/lib/kformula/rootelement.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lib/kformula/rootelement.cpp')
-rw-r--r--lib/kformula/rootelement.cpp680
1 files changed, 680 insertions, 0 deletions
diff --git a/lib/kformula/rootelement.cpp b/lib/kformula/rootelement.cpp
new file mode 100644
index 00000000..5e511cbe
--- /dev/null
+++ b/lib/kformula/rootelement.cpp
@@ -0,0 +1,680 @@
+/* This file is part of the KDE project
+ Copyright (C) 2001 Andrea Rizzi <[email protected]>
+ Ulrich Kuettler <[email protected]>
+
+ 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 <tqpen.h>
+
+#include <kdebug.h>
+#include <tdelocale.h>
+
+#include "elementvisitor.h"
+#include "formulacursor.h"
+#include "formulaelement.h"
+#include "kformulacommand.h"
+#include "rootelement.h"
+#include "sequenceelement.h"
+
+KFORMULA_NAMESPACE_BEGIN
+
+
+class RootSequenceElement : public SequenceElement {
+ typedef SequenceElement inherited;
+public:
+
+ RootSequenceElement( BasicElement* parent = 0 ) : SequenceElement( parent ) {}
+ virtual RootSequenceElement* clone() {
+ return new RootSequenceElement( *this );
+ }
+
+ /**
+ * This is called by the container to get a command depending on
+ * the current cursor position (this is how the element gets chosen)
+ * and the request.
+ *
+ * @returns the command that performs the requested action with
+ * the containers active cursor.
+ */
+ virtual KCommand* buildCommand( Container*, Request* );
+};
+
+
+KCommand* RootSequenceElement::buildCommand( Container* container, Request* request )
+{
+ FormulaCursor* cursor = container->activeCursor();
+ if ( cursor->isReadOnly() ) {
+ return 0;
+ }
+
+ switch ( *request ) {
+ case req_addIndex: {
+ FormulaCursor* cursor = container->activeCursor();
+ if ( cursor->isSelection() ||
+ ( cursor->getPos() > 0 && cursor->getPos() < countChildren() ) ) {
+ break;
+ }
+ IndexRequest* ir = static_cast<IndexRequest*>( request );
+ if ( ir->index() == upperLeftPos ) {
+ RootElement* element = static_cast<RootElement*>( getParent() );
+ ElementIndexPtr index = element->getIndex();
+ if ( !index->hasIndex() ) {
+ KFCAddGenericIndex* command = new KFCAddGenericIndex( container, index );
+ return command;
+ }
+ else {
+ index->moveToIndex( cursor, afterCursor );
+ cursor->setSelection( false );
+ formula()->cursorHasMoved( cursor );
+ return 0;
+ }
+ }
+ }
+ default:
+ break;
+ }
+ return inherited::buildCommand( container, request );
+}
+
+
+RootElement::RootElement(BasicElement* parent)
+ : BasicElement(parent)
+{
+ content = new RootSequenceElement( this );
+ index = 0;
+}
+
+RootElement::~RootElement()
+{
+ delete index;
+ delete content;
+}
+
+
+RootElement::RootElement( const RootElement& other )
+ : BasicElement( other )
+{
+ content = new RootSequenceElement( *dynamic_cast<RootSequenceElement*>( other.content ) );
+ if ( other.index ) {
+ index = new SequenceElement( *( other.index ) );
+ index->setParent( this );
+ }
+ else {
+ index = 0;
+ }
+}
+
+
+bool RootElement::accept( ElementVisitor* visitor )
+{
+ return visitor->visit( this );
+}
+
+
+void RootElement::entered( SequenceElement* child )
+{
+ if ( child == content ) {
+ formula()->tell( i18n( "Main list of root" ) );
+ }
+ else {
+ formula()->tell( i18n( "Index" ) );
+ }
+}
+
+
+BasicElement* RootElement::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 = content->goToPos(cursor, handled, point, myPos);
+ if (e != 0) {
+ return e;
+ }
+ if (hasIndex()) {
+ e = index->goToPos(cursor, handled, point, myPos);
+ if (e != 0) {
+ return e;
+ }
+ }
+
+ //int dx = point.x() - myPos.x();
+ luPixel dy = point.y() - myPos.y();
+
+ // the position after the index
+ if (hasIndex()) {
+ if (dy < index->getHeight()) {
+ index->moveLeft(cursor, this);
+ handled = true;
+ return index;
+ }
+ }
+
+ return this;
+ }
+ return 0;
+}
+
+
+/**
+ * Calculates our width and height and
+ * our children's parentPosition.
+ */
+void RootElement::calcSizes( const ContextStyle& context,
+ ContextStyle::TextStyle tstyle,
+ ContextStyle::IndexStyle istyle,
+ StyleAttributes& style )
+{
+ content->calcSizes( context, tstyle,
+ context.convertIndexStyleLower(istyle), style );
+
+ luPixel indexWidth = 0;
+ luPixel indexHeight = 0;
+ if (hasIndex()) {
+ index->calcSizes( context,
+ context.convertTextStyleIndex(tstyle),
+ context.convertIndexStyleUpper(istyle),
+ style );
+ indexWidth = index->getWidth();
+ indexHeight = index->getHeight();
+ }
+
+ double factor = style.sizeFactor();
+ luPixel distX = context.ptToPixelX( context.getThinSpace( tstyle, factor ) );
+ luPixel distY = context.ptToPixelY( context.getThinSpace( tstyle, factor ) );
+ luPixel unit = (content->getHeight() + distY)/ 3;
+
+ if (hasIndex()) {
+ if (indexWidth > unit) {
+ index->setX(0);
+ rootOffset.setX( indexWidth - unit );
+ }
+ else {
+ index->setX( ( unit - indexWidth )/2 );
+ rootOffset.setX(0);
+ }
+ if (indexHeight > unit) {
+ index->setY(0);
+ rootOffset.setY( indexHeight - unit );
+ }
+ else {
+ index->setY( unit - indexHeight );
+ rootOffset.setY(0);
+ }
+ }
+ else {
+ rootOffset.setX(0);
+ rootOffset.setY(0);
+ }
+
+ setWidth( content->getWidth() + unit+unit/3+ rootOffset.x() + distX/2 );
+ setHeight( content->getHeight() + distY*2 + rootOffset.y() );
+
+ content->setX( rootOffset.x() + unit+unit/3 );
+ content->setY( rootOffset.y() + distY );
+ setBaseline(content->getBaseline() + content->getY());
+}
+
+/**
+ * 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 RootElement::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;
+
+ content->draw( painter, r, context, tstyle,
+ context.convertIndexStyleLower(istyle), style, myPos);
+ if (hasIndex()) {
+ index->draw(painter, r, context,
+ context.convertTextStyleIndex(tstyle),
+ context.convertIndexStyleUpper(istyle), style, myPos);
+ }
+
+ luPixel x = myPos.x() + rootOffset.x();
+ luPixel y = myPos.y() + rootOffset.y();
+ //int distX = context.getDistanceX(tstyle);
+ double factor = style.sizeFactor();
+ luPixel distY = context.ptToPixelY( context.getThinSpace( tstyle, factor ) );
+ luPixel unit = (content->getHeight() + distY)/ 3;
+
+ painter.setPen( TQPen( style.color(),
+ context.layoutUnitToPixelX( 2*context.getLineWidth( factor ) ) ) );
+ painter.drawLine( context.layoutUnitToPixelX( x+unit/3 ),
+ context.layoutUnitToPixelY( y+unit+distY/3 ),
+ context.layoutUnitToPixelX( x+unit/2+unit/3 ),
+ context.layoutUnitToPixelY( myPos.y()+getHeight() ) );
+
+ painter.setPen( TQPen( style.color(),
+ context.layoutUnitToPixelY( context.getLineWidth( factor ) ) ) );
+
+ painter.drawLine( context.layoutUnitToPixelX( x+unit+unit/3 ),
+ context.layoutUnitToPixelY( y+distY/3 ),
+ context.layoutUnitToPixelX( x+unit/2+unit/3 ),
+ context.layoutUnitToPixelY( myPos.y()+getHeight() ) );
+ painter.drawLine( context.layoutUnitToPixelX( x+unit+unit/3 ),
+ context.layoutUnitToPixelY( y+distY/3 ),
+ context.layoutUnitToPixelX( x+unit+unit/3+content->getWidth() ),
+ context.layoutUnitToPixelY( y+distY/3 ) );
+ painter.drawLine( context.layoutUnitToPixelX( x+unit/3 ),
+ context.layoutUnitToPixelY( y+unit+distY/2 ),
+ context.layoutUnitToPixelX( x ),
+ context.layoutUnitToPixelY( y+unit+unit/2 ) );
+}
+
+
+void RootElement::dispatchFontCommand( FontCommand* cmd )
+{
+ content->dispatchFontCommand( cmd );
+ if (hasIndex()) {
+ index->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 RootElement::moveLeft(FormulaCursor* cursor, BasicElement* from)
+{
+ if (cursor->isSelectionMode()) {
+ getParent()->moveLeft(cursor, this);
+ }
+ else {
+ bool linear = cursor->getLinearMovement();
+ if (from == getParent()) {
+ content->moveLeft(cursor, this);
+ }
+ else if (from == content) {
+ if (linear && hasIndex()) {
+ index->moveLeft(cursor, this);
+ }
+ else {
+ getParent()->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 RootElement::moveRight(FormulaCursor* cursor, BasicElement* from)
+{
+ if (cursor->isSelectionMode()) {
+ getParent()->moveRight(cursor, this);
+ }
+ else {
+ bool linear = cursor->getLinearMovement();
+ if (from == getParent()) {
+ if (linear && hasIndex()) {
+ index->moveRight(cursor, this);
+ }
+ else {
+ content->moveRight(cursor, this);
+ }
+ }
+ else if (from == index) {
+ content->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 RootElement::moveUp(FormulaCursor* cursor, BasicElement* from)
+{
+ if (cursor->isSelectionMode()) {
+ getParent()->moveUp(cursor, this);
+ }
+ else {
+ if (from == getParent()) {
+ content->moveRight(cursor, this);
+ }
+ else if (from == content) {
+ if (hasIndex()) {
+ index->moveRight(cursor, this);
+ }
+ else {
+ getParent()->moveUp(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 RootElement::moveDown(FormulaCursor* cursor, BasicElement* from)
+{
+ if (cursor->isSelectionMode()) {
+ getParent()->moveDown(cursor, this);
+ }
+ else {
+ if (from == getParent()) {
+ if (hasIndex()) {
+ index->moveRight(cursor, this);
+ }
+ else {
+ content->moveRight(cursor, this);
+ }
+ }
+ else if (from == index) {
+ content->moveRight(cursor, this);
+ }
+ else {
+ getParent()->moveDown(cursor, this);
+ }
+ }
+}
+
+/**
+ * Reinserts the index if it has been removed.
+ */
+void RootElement::insert(FormulaCursor* cursor,
+ TQPtrList<BasicElement>& newChildren,
+ Direction direction)
+{
+ if (cursor->getPos() == upperLeftPos) {
+ index = static_cast<SequenceElement*>(newChildren.take(0));
+ index->setParent(this);
+
+ if (direction == beforeCursor) {
+ index->moveLeft(cursor, this);
+ }
+ else {
+ index->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 content.
+ */
+void RootElement::remove(FormulaCursor* cursor,
+ TQPtrList<BasicElement>& removedChildren,
+ Direction direction)
+{
+ switch (cursor->getPos()) {
+ case contentPos:
+ getParent()->selectChild(cursor, this);
+ getParent()->remove(cursor, removedChildren, direction);
+ break;
+ case upperLeftPos:
+ removedChildren.append(index);
+ formula()->elementRemoval(index);
+ index = 0;
+ cursor->setTo(this, upperLeftPos);
+ formula()->changed();
+ break;
+ }
+}
+
+
+/**
+ * Moves the cursor to a normal place where new elements
+ * might be inserted.
+ */
+void RootElement::normalize(FormulaCursor* cursor, Direction direction)
+{
+ if (direction == beforeCursor) {
+ content->moveLeft(cursor, this);
+ }
+ else {
+ content->moveRight(cursor, this);
+ }
+}
+
+
+// main child
+//
+// If an element has children one has to become the main one.
+
+SequenceElement* RootElement::getMainChild()
+{
+ return content;
+}
+
+// void RootElement::setMainChild(SequenceElement* child)
+// {
+// formula()->elementRemoval(content);
+// content = child;
+// content->setParent(this);
+// formula()->changed();
+// }
+
+
+/**
+ * Sets the cursor to select the child. The mark is placed before,
+ * the position behind it.
+ */
+void RootElement::selectChild(FormulaCursor* cursor, BasicElement* child)
+{
+ if (child == content) {
+ cursor->setTo(this, contentPos);
+ }
+ else if (child == index) {
+ cursor->setTo(this, upperLeftPos);
+ }
+}
+
+
+void RootElement::moveToIndex(FormulaCursor* cursor, Direction direction)
+{
+ if (hasIndex()) {
+ if (direction == beforeCursor) {
+ index->moveLeft(cursor, this);
+ }
+ else {
+ index->moveRight(cursor, this);
+ }
+ }
+}
+
+void RootElement::setToIndex(FormulaCursor* cursor)
+{
+ cursor->setTo(this, upperLeftPos);
+}
+
+
+/**
+ * Appends our attributes to the dom element.
+ */
+void RootElement::writeDom(TQDomElement element)
+{
+ BasicElement::writeDom(element);
+
+ TQDomDocument doc = element.ownerDocument();
+
+ TQDomElement con = doc.createElement("CONTENT");
+ con.appendChild(content->getElementDom(doc));
+ element.appendChild(con);
+
+ if(hasIndex()) {
+ TQDomElement ind = doc.createElement("ROOTINDEX");
+ ind.appendChild(index->getElementDom(doc));
+ element.appendChild(ind);
+ }
+}
+
+/**
+ * Reads our attributes from the element.
+ * Returns false if it failed.
+ */
+bool RootElement::readAttributesFromDom(TQDomElement element)
+{
+ return BasicElement::readAttributesFromDom(element);
+}
+
+/**
+ * Reads our content from the node. Sets the node to the next node
+ * that needs to be read.
+ * Returns false if it failed.
+ */
+bool RootElement::readContentFromDom(TQDomNode& node)
+{
+ if (!BasicElement::readContentFromDom(node)) {
+ return false;
+ }
+
+ if ( !buildChild( content, node, "CONTENT" ) ) {
+ kdWarning( DEBUGID ) << "Empty content in RootElement." << endl;
+ return false;
+ }
+ node = node.nextSibling();
+
+ if ( node.nodeName().upper() == "ROOTINDEX" ) {
+ if ( !buildChild( index=new SequenceElement( this ), node, "ROOTINDEX" ) ) {
+ return false;
+ }
+ }
+ // backward compatibility
+ else if ( node.nodeName().upper() == "INDEX" ) {
+ if ( !buildChild( index=new SequenceElement( this ), node, "INDEX" ) ) {
+ return false;
+ }
+ }
+ node = node.nextSibling();
+
+ return true;
+}
+
+/**
+ * Reads our attributes from the MathML element.
+ * Also checks whether it's a msqrt or mroot.
+ * Returns false if it failed.
+ */
+bool RootElement::readAttributesFromMathMLDom(const TQDomElement& element)
+{
+ if ( element.tagName().lower() == "mroot" )
+ square = false;
+ else
+ square = true;
+ 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 RootElement::readContentFromMathMLDom(TQDomNode& node)
+{
+ if ( BasicElement::readContentFromMathMLDom( node ) == -1 ) {
+ return -1;
+ }
+
+ if ( square ) {
+ // Any number of arguments are allowed
+ if ( content->readContentFromMathMLDom( node ) == -1 ) {
+ kdWarning( DEBUGID ) << "Empty content in RootElement." << endl;
+ return -1;
+ }
+ }
+ else {
+ // Exactly two arguments are required
+ int contentNumber = content->buildMathMLChild( node );
+ if ( contentNumber == -1 ) {
+ kdWarning( DEBUGID ) << "Empty content in RootElement." << endl;
+ return -1;
+ }
+ for (int i = 0; i < contentNumber; i++ ) {
+ if ( node.isNull() ) {
+ return -1;
+ }
+ node = node.nextSibling();
+ }
+
+ index = new SequenceElement( this );
+ if ( index->buildMathMLChild( node ) == -1 ) {
+ kdWarning( DEBUGID ) << "Empty index in RootElement." << endl;
+ return -1;
+ }
+ }
+
+ return 1;
+}
+
+TQString RootElement::toLatex()
+{
+ TQString root;
+ root="\\sqrt";
+ if(hasIndex()) {
+ root+="[";
+ root+=index->toLatex();
+ root+="]";
+ }
+ root+="{";
+ root+=content->toLatex();
+ root+="}";
+
+ return root;
+}
+
+TQString RootElement::formulaString()
+{
+ if ( hasIndex() ) {
+ return "(" + content->formulaString() + ")**(1.0/(" + index->formulaString() + "))";
+ }
+ return "sqrt(" + content->formulaString() + ")";
+}
+
+void RootElement::writeMathMLContent( TQDomDocument& doc, TQDomElement& element, bool oasisFormat ) const
+{
+ content->writeMathML( doc, element, oasisFormat );
+ if( hasIndex() )
+ {
+ index->writeMathML( doc, element, oasisFormat );
+ }
+}
+
+KFORMULA_NAMESPACE_END
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-16 00:59:14 +0000