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.
441 lines
11 KiB
441 lines
11 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.
|
|
*/
|
|
|
|
#ifndef KFORMULACONTAINER_H
|
|
#define KFORMULACONTAINER_H
|
|
|
|
#include <tqclipboard.h>
|
|
#include <tqdom.h>
|
|
#include <tqimage.h>
|
|
#include <tqptrlist.h>
|
|
#include <tqobject.h>
|
|
#include <tqptrstack.h>
|
|
#include <tqstring.h>
|
|
|
|
#include <kcommand.h>
|
|
//#include <KoCommandHistory.h>
|
|
#include "KoCommandHistory.h"
|
|
#include "kformuladefs.h"
|
|
|
|
class TQColorGroup;
|
|
class TQKeyEvent;
|
|
class TQPainter;
|
|
|
|
class KCommand;
|
|
class KPrinter;
|
|
|
|
KFORMULA_NAMESPACE_BEGIN
|
|
|
|
class BasicElement;
|
|
class Document;
|
|
class FormulaCursor;
|
|
class FormulaElement;
|
|
class IndexElement;
|
|
class PlainCommand;
|
|
class SymbolTable;
|
|
|
|
|
|
/**
|
|
* The interface the elements expect from its document.
|
|
*
|
|
* Please don't mistake this class for Document.
|
|
* This one represents one formula, the other one provides
|
|
* the context in which the formulae exist.
|
|
*/
|
|
class FormulaDocument {
|
|
// not allowed
|
|
FormulaDocument( const FormulaDocument& ) {}
|
|
FormulaDocument& operator=( const FormulaDocument& ) { return *this; }
|
|
public:
|
|
|
|
FormulaDocument() {}
|
|
virtual ~FormulaDocument() {}
|
|
|
|
virtual void elementRemoval(BasicElement* /*child*/) {}
|
|
virtual void changed() {}
|
|
virtual void cursorHasMoved( FormulaCursor* ) {}
|
|
virtual void moveOutLeft( FormulaCursor* ) {}
|
|
virtual void moveOutRight( FormulaCursor* ) {}
|
|
virtual void moveOutAbove( FormulaCursor* ) {}
|
|
virtual void moveOutBelow( FormulaCursor* ) {}
|
|
virtual void tell( const TQString& /*msg*/ ) {}
|
|
virtual void insertFormula( FormulaCursor* ) {}
|
|
virtual void removeFormula( FormulaCursor* ) {}
|
|
virtual void baseSizeChanged( int, bool ) {}
|
|
virtual const SymbolTable& getSymbolTable() const = 0;
|
|
};
|
|
|
|
|
|
/**
|
|
* The document. Actually only one part of the whole.
|
|
* Provides everything to edit the formula.
|
|
*/
|
|
class KOFORMULA_EXPORT Container : public TQObject, public FormulaDocument {
|
|
friend class MimeSource;
|
|
TQ_OBJECT
|
|
|
|
|
|
// no copying
|
|
Container( const Container& );
|
|
Container& operator= ( const Container& );
|
|
|
|
public:
|
|
|
|
enum ViewActions { EXIT_LEFT, EXIT_RIGHT,
|
|
EXIT_ABOVE, EXIT_BELOW,
|
|
INSERT_FORMULA, REMOVE_FORMULA };
|
|
|
|
/**
|
|
* Constructs a new formula and register it with the document.
|
|
*
|
|
* @param doc the document we belong to.
|
|
* @param pos the formulas position inside its document.
|
|
* @param registerMe whether the formula is to be registered
|
|
* with the document.
|
|
*/
|
|
Container( Document* doc, int pos, bool registerMe=true );
|
|
~Container();
|
|
|
|
/**
|
|
* Needs to be called before anything else can be done with a
|
|
* newly created formula! This is required to allow polymorphic
|
|
* formulas. (The virtual method problem.)
|
|
*/
|
|
void initialize();
|
|
|
|
/**
|
|
* Returns a new cursor. It points to the beginning of the
|
|
* formula. The cursor gets no messages if the formula changes
|
|
* so use this with care!
|
|
*/
|
|
FormulaCursor* createCursor();
|
|
|
|
/**
|
|
* Gets called just before the child is removed from
|
|
* the element tree.
|
|
*/
|
|
void elementRemoval(BasicElement* child);
|
|
|
|
/**
|
|
* Gets called when ever something changes and we need to
|
|
* recalc.
|
|
*/
|
|
void changed();
|
|
|
|
/**
|
|
* Gets called when a request has the side effect of moving the
|
|
* cursor. In the end any operation that moves the cursor should
|
|
* call this.
|
|
*/
|
|
void cursorHasMoved( FormulaCursor* );
|
|
|
|
/**
|
|
* Inside the formula occurred an event that must be handled
|
|
* outside.
|
|
*/
|
|
void moveOutLeft( FormulaCursor* );
|
|
void moveOutRight( FormulaCursor* );
|
|
void moveOutAbove( FormulaCursor* );
|
|
void moveOutBelow( FormulaCursor* );
|
|
void tell( const TQString& msg );
|
|
void removeFormula( FormulaCursor* );
|
|
|
|
/**
|
|
* Register and unregister this formula with its document.
|
|
*/
|
|
void registerFormula( int pos=-1 );
|
|
void unregisterFormula();
|
|
|
|
/**
|
|
* The base size changed. If not owned it uses the default one now.
|
|
*/
|
|
void baseSizeChanged( int size, bool owned );
|
|
|
|
/**
|
|
* Draws the whole thing.
|
|
*/
|
|
void draw( TQPainter& painter, const TQRect& r,
|
|
const TQColorGroup& cg, bool edit=false );
|
|
|
|
/**
|
|
* Draws the whole thing.
|
|
*/
|
|
void draw( TQPainter& painter, const TQRect& r, bool edit=false );
|
|
|
|
/**
|
|
* Saves the data into the document.
|
|
*/
|
|
void save( TQDomElement &root );
|
|
|
|
/**
|
|
* Save formula as MathML.
|
|
*/
|
|
void saveMathML( TQTextStream& stream, bool oasisFormat = false );
|
|
|
|
/**
|
|
* Load function.
|
|
* Load the formula from the specified file containing MathML .
|
|
*/
|
|
bool loadMathML( const TQDomDocument &doc, bool oasisFormat = false );
|
|
|
|
/**
|
|
* Load function.
|
|
* Load the formula from the specified file containing MathML .
|
|
*/
|
|
bool loadMathML( const TQDomElement &doc, bool oasisFormat = false );
|
|
|
|
/**
|
|
* Loads a formula from the document.
|
|
*/
|
|
bool load( const TQDomElement &fe );
|
|
|
|
/**
|
|
* @returns Tex string for the formula
|
|
*/
|
|
TQString texString();
|
|
|
|
TQString formulaString();
|
|
|
|
/**
|
|
* Prints the formula.
|
|
*/
|
|
void print(KPrinter& printer);
|
|
|
|
/**
|
|
* @returns an image that looks like out formula.
|
|
*/
|
|
TQImage drawImage( int width, int height );
|
|
|
|
/**
|
|
* @returns the cursor to be used for editing.
|
|
*/
|
|
FormulaCursor* activeCursor();
|
|
const FormulaCursor* activeCursor() const;
|
|
|
|
/**
|
|
* Sets the cursor that is to be used for any editing.
|
|
*
|
|
* The active cursor might 0. In this case you must not
|
|
* request any change from the formula.
|
|
*/
|
|
void setActiveCursor(FormulaCursor* cursor);
|
|
|
|
/**
|
|
* @returns the formula's size.
|
|
*/
|
|
TQRect boundingRect() const;
|
|
|
|
/**
|
|
* @returns the formula's size including its active cursor.
|
|
*/
|
|
TQRect coveredRect();
|
|
|
|
double width() const;
|
|
double height() const;
|
|
|
|
/**
|
|
* @returns the distance between the upper bound and the formulas
|
|
* base line.
|
|
*/
|
|
double baseline() const;
|
|
|
|
/**
|
|
* Moves the formula to a new location. This location will be the
|
|
* upper left corner of the rectangle that is drawn by the painter.
|
|
*/
|
|
void moveTo( int x, int y );
|
|
|
|
/**
|
|
* KWord uses a transformed painter to draw formulas, so every
|
|
* formula has the internal position (0,0). But we might need to
|
|
* sort our formulas according to their position inside the
|
|
* document. (This is only needed for math formulas.)
|
|
*/
|
|
virtual double getDocumentX() const { return -1; }
|
|
virtual double getDocumentY() const { return -1; }
|
|
virtual void setDocumentPosition( double /*x*/, double /*y*/ ) {}
|
|
|
|
/**
|
|
* Start the documents evaluation at this formula. This must be the
|
|
* formula that changed. The formulas above it won't be affected
|
|
* by this change.
|
|
*
|
|
* This has no meaning in not evaluating formulas.
|
|
*/
|
|
virtual void startEvaluation() {}
|
|
|
|
/**
|
|
* Recalcs the formula and emits the .*Changed signals if needed.
|
|
*/
|
|
void testDirty();
|
|
|
|
/**
|
|
* Recalc the formula.
|
|
*/
|
|
virtual void recalc();
|
|
|
|
/**
|
|
* @returns true if there is no element.
|
|
*/
|
|
bool isEmpty();
|
|
|
|
/**
|
|
* @returns the document this formula belongs to.
|
|
*/
|
|
virtual Document* document() const;
|
|
|
|
virtual const SymbolTable& getSymbolTable() const;
|
|
|
|
int fontSize() const;
|
|
|
|
/**
|
|
* Sets the base font size of this formula.
|
|
*/
|
|
void setFontSize( int pointSize, bool forPrint = false );
|
|
|
|
void setFontSizeDirect( int pointSize );
|
|
|
|
/**
|
|
If the cursor is in a matrix, the matrix actions will be enabled, otherwise disabled.
|
|
*/
|
|
void updateMatrixActions();
|
|
|
|
signals:
|
|
|
|
/**
|
|
* The cursor has been moved but the formula hasn't been
|
|
* changed. The view that owns the cursor needs to know this.
|
|
*/
|
|
void cursorMoved(FormulaCursor* cursor);
|
|
|
|
/**
|
|
* The cursor wants to leave this formula.
|
|
*/
|
|
void leaveFormula( Container* formula, FormulaCursor* cursor, int cmd );
|
|
|
|
/**
|
|
* The formula has changed and needs to be redrawn.
|
|
*/
|
|
void formulaChanged( int width, int height );
|
|
void formulaChanged( double width, double height );
|
|
|
|
/**
|
|
* A message that might be a useful hint. Meant for the statusbar.
|
|
*/
|
|
void statusMsg( const TQString& msg );
|
|
|
|
/**
|
|
* A message that describes an error. Meant for a message box. (?)
|
|
*/
|
|
void errorMsg( const TQString& );
|
|
|
|
/**
|
|
* The element is going to leave the formula with and all its children.
|
|
*/
|
|
void elementWillVanish(BasicElement* element);
|
|
|
|
/**
|
|
* Tells the cursors that we have just loaded a new formula.
|
|
*/
|
|
void formulaLoaded(FormulaElement*);
|
|
|
|
/**
|
|
* We've got a new base size.
|
|
*/
|
|
void baseSizeChanged( int );
|
|
|
|
public:
|
|
|
|
/**
|
|
* General input.
|
|
*/
|
|
void input( TQKeyEvent* event );
|
|
|
|
void performRequest( Request* request );
|
|
|
|
// There are a lot of thing we can do with the formula.
|
|
|
|
/**
|
|
* Insert data from the clipboard.
|
|
*/
|
|
void paste();
|
|
|
|
/**
|
|
* Insert data from the document.
|
|
*/
|
|
void paste( const TQDomDocument& document, TQString desc );
|
|
|
|
/**
|
|
* Copy the current selection to the clipboard.
|
|
*/
|
|
void copy();
|
|
|
|
/**
|
|
* Copy and remove.
|
|
*/
|
|
void cut();
|
|
|
|
protected:
|
|
|
|
KoCommandHistory* getHistory() const;
|
|
|
|
/**
|
|
* @returns the root of our element tree. That's the formula's structure.
|
|
*/
|
|
FormulaElement* rootElement() const;
|
|
|
|
/**
|
|
* Factory method.
|
|
*/
|
|
virtual FormulaElement* createMainSequence();
|
|
|
|
void emitErrorMsg( const TQString& );
|
|
|
|
private:
|
|
|
|
/**
|
|
* Execute the command if it makes sense.
|
|
*/
|
|
void execute(KCommand *command);
|
|
|
|
/**
|
|
* Emits a signal if the cursor had moved.
|
|
*/
|
|
void checkCursor();
|
|
|
|
/**
|
|
* @returns true if there is a cursor that is allowed to edit the formula.
|
|
*/
|
|
bool hasValidCursor() const;
|
|
|
|
struct Container_Impl;
|
|
Container_Impl* impl;
|
|
|
|
// debug
|
|
friend class TestFormulaCursor;
|
|
friend class TestFormulaElement;
|
|
friend class TestIndexElement;
|
|
friend class TestCommands;
|
|
};
|
|
|
|
KFORMULA_NAMESPACE_END
|
|
|
|
#endif // KFORMULACONTAINER_H
|