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.
1764 lines
52 KiB
1764 lines
52 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 "indexelement.h"
|
|
#include "formulacursor.h"
|
|
#include "formulaelement.h"
|
|
#include "kformulacommand.h"
|
|
#include "sequenceelement.h"
|
|
|
|
|
|
KFORMULA_NAMESPACE_BEGIN
|
|
|
|
|
|
class IndexSequenceElement : public SequenceElement {
|
|
typedef SequenceElement inherited;
|
|
public:
|
|
|
|
IndexSequenceElement( BasicElement* parent = 0 ) : SequenceElement( parent ) {}
|
|
virtual IndexSequenceElement* clone() {
|
|
return new IndexSequenceElement( *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* IndexSequenceElement::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;
|
|
}
|
|
IndexElement* element = static_cast<IndexElement*>( getParent() );
|
|
IndexRequest* ir = static_cast<IndexRequest*>( request );
|
|
ElementIndexPtr index = element->getIndex( ir->index() );
|
|
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 );
|
|
}
|
|
|
|
|
|
IndexElement::IndexElement(BasicElement* parent)
|
|
: BasicElement(parent),
|
|
m_subScriptShiftType( NoSize ),
|
|
m_superScriptShiftType( NoSize ),
|
|
m_customAccentUnder( false ),
|
|
m_customAccent ( false )
|
|
{
|
|
content = new IndexSequenceElement( this );
|
|
|
|
upperLeft = 0;
|
|
upperMiddle = 0;
|
|
upperRight = 0;
|
|
lowerLeft = 0;
|
|
lowerMiddle = 0;
|
|
lowerRight = 0;
|
|
}
|
|
|
|
IndexElement::~IndexElement()
|
|
{
|
|
delete content;
|
|
delete upperLeft;
|
|
delete upperMiddle;
|
|
delete upperRight;
|
|
delete lowerLeft;
|
|
delete lowerMiddle;
|
|
delete lowerRight;
|
|
}
|
|
|
|
|
|
IndexElement::IndexElement( const IndexElement& other )
|
|
: BasicElement( other ),
|
|
m_subScriptShiftType( other.m_subScriptShiftType ),
|
|
m_subScriptShift( other.m_subScriptShift ),
|
|
m_superScriptShiftType( other.m_superScriptShiftType ),
|
|
m_superScriptShift( other.m_superScriptShift ),
|
|
m_customAccentUnder( other.m_customAccentUnder ),
|
|
m_accentUnder( other.m_accentUnder ),
|
|
m_customAccent ( other.m_customAccent ),
|
|
m_accent( other.m_accent )
|
|
{
|
|
content = new IndexSequenceElement( *dynamic_cast<IndexSequenceElement*>( other.content ) );
|
|
|
|
if ( other.upperLeft ) {
|
|
upperLeft = new SequenceElement( *( other.upperLeft ) );
|
|
upperLeft->setParent( this );
|
|
}
|
|
else {
|
|
upperLeft = 0;
|
|
}
|
|
if ( other.upperMiddle ) {
|
|
upperMiddle = new SequenceElement( *( other.upperMiddle ) );
|
|
upperMiddle->setParent( this );
|
|
}
|
|
else {
|
|
upperMiddle = 0;
|
|
}
|
|
if ( other.upperRight ) {
|
|
upperRight = new SequenceElement( *( other.upperRight ) );
|
|
upperRight->setParent( this );
|
|
}
|
|
else {
|
|
upperRight = 0;
|
|
}
|
|
|
|
if ( other.lowerLeft ) {
|
|
lowerLeft = new SequenceElement( *( other.lowerLeft ) );
|
|
lowerLeft->setParent( this );
|
|
}
|
|
else {
|
|
lowerLeft = 0;
|
|
}
|
|
if ( other.lowerMiddle ) {
|
|
lowerMiddle = new SequenceElement( *( other.lowerMiddle ) );
|
|
lowerMiddle->setParent( this );
|
|
}
|
|
else {
|
|
lowerMiddle = 0;
|
|
}
|
|
if ( other.lowerRight ) {
|
|
lowerRight = new SequenceElement( *( other.lowerRight ) );
|
|
lowerRight->setParent( this );
|
|
}
|
|
else {
|
|
lowerRight = 0;
|
|
}
|
|
}
|
|
|
|
|
|
bool IndexElement::accept( ElementVisitor* visitor )
|
|
{
|
|
return visitor->visit( this );
|
|
}
|
|
|
|
|
|
TQChar IndexElement::getCharacter() const
|
|
{
|
|
if ( !content->isTextOnly() ) {
|
|
return TQChar::null;
|
|
}
|
|
|
|
if ( hasUpperRight() && !upperRight->isTextOnly() ) {
|
|
return TQChar::null;
|
|
}
|
|
if ( hasUpperMiddle() && !upperMiddle->isTextOnly() ) {
|
|
return TQChar::null;
|
|
}
|
|
if ( hasUpperLeft() && !upperLeft->isTextOnly() ) {
|
|
return TQChar::null;
|
|
}
|
|
if ( hasLowerRight() && !lowerRight->isTextOnly() ) {
|
|
return TQChar::null;
|
|
}
|
|
if ( hasLowerMiddle() && !lowerMiddle->isTextOnly() ) {
|
|
return TQChar::null;
|
|
}
|
|
if ( hasLowerLeft() && !lowerLeft->isTextOnly() ) {
|
|
return TQChar::null;
|
|
}
|
|
|
|
return ' ';
|
|
}
|
|
|
|
void IndexElement::entered( SequenceElement* child )
|
|
{
|
|
if ( child == content ) {
|
|
formula()->tell( i18n( "Indexed list" ) );
|
|
}
|
|
else {
|
|
formula()->tell( i18n( "Index" ) );
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the element the point is in.
|
|
*/
|
|
BasicElement* IndexElement::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 (hasUpperRight()) {
|
|
e = upperRight->goToPos(cursor, handled, point, myPos);
|
|
if (e != 0) return e;
|
|
}
|
|
if (hasUpperMiddle()) {
|
|
e = upperMiddle->goToPos(cursor, handled, point, myPos);
|
|
if (e != 0) return e;
|
|
}
|
|
if (hasUpperLeft()) {
|
|
e = upperLeft->goToPos(cursor, handled, point, myPos);
|
|
if (e != 0) return e;
|
|
}
|
|
if (hasLowerRight()) {
|
|
e = lowerRight->goToPos(cursor, handled, point, myPos);
|
|
if (e != 0) return e;
|
|
}
|
|
if (hasLowerMiddle()) {
|
|
e = lowerMiddle->goToPos(cursor, handled, point, myPos);
|
|
if (e != 0) return e;
|
|
}
|
|
if (hasLowerLeft()) {
|
|
e = lowerLeft->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 left indexes
|
|
if (dx < content->getX()+content->getWidth()) {
|
|
if (dy < content->getY()) {
|
|
if (hasUpperMiddle() && (dx > upperMiddle->getX())) {
|
|
upperMiddle->moveLeft(cursor, this);
|
|
handled = true;
|
|
return upperMiddle;
|
|
}
|
|
if (hasUpperLeft() && (dx > upperLeft->getX())) {
|
|
upperLeft->moveLeft(cursor, this);
|
|
handled = true;
|
|
return upperLeft;
|
|
}
|
|
}
|
|
else if (dy > content->getY()+content->getHeight()) {
|
|
if (hasLowerMiddle() && (dx > lowerMiddle->getX())) {
|
|
lowerMiddle->moveLeft(cursor, this);
|
|
handled = true;
|
|
return lowerMiddle;
|
|
}
|
|
if (hasLowerLeft() && (dx > lowerLeft->getX())) {
|
|
lowerLeft->moveLeft(cursor, this);
|
|
handled = true;
|
|
return lowerLeft;
|
|
}
|
|
}
|
|
}
|
|
// the positions after the left indexes
|
|
else {
|
|
if (dy < content->getY()) {
|
|
if (hasUpperRight()) {
|
|
upperRight->moveLeft(cursor, this);
|
|
handled = true;
|
|
return upperRight;
|
|
}
|
|
}
|
|
else if (dy > content->getY()+content->getHeight()) {
|
|
if (hasLowerRight()) {
|
|
lowerRight->moveLeft(cursor, this);
|
|
handled = true;
|
|
return lowerRight;
|
|
}
|
|
}
|
|
else {
|
|
content->moveLeft(cursor, this);
|
|
handled = true;
|
|
return content;
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
// drawing
|
|
//
|
|
// Drawing depends on a context which knows the required properties like
|
|
// fonts, spaces and such.
|
|
// It is essential to calculate elements size with the same context
|
|
// before you draw.
|
|
|
|
|
|
void IndexElement::setMiddleX(int xOffset, int middleWidth)
|
|
{
|
|
content->setX(xOffset + (middleWidth - content->getWidth()) / 2);
|
|
if (hasUpperMiddle()) {
|
|
upperMiddle->setX(xOffset + (middleWidth - upperMiddle->getWidth()) / 2);
|
|
}
|
|
if (hasLowerMiddle()) {
|
|
lowerMiddle->setX(xOffset + (middleWidth - lowerMiddle->getWidth()) / 2);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Calculates our width and height and
|
|
* our children's parentPosition.
|
|
*/
|
|
void IndexElement::calcSizes(const ContextStyle& context,
|
|
ContextStyle::TextStyle tstyle,
|
|
ContextStyle::IndexStyle istyle,
|
|
StyleAttributes& style )
|
|
{
|
|
double factor = style.sizeFactor();
|
|
luPixel distY = context.ptToPixelY( context.getThinSpace( tstyle, factor ) );
|
|
|
|
ContextStyle::TextStyle i_tstyle = context.convertTextStyleIndex(tstyle);
|
|
ContextStyle::IndexStyle u_istyle = context.convertIndexStyleUpper( istyle );
|
|
ContextStyle::IndexStyle l_istyle = context.convertIndexStyleLower( istyle );
|
|
|
|
// get the indexes size
|
|
luPixel ulWidth = 0, ulHeight = 0, ulMidline = 0;
|
|
if (hasUpperLeft()) {
|
|
upperLeft->calcSizes( context, i_tstyle, u_istyle, style );
|
|
ulWidth = upperLeft->getWidth();
|
|
ulHeight = upperLeft->getHeight();
|
|
ulMidline = upperLeft->axis( context, i_tstyle, factor );
|
|
}
|
|
|
|
luPixel umWidth = 0, umHeight = 0, umMidline = 0;
|
|
if (hasUpperMiddle()) {
|
|
upperMiddle->calcSizes( context, i_tstyle, u_istyle, style );
|
|
umWidth = upperMiddle->getWidth();
|
|
umHeight = upperMiddle->getHeight() + distY;
|
|
umMidline = upperMiddle->axis( context, i_tstyle, factor );
|
|
}
|
|
|
|
luPixel urWidth = 0, urHeight = 0, urMidline = 0;
|
|
if (hasUpperRight()) {
|
|
upperRight->calcSizes( context, i_tstyle, u_istyle, style );
|
|
urWidth = upperRight->getWidth();
|
|
urHeight = upperRight->getHeight();
|
|
urMidline = upperRight->axis( context, i_tstyle, factor );
|
|
}
|
|
|
|
luPixel llWidth = 0, llHeight = 0, llMidline = 0;
|
|
if (hasLowerLeft()) {
|
|
lowerLeft->calcSizes( context, i_tstyle, l_istyle, style );
|
|
llWidth = lowerLeft->getWidth();
|
|
llHeight = lowerLeft->getHeight();
|
|
llMidline = lowerLeft->axis( context, i_tstyle, factor );
|
|
}
|
|
|
|
luPixel lmWidth = 0, lmHeight = 0, lmMidline = 0;
|
|
if (hasLowerMiddle()) {
|
|
lowerMiddle->calcSizes( context, i_tstyle, l_istyle, style );
|
|
lmWidth = lowerMiddle->getWidth();
|
|
lmHeight = lowerMiddle->getHeight() + distY;
|
|
lmMidline = lowerMiddle->axis( context, i_tstyle, factor );
|
|
}
|
|
|
|
luPixel lrWidth = 0, lrHeight = 0, lrMidline = 0;
|
|
if (hasLowerRight()) {
|
|
lowerRight->calcSizes( context, i_tstyle, l_istyle, style );
|
|
lrWidth = lowerRight->getWidth();
|
|
lrHeight = lowerRight->getHeight();
|
|
lrMidline = lowerRight->axis( context, i_tstyle, factor );
|
|
}
|
|
|
|
// get the contents size
|
|
content->calcSizes( context, tstyle, istyle, style );
|
|
luPixel width = TQMAX(content->getWidth(), TQMAX(umWidth, lmWidth));
|
|
luPixel toMidline = content->axis( context, tstyle, factor );
|
|
luPixel fromMidline = content->getHeight() - toMidline;
|
|
|
|
// calculate the x offsets
|
|
if (ulWidth > llWidth) {
|
|
upperLeft->setX(0);
|
|
if (hasLowerLeft()) {
|
|
lowerLeft->setX(ulWidth - llWidth);
|
|
}
|
|
setMiddleX(ulWidth, width);
|
|
width += ulWidth;
|
|
}
|
|
else {
|
|
if (hasUpperLeft()) {
|
|
upperLeft->setX(llWidth - ulWidth);
|
|
}
|
|
if (hasLowerLeft()) {
|
|
lowerLeft->setX(0);
|
|
}
|
|
setMiddleX(llWidth, width);
|
|
width += llWidth;
|
|
}
|
|
|
|
if (hasUpperRight()) {
|
|
upperRight->setX(width);
|
|
}
|
|
if (hasLowerRight()) {
|
|
lowerRight->setX(width);
|
|
}
|
|
width += TQMAX(urWidth, lrWidth);
|
|
|
|
// calculate the y offsets
|
|
luPixel ulOffset = 0;
|
|
luPixel urOffset = 0;
|
|
luPixel llOffset = 0;
|
|
luPixel lrOffset = 0;
|
|
if (content->isTextOnly()) {
|
|
luPt mySize = context.getAdjustedSize( tstyle, factor );
|
|
TQFont font = context.getDefaultFont();
|
|
font.setPointSizeFloat( context.layoutUnitPtToPt( mySize ) );
|
|
|
|
TQFontMetrics fm(font);
|
|
LuPixelRect bound = fm.boundingRect('x');
|
|
|
|
luPixel exBaseline = context.ptToLayoutUnitPt( -bound.top() );
|
|
|
|
// the upper half
|
|
ulOffset = ulHeight + exBaseline - content->getBaseline();
|
|
urOffset = urHeight + exBaseline - content->getBaseline();
|
|
|
|
// the lower half
|
|
llOffset = lrOffset = content->getBaseline();
|
|
}
|
|
else {
|
|
|
|
// the upper half
|
|
ulOffset = TQMAX(ulMidline, ulHeight-toMidline);
|
|
urOffset = TQMAX(urMidline, urHeight-toMidline);
|
|
|
|
// the lower half
|
|
llOffset = TQMAX(content->getHeight()-llMidline, toMidline);
|
|
lrOffset = TQMAX(content->getHeight()-lrMidline, toMidline);
|
|
}
|
|
|
|
// Add more offset if defined in attributes
|
|
switch ( m_superScriptShiftType ) {
|
|
case AbsoluteSize:
|
|
urOffset += context.ptToLayoutUnitPt( m_superScriptShift );
|
|
break;
|
|
case RelativeSize:
|
|
urOffset += urOffset * m_superScriptShift;
|
|
break;
|
|
case PixelSize:
|
|
urOffset += context.pixelToLayoutUnitY( m_superScriptShift );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch ( m_subScriptShiftType ) {
|
|
case AbsoluteSize:
|
|
lrOffset += context.ptToLayoutUnitPt( m_subScriptShift );
|
|
break;
|
|
case RelativeSize:
|
|
lrOffset += lrOffset * m_subScriptShift;
|
|
break;
|
|
case PixelSize:
|
|
lrOffset += context.pixelToLayoutUnitY( m_subScriptShift );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
luPixel height = TQMAX(umHeight, TQMAX(ulOffset, urOffset));
|
|
|
|
// the upper half
|
|
content->setY(height);
|
|
toMidline += height;
|
|
if (hasUpperLeft()) {
|
|
upperLeft->setY(height-ulOffset);
|
|
}
|
|
if (hasUpperMiddle()) {
|
|
upperMiddle->setY(height-umHeight);
|
|
}
|
|
if (hasUpperRight()) {
|
|
upperRight->setY( height - urOffset );
|
|
}
|
|
|
|
// the lower half
|
|
if (hasLowerLeft()) {
|
|
lowerLeft->setY(height+llOffset);
|
|
}
|
|
if (hasLowerMiddle()) {
|
|
lowerMiddle->setY(height+content->getHeight()+distY);
|
|
}
|
|
if (hasLowerRight()) {
|
|
lowerRight->setY( height + lrOffset );
|
|
}
|
|
|
|
fromMidline += TQMAX(TQMAX(llHeight+llOffset, lrHeight+lrOffset) - content->getHeight(), lmHeight);
|
|
|
|
// set the result
|
|
setWidth(width);
|
|
setHeight(toMidline+fromMidline);
|
|
if (content->isTextOnly()) {
|
|
setBaseline(content->getY() + content->getBaseline());
|
|
//setMidline(content->getY() + content->getMidline());
|
|
}
|
|
else {
|
|
//setMidline(toMidline);
|
|
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 IndexElement::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;
|
|
|
|
ContextStyle::TextStyle i_tstyle = context.convertTextStyleIndex(tstyle);
|
|
ContextStyle::IndexStyle u_istyle = context.convertIndexStyleUpper( istyle );
|
|
ContextStyle::IndexStyle l_istyle = context.convertIndexStyleLower( istyle );
|
|
|
|
content->draw(painter, r, context, tstyle, istyle, style, myPos);
|
|
if (hasUpperLeft()) {
|
|
upperLeft->draw(painter, r, context, i_tstyle, u_istyle, style, myPos);
|
|
}
|
|
if (hasUpperMiddle()) {
|
|
upperMiddle->draw(painter, r, context, i_tstyle, u_istyle, style, myPos);
|
|
}
|
|
if (hasUpperRight()) {
|
|
upperRight->draw(painter, r, context, i_tstyle, u_istyle, style, myPos);
|
|
}
|
|
if (hasLowerLeft()) {
|
|
lowerLeft->draw(painter, r, context, i_tstyle, l_istyle, style, myPos);
|
|
}
|
|
if (hasLowerMiddle()) {
|
|
lowerMiddle->draw(painter, r, context, i_tstyle, l_istyle, style, myPos);
|
|
}
|
|
if (hasLowerRight()) {
|
|
lowerRight->draw(painter, r, context, i_tstyle, l_istyle, style, myPos);
|
|
}
|
|
|
|
// Debug
|
|
//painter.setBrush(TQt::NoBrush);
|
|
//painter.setPen(TQt::red);
|
|
//painter.drawRect(myPos.x(), myPos.y(), getWidth(), getHeight());
|
|
//painter.drawLine(myPos.x(), myPos.y()+getMidline(),
|
|
// myPos.x()+getWidth(), myPos.y()+getMidline());
|
|
}
|
|
|
|
|
|
void IndexElement::dispatchFontCommand( FontCommand* cmd )
|
|
{
|
|
content->dispatchFontCommand( cmd );
|
|
if (hasUpperLeft()) {
|
|
upperLeft->dispatchFontCommand( cmd );
|
|
}
|
|
if (hasUpperMiddle()) {
|
|
upperMiddle->dispatchFontCommand( cmd );
|
|
}
|
|
if (hasUpperRight()) {
|
|
upperRight->dispatchFontCommand( cmd );
|
|
}
|
|
if (hasLowerLeft()) {
|
|
lowerLeft->dispatchFontCommand( cmd );
|
|
}
|
|
if (hasLowerMiddle()) {
|
|
lowerMiddle->dispatchFontCommand( cmd );
|
|
}
|
|
if (hasLowerRight()) {
|
|
lowerRight->dispatchFontCommand( cmd );
|
|
}
|
|
}
|
|
|
|
|
|
// navigation
|
|
//
|
|
// The elements are responsible to handle cursor movement themselves.
|
|
// To do this they need to know the direction the cursor moves and
|
|
// the element it comes from.
|
|
//
|
|
// The cursor might be in normal or in selection mode.
|
|
|
|
int IndexElement::getFromPos(BasicElement* from)
|
|
{
|
|
if (from == lowerRight) {
|
|
return lowerRightPos;
|
|
}
|
|
else if (from == upperRight) {
|
|
return upperRightPos;
|
|
}
|
|
else if (from == lowerMiddle) {
|
|
return lowerMiddlePos;
|
|
}
|
|
else if (from == content) {
|
|
return contentPos;
|
|
}
|
|
else if (from == upperMiddle) {
|
|
return upperMiddlePos;
|
|
}
|
|
else if (from == lowerLeft) {
|
|
return lowerLeftPos;
|
|
}
|
|
else if (from == upperLeft) {
|
|
return upperLeftPos;
|
|
}
|
|
return parentPos;
|
|
}
|
|
|
|
/**
|
|
* 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 IndexElement::moveLeft(FormulaCursor* cursor, BasicElement* from)
|
|
{
|
|
if (cursor->isSelectionMode()) {
|
|
getParent()->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
bool linear = cursor->getLinearMovement();
|
|
int fromPos = getFromPos(from);
|
|
if (!linear) {
|
|
if ((fromPos == lowerRightPos) && hasLowerMiddle()) {
|
|
lowerMiddle->moveLeft(cursor, this);
|
|
return;
|
|
}
|
|
else if ((fromPos == upperRightPos) && hasUpperMiddle()) {
|
|
upperMiddle->moveLeft(cursor, this);
|
|
return;
|
|
}
|
|
else if ((fromPos == lowerMiddlePos) && hasLowerLeft()) {
|
|
lowerLeft->moveLeft(cursor, this);
|
|
return;
|
|
}
|
|
else if ((fromPos == upperMiddlePos) && hasUpperLeft()) {
|
|
upperLeft->moveLeft(cursor, this);
|
|
return;
|
|
}
|
|
}
|
|
switch (fromPos) {
|
|
case parentPos:
|
|
if (hasLowerRight() && linear) {
|
|
lowerRight->moveLeft(cursor, this);
|
|
break;
|
|
}
|
|
case lowerRightPos:
|
|
if (hasUpperRight() && linear) {
|
|
upperRight->moveLeft(cursor, this);
|
|
break;
|
|
}
|
|
case upperRightPos:
|
|
if (hasLowerMiddle() && linear) {
|
|
lowerMiddle->moveLeft(cursor, this);
|
|
break;
|
|
}
|
|
case lowerMiddlePos:
|
|
content->moveLeft(cursor, this);
|
|
break;
|
|
case contentPos:
|
|
if (hasUpperMiddle() && linear) {
|
|
upperMiddle->moveLeft(cursor, this);
|
|
break;
|
|
}
|
|
case upperMiddlePos:
|
|
if (hasLowerLeft() && linear) {
|
|
lowerLeft->moveLeft(cursor, this);
|
|
break;
|
|
}
|
|
case lowerLeftPos:
|
|
if (hasUpperLeft() && linear) {
|
|
upperLeft->moveLeft(cursor, this);
|
|
break;
|
|
}
|
|
case upperLeftPos:
|
|
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 IndexElement::moveRight(FormulaCursor* cursor, BasicElement* from)
|
|
{
|
|
if (cursor->isSelectionMode()) {
|
|
getParent()->moveRight(cursor, this);
|
|
}
|
|
else {
|
|
bool linear = cursor->getLinearMovement();
|
|
int fromPos = getFromPos(from);
|
|
if (!linear) {
|
|
if ((fromPos == lowerLeftPos) && hasLowerMiddle()) {
|
|
lowerMiddle->moveRight(cursor, this);
|
|
return;
|
|
}
|
|
else if ((fromPos == upperLeftPos) && hasUpperMiddle()) {
|
|
upperMiddle->moveRight(cursor, this);
|
|
return;
|
|
}
|
|
else if ((fromPos == lowerMiddlePos) && hasLowerRight()) {
|
|
lowerRight->moveRight(cursor, this);
|
|
return;
|
|
}
|
|
else if ((fromPos == upperMiddlePos) && hasUpperRight()) {
|
|
upperRight->moveRight(cursor, this);
|
|
return;
|
|
}
|
|
}
|
|
switch (fromPos) {
|
|
case parentPos:
|
|
if (hasUpperLeft() && linear) {
|
|
upperLeft->moveRight(cursor, this);
|
|
break;
|
|
}
|
|
case upperLeftPos:
|
|
if (hasLowerLeft() && linear) {
|
|
lowerLeft->moveRight(cursor, this);
|
|
break;
|
|
}
|
|
case lowerLeftPos:
|
|
if (hasUpperMiddle() && linear) {
|
|
upperMiddle->moveRight(cursor, this);
|
|
break;
|
|
}
|
|
case upperMiddlePos:
|
|
content->moveRight(cursor, this);
|
|
break;
|
|
case contentPos:
|
|
if (hasLowerMiddle() && linear) {
|
|
lowerMiddle->moveRight(cursor, this);
|
|
break;
|
|
}
|
|
case lowerMiddlePos:
|
|
if (hasUpperRight() && linear) {
|
|
upperRight->moveRight(cursor, this);
|
|
break;
|
|
}
|
|
case upperRightPos:
|
|
if (hasLowerRight() && linear) {
|
|
lowerRight->moveRight(cursor, this);
|
|
break;
|
|
}
|
|
case lowerRightPos:
|
|
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 IndexElement::moveUp(FormulaCursor* cursor, BasicElement* from)
|
|
{
|
|
if (cursor->isSelectionMode()) {
|
|
getParent()->moveUp(cursor, this);
|
|
}
|
|
else {
|
|
if (from == content) {
|
|
if ((cursor->getPos() == 0) && (cursor->getElement() == from)) {
|
|
if (hasUpperLeft()) {
|
|
upperLeft->moveLeft(cursor, this);
|
|
return;
|
|
}
|
|
else if (hasUpperMiddle()) {
|
|
upperMiddle->moveRight(cursor, this);
|
|
return;
|
|
}
|
|
}
|
|
if (hasUpperRight()) {
|
|
upperRight->moveRight(cursor, this);
|
|
}
|
|
else if (hasUpperMiddle()) {
|
|
upperMiddle->moveLeft(cursor, this);
|
|
}
|
|
else if (hasUpperLeft()) {
|
|
upperLeft->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
getParent()->moveUp(cursor, this);
|
|
}
|
|
}
|
|
else if ((from == upperLeft) || (from == upperMiddle) || (from == upperRight)) {
|
|
getParent()->moveUp(cursor, this);
|
|
}
|
|
else if ((from == getParent()) || (from == lowerLeft) || (from == lowerMiddle)) {
|
|
content->moveRight(cursor, this);
|
|
}
|
|
else if (from == lowerRight) {
|
|
content->moveLeft(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 IndexElement::moveDown(FormulaCursor* cursor, BasicElement* from)
|
|
{
|
|
if (cursor->isSelectionMode()) {
|
|
getParent()->moveDown(cursor, this);
|
|
}
|
|
else {
|
|
if (from == content) {
|
|
if ((cursor->getPos() == 0) && (cursor->getElement() == from)) {
|
|
if (hasLowerLeft()) {
|
|
lowerLeft->moveLeft(cursor, this);
|
|
return;
|
|
}
|
|
else if (hasLowerMiddle()) {
|
|
lowerMiddle->moveRight(cursor, this);
|
|
return;
|
|
}
|
|
}
|
|
if (hasLowerRight()) {
|
|
lowerRight->moveRight(cursor, this);
|
|
}
|
|
else if (hasLowerMiddle()) {
|
|
lowerMiddle->moveLeft(cursor, this);
|
|
}
|
|
else if (hasLowerLeft()) {
|
|
lowerLeft->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
getParent()->moveDown(cursor, this);
|
|
}
|
|
}
|
|
else if ((from == lowerLeft) || (from == lowerMiddle) || (from == lowerRight)) {
|
|
getParent()->moveDown(cursor, this);
|
|
}
|
|
else if ((from == getParent()) || (from == upperLeft) || (from == upperMiddle)) {
|
|
content->moveRight(cursor, this);
|
|
}
|
|
if (from == upperRight) {
|
|
content->moveLeft(cursor, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// children
|
|
|
|
|
|
// main child
|
|
//
|
|
// If an element has children one has to become the main one.
|
|
|
|
// void IndexElement::setMainChild(SequenceElement* child)
|
|
// {
|
|
// formula()->elementRemoval(content);
|
|
// content = child;
|
|
// content->setParent(this);
|
|
// formula()->changed();
|
|
// }
|
|
|
|
|
|
/**
|
|
* Inserts all new children at the cursor position. Places the
|
|
* cursor according to the direction.
|
|
*
|
|
* You only can insert one index at a time. So the list must contain
|
|
* exactly on SequenceElement. And the index you want to insert
|
|
* must not exist already.
|
|
*
|
|
* The list will be emptied but stays the property of the caller.
|
|
*/
|
|
void IndexElement::insert(FormulaCursor* cursor,
|
|
TQPtrList<BasicElement>& newChildren,
|
|
Direction direction)
|
|
{
|
|
SequenceElement* index = static_cast<SequenceElement*>(newChildren.take(0));
|
|
index->setParent(this);
|
|
|
|
switch (cursor->getPos()) {
|
|
case upperLeftPos:
|
|
upperLeft = index;
|
|
break;
|
|
case lowerLeftPos:
|
|
lowerLeft = index;
|
|
break;
|
|
case upperMiddlePos:
|
|
upperMiddle = index;
|
|
break;
|
|
case lowerMiddlePos:
|
|
lowerMiddle = index;
|
|
break;
|
|
case upperRightPos:
|
|
upperRight = index;
|
|
break;
|
|
case lowerRightPos:
|
|
lowerRight = index;
|
|
break;
|
|
default:
|
|
// this is an error!
|
|
return;
|
|
}
|
|
|
|
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.
|
|
*
|
|
* The cursor has to be inside one of our indexes which is supposed
|
|
* to be empty. The index will be removed and the cursor will
|
|
* be placed to the removed index so it can be inserted again.
|
|
* This methode is called by SequenceElement::remove only.
|
|
*
|
|
* The ownership of the list is passed to the caller.
|
|
*/
|
|
void IndexElement::remove(FormulaCursor* cursor,
|
|
TQPtrList<BasicElement>& removedChildren,
|
|
Direction direction)
|
|
{
|
|
int pos = cursor->getPos();
|
|
switch (pos) {
|
|
case upperLeftPos:
|
|
removedChildren.append(upperLeft);
|
|
formula()->elementRemoval(upperLeft);
|
|
upperLeft = 0;
|
|
setToUpperLeft(cursor);
|
|
break;
|
|
case lowerLeftPos:
|
|
removedChildren.append(lowerLeft);
|
|
formula()->elementRemoval(lowerLeft);
|
|
lowerLeft = 0;
|
|
setToLowerLeft(cursor);
|
|
break;
|
|
case contentPos: {
|
|
BasicElement* parent = getParent();
|
|
parent->selectChild(cursor, this);
|
|
parent->remove(cursor, removedChildren, direction);
|
|
break;
|
|
}
|
|
case upperMiddlePos:
|
|
removedChildren.append(upperMiddle);
|
|
formula()->elementRemoval(upperMiddle);
|
|
upperMiddle = 0;
|
|
setToUpperMiddle(cursor);
|
|
break;
|
|
case lowerMiddlePos:
|
|
removedChildren.append(lowerMiddle);
|
|
formula()->elementRemoval(lowerMiddle);
|
|
lowerMiddle = 0;
|
|
setToLowerMiddle(cursor);
|
|
break;
|
|
case upperRightPos:
|
|
removedChildren.append(upperRight);
|
|
formula()->elementRemoval(upperRight);
|
|
upperRight = 0;
|
|
setToUpperRight(cursor);
|
|
break;
|
|
case lowerRightPos:
|
|
removedChildren.append(lowerRight);
|
|
formula()->elementRemoval(lowerRight);
|
|
lowerRight = 0;
|
|
setToLowerRight(cursor);
|
|
break;
|
|
}
|
|
formula()->changed();
|
|
}
|
|
|
|
/**
|
|
* Moves the cursor to a normal place where new elements
|
|
* might be inserted.
|
|
*/
|
|
void IndexElement::normalize(FormulaCursor* cursor, Direction direction)
|
|
{
|
|
if (direction == beforeCursor) {
|
|
content->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
content->moveRight(cursor, this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 IndexElement::isSenseless()
|
|
{
|
|
return !hasUpperLeft() && !hasUpperRight() && !hasUpperMiddle() &&
|
|
!hasLowerLeft() && !hasLowerRight() && !hasLowerMiddle();
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the child at the cursor.
|
|
*/
|
|
BasicElement* IndexElement::getChild(FormulaCursor* cursor, Direction)
|
|
{
|
|
int pos = cursor->getPos();
|
|
/*
|
|
It makes no sense to care for the direction.
|
|
if (direction == beforeCursor) {
|
|
pos -= 1;
|
|
}
|
|
*/
|
|
switch (pos) {
|
|
case contentPos:
|
|
return content;
|
|
case upperLeftPos:
|
|
return upperLeft;
|
|
case lowerLeftPos:
|
|
return lowerLeft;
|
|
case upperMiddlePos:
|
|
return upperMiddle;
|
|
case lowerMiddlePos:
|
|
return lowerMiddle;
|
|
case upperRightPos:
|
|
return upperRight;
|
|
case lowerRightPos:
|
|
return lowerRight;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the cursor to select the child. The mark is placed before,
|
|
* the position behind it.
|
|
*/
|
|
void IndexElement::selectChild(FormulaCursor* cursor, BasicElement* child)
|
|
{
|
|
if (child == content) {
|
|
setToContent(cursor);
|
|
}
|
|
else if (child == upperLeft) {
|
|
setToUpperLeft(cursor);
|
|
}
|
|
else if (child == lowerLeft) {
|
|
setToLowerLeft(cursor);
|
|
}
|
|
else if (child == upperMiddle) {
|
|
setToUpperMiddle(cursor);
|
|
}
|
|
else if (child == lowerMiddle) {
|
|
setToLowerMiddle(cursor);
|
|
}
|
|
else if (child == upperRight) {
|
|
setToUpperRight(cursor);
|
|
}
|
|
else if (child == lowerRight) {
|
|
setToLowerRight(cursor);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the cursor to point to the place where the content is.
|
|
* There always is a content so this is not a useful place.
|
|
* No insertion or removal will succeed as long as the cursor is
|
|
* there.
|
|
*/
|
|
void IndexElement::setToContent(FormulaCursor* cursor)
|
|
{
|
|
cursor->setTo(this, contentPos);
|
|
}
|
|
|
|
// point the cursor to a gap where an index is to be inserted.
|
|
// this makes no sense if there is such an index already.
|
|
|
|
void IndexElement::setToUpperLeft(FormulaCursor* cursor)
|
|
{
|
|
cursor->setTo(this, upperLeftPos);
|
|
}
|
|
|
|
void IndexElement::setToUpperMiddle(FormulaCursor* cursor)
|
|
{
|
|
cursor->setTo(this, upperMiddlePos);
|
|
}
|
|
|
|
void IndexElement::setToUpperRight(FormulaCursor* cursor)
|
|
{
|
|
cursor->setTo(this, upperRightPos);
|
|
}
|
|
|
|
void IndexElement::setToLowerLeft(FormulaCursor* cursor)
|
|
{
|
|
cursor->setTo(this, lowerLeftPos);
|
|
}
|
|
|
|
void IndexElement::setToLowerMiddle(FormulaCursor* cursor)
|
|
{
|
|
cursor->setTo(this, lowerMiddlePos);
|
|
}
|
|
|
|
void IndexElement::setToLowerRight(FormulaCursor* cursor)
|
|
{
|
|
cursor->setTo(this, lowerRightPos);
|
|
}
|
|
|
|
|
|
// move inside an index that exists already.
|
|
|
|
void IndexElement::moveToUpperLeft(FormulaCursor* cursor, Direction direction)
|
|
{
|
|
if (hasUpperLeft()) {
|
|
if (direction == beforeCursor) {
|
|
upperLeft->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
upperLeft->moveRight(cursor, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IndexElement::moveToUpperMiddle(FormulaCursor* cursor, Direction direction)
|
|
{
|
|
if (hasUpperMiddle()) {
|
|
if (direction == beforeCursor) {
|
|
upperMiddle->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
upperMiddle->moveRight(cursor, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IndexElement::moveToUpperRight(FormulaCursor* cursor, Direction direction)
|
|
{
|
|
if (hasUpperRight()) {
|
|
if (direction == beforeCursor) {
|
|
upperRight->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
upperRight->moveRight(cursor, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IndexElement::moveToLowerLeft(FormulaCursor* cursor, Direction direction)
|
|
{
|
|
if (hasLowerLeft()) {
|
|
if (direction == beforeCursor) {
|
|
lowerLeft->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
lowerLeft->moveRight(cursor, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IndexElement::moveToLowerMiddle(FormulaCursor* cursor, Direction direction)
|
|
{
|
|
if (hasLowerMiddle()) {
|
|
if (direction == beforeCursor) {
|
|
lowerMiddle->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
lowerMiddle->moveRight(cursor, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void IndexElement::moveToLowerRight(FormulaCursor* cursor, Direction direction)
|
|
{
|
|
if (hasLowerRight()) {
|
|
if (direction == beforeCursor) {
|
|
lowerRight->moveLeft(cursor, this);
|
|
}
|
|
else {
|
|
lowerRight->moveRight(cursor, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Appends our attributes to the dom element.
|
|
*/
|
|
void IndexElement::writeDom(TQDomElement element)
|
|
{
|
|
BasicElement::writeDom(element);
|
|
|
|
TQDomDocument doc = element.ownerDocument();
|
|
|
|
TQDomElement cont = doc.createElement("CONTENT");
|
|
cont.appendChild(content->getElementDom(doc));
|
|
element.appendChild(cont);
|
|
|
|
if (hasUpperLeft()) {
|
|
TQDomElement ind = doc.createElement("UPPERLEFT");
|
|
ind.appendChild(upperLeft->getElementDom(doc));
|
|
element.appendChild(ind);
|
|
}
|
|
if (hasUpperMiddle()) {
|
|
TQDomElement ind = doc.createElement("UPPERMIDDLE");
|
|
ind.appendChild(upperMiddle->getElementDom(doc));
|
|
element.appendChild(ind);
|
|
}
|
|
if (hasUpperRight()) {
|
|
TQDomElement ind = doc.createElement("UPPERRIGHT");
|
|
ind.appendChild(upperRight->getElementDom(doc));
|
|
element.appendChild(ind);
|
|
}
|
|
if (hasLowerLeft()) {
|
|
TQDomElement ind = doc.createElement("LOWERLEFT");
|
|
ind.appendChild(lowerLeft->getElementDom(doc));
|
|
element.appendChild(ind);
|
|
}
|
|
if (hasLowerMiddle()) {
|
|
TQDomElement ind = doc.createElement("LOWERMIDDLE");
|
|
ind.appendChild(lowerMiddle->getElementDom(doc));
|
|
element.appendChild(ind);
|
|
}
|
|
if (hasLowerRight()) {
|
|
TQDomElement ind = doc.createElement("LOWERRIGHT");
|
|
ind.appendChild(lowerRight->getElementDom(doc));
|
|
element.appendChild(ind);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads our attributes from the element.
|
|
* Returns false if it failed.
|
|
*/
|
|
bool IndexElement::readAttributesFromDom(TQDomElement element)
|
|
{
|
|
if (!BasicElement::readAttributesFromDom(element)) {
|
|
return 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 IndexElement::readContentFromDom(TQDomNode& node)
|
|
{
|
|
if (!BasicElement::readContentFromDom(node)) {
|
|
return false;
|
|
}
|
|
|
|
if ( !buildChild( content, node, "CONTENT" ) ) {
|
|
kdWarning( DEBUGID ) << "Empty content in IndexElement." << endl;
|
|
return false;
|
|
}
|
|
node = node.nextSibling();
|
|
|
|
bool upperLeftRead = false;
|
|
bool upperMiddleRead = false;
|
|
bool upperRightRead = false;
|
|
bool lowerLeftRead = false;
|
|
bool lowerMiddleRead = false;
|
|
bool lowerRightRead = false;
|
|
|
|
while (!node.isNull() &&
|
|
!(upperLeftRead && upperMiddleRead && upperRightRead &&
|
|
lowerLeftRead && lowerMiddleRead && lowerRightRead)) {
|
|
|
|
if (!upperLeftRead && (node.nodeName().upper() == "UPPERLEFT")) {
|
|
upperLeftRead = buildChild( upperLeft=new SequenceElement( this ), node, "UPPERLEFT" );
|
|
if ( !upperLeftRead ) return false;
|
|
}
|
|
|
|
if (!upperMiddleRead && (node.nodeName().upper() == "UPPERMIDDLE")) {
|
|
upperMiddleRead = buildChild( upperMiddle=new SequenceElement( this ), node, "UPPERMIDDLE" );
|
|
if ( !upperMiddleRead ) return false;
|
|
}
|
|
|
|
if (!upperRightRead && (node.nodeName().upper() == "UPPERRIGHT")) {
|
|
upperRightRead = buildChild( upperRight=new SequenceElement( this ), node, "UPPERRIGHT" );
|
|
if ( !upperRightRead ) return false;
|
|
}
|
|
|
|
if (!lowerLeftRead && (node.nodeName().upper() == "LOWERLEFT")) {
|
|
lowerLeftRead = buildChild( lowerLeft=new SequenceElement( this ), node, "LOWERLEFT" );
|
|
if ( !lowerLeftRead ) return false;
|
|
}
|
|
|
|
if (!lowerMiddleRead && (node.nodeName().upper() == "LOWERMIDDLE")) {
|
|
lowerMiddleRead = buildChild( lowerMiddle=new SequenceElement( this ), node, "LOWERMIDDLE" );
|
|
if ( !lowerMiddleRead ) return false;
|
|
}
|
|
|
|
if (!lowerRightRead && (node.nodeName().upper() == "LOWERRIGHT")) {
|
|
lowerRightRead = buildChild( lowerRight=new SequenceElement( this ), node, "LOWERRIGHT" );
|
|
if ( !lowerRightRead ) return false;
|
|
}
|
|
|
|
node = node.nextSibling();
|
|
}
|
|
return upperLeftRead || upperMiddleRead || upperRightRead ||
|
|
lowerLeftRead || lowerMiddleRead || lowerRightRead;
|
|
}
|
|
|
|
bool IndexElement::readAttributesFromMathMLDom( const TQDomElement& element )
|
|
{
|
|
if ( !BasicElement::readAttributesFromMathMLDom( element ) ) {
|
|
return false;
|
|
}
|
|
|
|
TQString tag = element.tagName().stripWhiteSpace().lower();
|
|
if ( tag == "msub" || tag == "msubsup" ) {
|
|
TQString subscriptshiftStr = element.attribute( "subscriptshift" ).stripWhiteSpace().lower();
|
|
if ( ! subscriptshiftStr.isNull() ) {
|
|
m_subScriptShift = getSize( subscriptshiftStr, &m_subScriptShiftType );
|
|
}
|
|
}
|
|
if ( tag == "msup" || tag == "msubsup" ) {
|
|
TQString superscriptshiftStr = element.attribute( "superscriptshift" ).stripWhiteSpace().lower();
|
|
if ( ! superscriptshiftStr.isNull() ) {
|
|
m_superScriptShift = getSize( superscriptshiftStr, &m_superScriptShiftType );
|
|
}
|
|
}
|
|
|
|
if ( tag == "munder" || tag == "munderover" ) {
|
|
TQString accentunderStr = element.attribute( "accentunder" ).stripWhiteSpace().lower();
|
|
if ( ! accentunderStr.isNull() ) {
|
|
if ( accentunderStr == "true" ) {
|
|
m_customAccentUnder = true;
|
|
m_accentUnder = true;
|
|
}
|
|
else if ( accentunderStr == "false" ) {
|
|
m_customAccentUnder = true;
|
|
m_accentUnder = false;
|
|
}
|
|
else {
|
|
kdWarning( DEBUGID ) << "Invalid value for attribute `accentunder': "
|
|
<< accentunderStr << endl;
|
|
}
|
|
}
|
|
}
|
|
if ( tag == "mover" || tag == "munderover" ) {
|
|
TQString accentStr = element.attribute( "accent" ).stripWhiteSpace().lower();
|
|
if ( ! accentStr.isNull() ) {
|
|
if ( accentStr == "true" ) {
|
|
m_customAccent = true;
|
|
m_accent = true;
|
|
}
|
|
else if ( accentStr == "false" ) {
|
|
m_customAccent = true;
|
|
m_accent = false;
|
|
}
|
|
else {
|
|
kdWarning( DEBUGID ) << "Invalid value for attribute `accent': "
|
|
<< accentStr << endl;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Reads our content from the MathML node. Sets the node to the next node
|
|
* that needs to be read. It is sometimes needed to read more than one node
|
|
* (e. g. for fence operators).
|
|
* Returns the number of nodes processed or -1 if it failed.
|
|
*/
|
|
int IndexElement::readContentFromMathMLDom( TQDomNode& node )
|
|
{
|
|
if ( BasicElement::readContentFromMathMLDom( node ) == -1 ) {
|
|
return -1;
|
|
}
|
|
|
|
int contentNumber = content->buildMathMLChild( node );
|
|
if ( contentNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty base in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < contentNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
TQString indexType = node.parentNode().toElement().tagName().lower();
|
|
if ( indexType == "msub" ) {
|
|
lowerRight = new SequenceElement( this );
|
|
int lowerRightNumber = lowerRight->buildMathMLChild( node );
|
|
if ( lowerRightNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty subscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < lowerRightNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
if ( indexType == "msup" ) {
|
|
upperRight = new SequenceElement( this );
|
|
int upperRightNumber = upperRight->buildMathMLChild( node );
|
|
if ( upperRightNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty superscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < upperRightNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
if ( indexType == "msubsup" ) {
|
|
lowerRight = new SequenceElement( this );
|
|
int lowerRightNumber = lowerRight->buildMathMLChild( node );
|
|
if ( lowerRightNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty subscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < lowerRightNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
upperRight = new SequenceElement( this );
|
|
int upperRightNumber = upperRight->buildMathMLChild( node );
|
|
if ( upperRightNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty superscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < upperRightNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
if ( indexType == "munder" ) {
|
|
lowerMiddle = new SequenceElement( this );
|
|
int lowerMiddleNumber = lowerMiddle->buildMathMLChild( node );
|
|
if ( lowerMiddleNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty underscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < lowerMiddleNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
if ( indexType == "mover" ) {
|
|
upperMiddle = new SequenceElement( this );
|
|
int upperMiddleNumber = upperMiddle->buildMathMLChild( node );
|
|
if ( upperMiddleNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty overscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < upperMiddleNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
if ( indexType == "munderover" ) {
|
|
lowerMiddle = new SequenceElement( this );
|
|
int lowerMiddleNumber = lowerMiddle->buildMathMLChild( node );
|
|
if ( lowerMiddleNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty underscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < lowerMiddleNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
|
|
upperMiddle = new SequenceElement( this );
|
|
int upperMiddleNumber = upperMiddle->buildMathMLChild( node );
|
|
if ( upperMiddleNumber == -1 ) {
|
|
kdWarning( DEBUGID ) << "Empty overscript in Script" << endl;
|
|
return -1;
|
|
}
|
|
for (int i = 0; i < upperMiddleNumber; i++ ) {
|
|
if ( node.isNull() ) {
|
|
return -1;
|
|
}
|
|
node = node.nextSibling();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
// TODO: mmultiscripts, section 3.4.7
|
|
return 1;
|
|
}
|
|
|
|
|
|
ElementIndexPtr IndexElement::getIndex( int position )
|
|
{
|
|
switch (position) {
|
|
case upperRightPos:
|
|
return getUpperRight();
|
|
case lowerRightPos:
|
|
return getLowerRight();
|
|
case lowerMiddlePos:
|
|
return getLowerMiddle();
|
|
case upperMiddlePos:
|
|
return getUpperMiddle();
|
|
case lowerLeftPos:
|
|
return getLowerLeft();
|
|
case upperLeftPos:
|
|
return getUpperLeft();
|
|
}
|
|
return getUpperRight();
|
|
}
|
|
|
|
|
|
|
|
TQString IndexElement::toLatex()
|
|
{
|
|
TQString index;
|
|
|
|
if ( hasUpperMiddle() ) {
|
|
index += "\\overset{" + upperMiddle->toLatex() + "}{";
|
|
}
|
|
|
|
if ( hasLowerMiddle() ) {
|
|
index += "\\underset{" + lowerMiddle->toLatex() + "}{";
|
|
}
|
|
|
|
if ( hasUpperLeft() || hasUpperRight() ) { //Not sure that this is possible in Latex!
|
|
/*index += "{}";
|
|
if ( hasUpperLeft() )
|
|
index += "^" + upperLeft->toLatex();
|
|
if ( hasLowerLeft() )
|
|
index += "_" + lowerLeft->toLatex();
|
|
*/
|
|
}
|
|
|
|
index += content->toLatex();
|
|
|
|
if ( hasUpperRight() || hasLowerRight() ) {
|
|
if ( hasUpperRight() )
|
|
index += "^{" + upperRight->toLatex() + "}";
|
|
if ( hasLowerRight() )
|
|
index += "_{" + lowerRight->toLatex() + "}";
|
|
index += " ";
|
|
}
|
|
|
|
if ( hasLowerMiddle() ) {
|
|
index += "}";
|
|
}
|
|
|
|
if ( hasUpperMiddle() ) {
|
|
index += "}";
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
TQString IndexElement::formulaString()
|
|
{
|
|
TQString index = "(" + content->formulaString() + ")";
|
|
if ( hasLowerRight() ) {
|
|
index += "_(" + lowerRight->formulaString() + ")";
|
|
}
|
|
if ( hasUpperRight() ) {
|
|
index += "**(" + upperRight->formulaString() + ")";
|
|
}
|
|
return index;
|
|
}
|
|
|
|
TQString IndexElement::getElementName() const
|
|
{
|
|
if ( hasUpperMiddle() && hasLowerMiddle() )
|
|
return "munderover";
|
|
if ( hasUpperMiddle() )
|
|
return "mover";
|
|
if ( hasLowerMiddle() )
|
|
return "munder";
|
|
if ( hasLowerLeft() || hasUpperLeft() )
|
|
return "mmultiscripts";
|
|
if ( hasLowerRight() || hasUpperRight() ) {
|
|
if ( ! hasUpperRight() )
|
|
return "msub";
|
|
if ( ! hasLowerRight() )
|
|
return "msup";
|
|
}
|
|
return "msubsup";
|
|
}
|
|
|
|
void IndexElement::writeMathMLAttributes( TQDomElement& element ) const
|
|
{
|
|
TQString tag = getElementName();
|
|
if ( tag == "msub" || tag == "msubsup" ) {
|
|
switch ( m_subScriptShiftType ) {
|
|
case AbsoluteSize:
|
|
element.setAttribute( "subscriptshift", TQString( "%1pt" ).arg( m_subScriptShift ) );
|
|
break;
|
|
case RelativeSize:
|
|
element.setAttribute( "subscriptshift", TQString( "%1%" ).arg( m_subScriptShift * 100.0 ) );
|
|
break;
|
|
case PixelSize:
|
|
element.setAttribute( "subscriptshift", TQString( "%1px" ).arg( m_subScriptShift ) );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if ( tag == "msup" || tag == "msubsup" ) {
|
|
switch ( m_superScriptShiftType ) {
|
|
case AbsoluteSize:
|
|
element.setAttribute( "superscriptshift", TQString( "%1pt" ).arg( m_superScriptShift ) );
|
|
break;
|
|
case RelativeSize:
|
|
element.setAttribute( "superscriptshift", TQString( "%1%" ).arg( m_superScriptShift * 100.0 ) );
|
|
break;
|
|
case PixelSize:
|
|
element.setAttribute( "superscriptshift", TQString( "%1px" ).arg( m_superScriptShift ) );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if ( tag == "munder" || tag == "munderover" ) {
|
|
if ( m_customAccentUnder ) {
|
|
element.setAttribute( "accentunder", m_accentUnder ? "true" : "false" );
|
|
}
|
|
}
|
|
if ( tag == "mover" || tag == "munderover" ) {
|
|
if ( m_customAccent ) {
|
|
element.setAttribute( "accent", m_accent ? "true" : "false" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void IndexElement::writeMathMLContent( TQDomDocument& doc,
|
|
TQDomElement& element,
|
|
bool oasisFormat ) const
|
|
{
|
|
TQDomElement de;
|
|
|
|
content->writeMathML( doc, element, oasisFormat ); // base
|
|
if ( hasUpperMiddle() && hasLowerMiddle() )
|
|
{
|
|
lowerMiddle->writeMathML( doc, element, oasisFormat );
|
|
upperMiddle->writeMathML( doc, element,oasisFormat );
|
|
}
|
|
else if ( hasUpperMiddle() )
|
|
{
|
|
upperMiddle->writeMathML( doc, element,oasisFormat );
|
|
}
|
|
else if ( hasLowerMiddle() )
|
|
{
|
|
lowerMiddle->writeMathML( doc, element,oasisFormat );
|
|
}
|
|
|
|
if ( hasLowerLeft() || hasUpperLeft() )
|
|
{
|
|
if ( hasLowerRight() )
|
|
lowerRight->writeMathML( doc, element, oasisFormat );
|
|
else
|
|
element.appendChild( doc.createElement( "none" ) );
|
|
|
|
if ( hasUpperRight() )
|
|
upperRight->writeMathML( doc, element, oasisFormat );
|
|
else
|
|
element.appendChild( doc.createElement( "none" ) );
|
|
|
|
element.appendChild( doc.createElement( "mprescripts" ) );
|
|
|
|
if ( hasLowerLeft() )
|
|
lowerLeft->writeMathML( doc, element, oasisFormat );
|
|
else
|
|
element.appendChild( doc.createElement( "none" ) );
|
|
|
|
if ( hasUpperLeft() )
|
|
upperLeft->writeMathML( doc, element, oasisFormat );
|
|
else
|
|
element.appendChild( doc.createElement( "none" ) );
|
|
}
|
|
else if ( hasLowerRight() || hasUpperRight() )
|
|
{
|
|
if ( !hasUpperRight() ) {
|
|
lowerRight->writeMathML( doc, element, oasisFormat );
|
|
}
|
|
else if ( !hasLowerRight() ) {
|
|
upperRight->writeMathML( doc, element, oasisFormat );
|
|
}
|
|
else // both
|
|
{
|
|
lowerRight->writeMathML( doc, element, oasisFormat );
|
|
upperRight->writeMathML( doc, element,oasisFormat );
|
|
}
|
|
}
|
|
}
|
|
|
|
KFORMULA_NAMESPACE_END
|