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.
tdewebdev/quanta/parts/kafka/wkafkapart.h

475 lines
17 KiB

/***************************************************************************
wkafkapart.h
-------------------
copyright : (C) 2003, 2004 - Nicolas Deschildre
email : ndeschildre@kdewebdev.org
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef WKAFKAPART_H
#define WKAFKAPART_H
class TDEConfig;
namespace DOM
{
class Node;
}
class Document;
class Node;
class Parser;
class kNodeAttrs;
class NodeModifsSet;
class NodeEnhancer;
struct DTDStruct;
class NodeSelectionInd;
class NodeModifsSet;
#include <tqmap.h>
#include <tqobject.h>
#include <tqptrdict.h>
#include "kafkahtmlpart.h"
/**
* This class assures the synchronisation of the two trees : the quanta and the
* kafka tree.
* By Quanta Node, i mean Node (cf quanta/parser/node.h)
* By Kafka Node, i mean DOM::Node (cf <dom/dom_node.h>)
* It is a singleton class.
*/
class KafkaDocument : public TQObject
{
Q_OBJECT
public:
/** Returns a reference to the KafkaDocument object */
static KafkaDocument* const ref(TQWidget *parent = 0L, TQWidget *widgetParent = 0L, const char *name = 0L)
{
static KafkaDocument *m_ref;
if (!m_ref) m_ref = new KafkaDocument(parent, widgetParent, name);
return m_ref;
}
~KafkaDocument();
/* ----------------------------- LOADING/UNLOADING -----------------------------------------*/
/**
* Builds kafka's own tree from the Quanta tree.
* If the current Document is empty, it will create a minimum tree.
* @param the Document we want to load.
*/
void loadDocument(Document *doc);
/**
* Unloads the kafka tree.
*/
void unloadDocument();
/**
* Reloads the Document.
*/
void reloadDocument();
/**
* Called to get KafkaDocument's state.
* @return Returns true if KafkaDocument is loaded.
*/
bool isLoaded() {return _docLoaded;}
/* ----------------------------------- KAFKA<->QUANTA NODES LINK ----------------------------------*/
/**
* @param _node The DOM::Node we want the attributess.
* @return Return the corresponding kNodeAttrs of the DOM::Node.
*/
kNodeAttrs *getAttrs(DOM::Node _domNode);
/**
* This function search the corresponding quanta Node to the kafka DOM::Node
* @param _domNode The DOM::Node we seek its corresponding Node.
* @return The Node corresponding to _domNode.
*/
Node *getNode(DOM::Node _domNode);
/**
* Connects the domNode to the corresponding Quanta Node with an intermediate class :
* a kNodeAttrs which links the node and the DOM::Node.
* This is MANDATORY, even if node is null, to use this function at each
* DOM::Node insertion !!
* @param domNode The DOM::Node to connect to the Node.
* @param node The Node to connect to the DOM::Node. Can be null.
* @return Returns the kNodeAttr which links them.
*/
kNodeAttrs* connectDomNodeToQuantaNode(DOM::Node domNode, Node *node);
/**
* Disconnects the domNode from its corresponding Quanta Node.
* @param _domNode The DOM::Node to disconnect from its Node.
*/
void disconnectDomNodeFromQuantaNode(DOM::Node _domNode);
/**
* Disconnects all the domNode from their Quanta Node.
*/
void disconnectAllDomNodes();
/* --------------------------- CURSOR AND SELECTION HANDLING --------------------------*/
/**
* Set the cursor and selection coordinates.
* @param nodeSelection The coordinates of the selection and cursor.
*/
void setCursorAndSelection(NodeSelectionInd *nodeSelection);
void setCursor(Node* node, int cursorOffset);
/* --------------------------- KAFKA/QUANTA NODES CREATION -----------------------------*/
/**
* This function build a kafka DOM:::Node from a Quanta Node.
* @param _node The node from which we build the DOM::Node
* @param insertNode Specifies if we should insert the Node.
* @return Returns if the insertion was successful if asked, else true.
*/
bool buildKafkaNodeFromNode(Node *_node, bool insertNode = true);
/**
* This function synchronizes the Node from the DOM::Node. If the Node is a text Node,
* we try to keep its indentation while updating it.
* @param node The Node to synchronize.
* @param domNode The Node is synchronized from this DOM::Node.
*/
void buildNodeFromKafkaNode(Node *node, DOM::Node domNode);
/**
* This function creates and synchronize a Node from the DOM::Node. It adds
* the closing Node if necessary, and the node and its closing Node can surround Nodes
* and thus make them its childs. Usefull when adding a Node on a selected range of Nodes.
* It also create empty Nodes between Nodes.
* @param domNode The Node returned is synchronized from this DOM::Node.
* @param nodeParent The parent Node of the Node returned.
* @param beginNode The new Node will be placed before or within _beginNode.
* @param beginOffset NOT IMLEMENTED If set to 0 or -1, the new Node will be placed before _beginNode,
* else _beginNode will be splitted at offset #beginOffset and the new Node will be placed
* inbetween.
* @param endNode NOT IMPLEMENTED If not null and if the new Node has a closing tag, set the closing node
* after or within endNode.
* @param endOffset NOT IMPLEMENTED If set to -1, the closing node will be placed after _endNode, else _endNode
* will be splitted at offset #endOffset and the closing Node will be placed inbetween.
* @param modifs The NodeModifSet to log the changes made.
* @return Returns the new main Node created from the DOM::Node.
*/
Node * buildNodeFromKafkaNode(DOM::Node domNode, Node *nodeParent,
Node *beginNode, int beginOffset, Node *endNode, int endOffset,
NodeModifsSet *modifs);
/* ------------------------------- TEXT ENTITIES ENCODING/DECODING ---------------------*/
/**
* This function returns the special XML character (e.g. space, <EFBFBD>...)
* from its encoded form (e.g. &nbsp;)
* @return Returns the special character.
*/
TQString getDecodedChar(const TQString &encodedChar);
/**
* This function returns the text decoded from its XML-encoded form.
* @param encodedText The text to decode.
* @param translateWhiteSpacesAndLineBreaks Specifies if whiteSpaces and line breaks should be
* compressed. Set it to false if we are inside PRE tag.
* @param removeLeftWhitespaces Specify if we should remove ALL whitespaces at the left of the string
* e.g. if the current text is the first child of a BLOCK Node (e.g. P)
* @param removeLeftWhitespaces Specify if we should remove ALL whitespaces at the right of the string
* e.g. if the current text is the last child of a BLOCK Node (e.g. P)
* @return Returns the text decoded.
*/
TQString getDecodedText(const TQString &encodedText, bool translateWhiteSpacesAndLineBreaks = true,
bool removeLeftWhitespaces = false, bool removeRightWhitespaces = false);
/**
* This function returns the XML-encoded character (e.g. &nbsp;)
* from the XML special character (e.g. space, <EFBFBD>...)
* @param decodedChar The character to encode.
* @param previousDecodedchar The previous decoded character.
* @return Returns the XML-encoded character.
*/
TQString getEncodedChar(const TQString &decodedChar, const TQString &previousDecodedChar);
/**
* This function returns the text with all the special XML characters encoded.
* @param decodedText The text to encode.
* @param bLine The start line of the returned encoded text.
* @param bCol The start col of the returned encoded text.
* @param eLine Returns the end line of the returned encoded text.
* @param eCol Returns the end col of the return encoded text.
* @param translateWhiteSpaces Specifies if we should translate the whitespaces
* into &nbsp; Set it to false for PRE Tag.
* @return Return the XML-encoded text.
*/
TQString getEncodedText(const TQString &decodedText, int bLine, int bCol, int &eLine, int &eCol,
bool translateWhiteSpaces = true);
/**
* This function behaves essentially like the above function except that it doesn't
* return the position of the encoded text.
*/
TQString getEncodedText(const TQString &decodedText);
/**
* This function generates the code corresponding to the XML node.
* @param _node The Node we want to generate its code.
* @param bLine The start line of the returned generated code.
* @param bCol The start col of the returned generated code.
* @param eLine Returns the end line of the returned generated code.
* @param eCol Returns the end col of the return generated code.
* @param encodeText Specify, if node is a Text Node, if we should encode the text
* (e.g. whitespace => &nbsp;)
* @return Returns the code.
*/
TQString generateCodeFromNode(Node *node, int bLine, int bCol, int &eLine, int &eCol,
bool encodeText = true);
/* ------------------------- KAFKA<->QUANTA POSITION TRANSLATION -------------------------------*/
/**
* Returns the kafka cursor position corresponding to the quanta cursor position.
* @param line The quanta line cursor position.
* @param col The quanta column cursor position.
* @param domNode Returns the DOM::Node in which the cursor is located.
* @param offset Returns the offset of the cursor.
*/
void translateQuantaIntoKafkaCursorPosition(uint line, uint col, DOM::Node &domNode, long &offset);
/**
* Returns the internal Node offset corresponding to the Quanta cursor position.
* @param line The quanta line cursor position.
* @param col The quanta column cursor position.
* @param node Returns the node where is located the node internal offset.
* @param offset Returns the node internal corresponding offset.
*/
void translateQuantaIntoNodeCursorPosition(uint line, uint col, Node **node, long &offset);
/**
* Returns the internal Node offset corresponding to the kafka cursor position.
* @param domNode The kafka DOM::Node cursor position.
* @param domNodeOffset The kafka offset cursor position.
* @param node Returns the node where is located the node internal offset.
* @param offset Returns the node internal corresponding offset.
*/
void translateKafkaIntoNodeCursorPosition(DOM::Node domNode, long domNodeOffset, Node **node, long &offset);
/**
* Returns the quanta cursor position corresponding to the kafka cursor position.
* @param domNode The kafka DOM::Node cursor position.
* @param offset The kafka offset cursor position.
* @param line Returns the line cursor position.
* @param col Returns the col cursor position.
*/
void translateKafkaIntoQuantaCursorPosition(DOM::Node domNode, int offset, int &line, int &col);
/**
* Returns the kafka cursor position corresponding to the internal Node offset.
* @param node The node.
* @param offset The internal offset of Node.
* @param domNode Returns the corresponding DOM::Node of node. Can be null.
* @param domNodeOffset Returns the offset inside the DOM::Node.
*/
void translateNodeIntoKafkaCursorPosition(Node *node, int offset, DOM::Node &domNode,
long &domNodeOffset);
/**
* Returns the quanta cursor position corresponding to the internal Node offset.
* @param node The node.
* @param offset The internal offset of Node.
* @param line Returns the line position of the corresponding Quanta cursor.
* @param col Returns the col position of the corresponding Quanta cursor.
*/
void translateNodeIntoQuantaCursorPosition(Node *node, int offset, uint &line, uint &col);
/** ----------------- DOM::NODE TREE MODIFICATIONS --------------------*/
/**
* Insert a DOM::Node in the DOM::Node tree. It takes care to handle the exceptions and
* to postEnhance (cf htmlenhancer.h)
* @param node The node to insert.
* @param parent The new parent of node. If null, insert node at the top level.
* @param nextSibling The new next sibling of node. If null, append node at the end of the child list.
* @param rootNode The root DOM::Node of the DOM::Node tree. Useful when no parent is provided.
* @return Returns true if the operation was successfull.
*/
bool insertDomNode(DOM::Node node, DOM::Node parent = DOM::Node(),
DOM::Node nextSibling = DOM::Node(), DOM::Node rootNode = DOM::Node());
/**
* Removes a DOM::Node from the DOM::Node Tree. It takes care to handle the exceptions
* and to postUnenhance (cf htmlenhancer.h)
* @param node The Node to remove from the tree.
* @retun Returns true if the operation was successfull..
*/
bool removeDomNode(DOM::Node node);
/** ------------------ DOM::NODE TREE NAVIGATION -----------------------------------------*/
/**
* @param domNode The DOM::Node the search starts from.
* @return Returns the next previous sibling which has no special behavior (cf htmlenhancer.h)
* Sibling here (contrary to node.h) has the same meaning as in dom/dom_node.h
*/
DOM::Node getPrevSiblingNSpecial(DOM::Node domNode);
/**
* @param domNode The DOM::Node the search starts from.
* @return Returns the next next sibling which has no special behavior (cf htmlenhancer.h)
* Sibling here (contrary to node.h) has the same meaning as in dom/dom_node.h
*/
DOM::Node getNextSiblingNSpecial(DOM::Node domNode);
/* --------------------------------- MISCELLANEOUS ------------------------------------------*/
/**
* Read the config.
* @param m_config The config to read.
*/
void readConfig(TDEConfig *m_config);
/**
* Returns the default DTD of the current Document.
*/
const DTDStruct* defaultDTD();
/**
* @return Returns the current KafkaWidget.
*/
KafkaWidget *getKafkaWidget() {return m_kafkaPart;}
/**
* @return Returns the current Document.
*/
Document *getCurrentDoc() {return m_currentDoc;}
/**
* Prints in stdout the current Node tree + Node->DOM::Node->Node relationship.
* @node The startNode
* @indent The number of little dots per parent relationship.
*/
void coutLinkTree(Node *node, int indent);
/**
* In order to have tdehtml works whatever DTD is loaded, they must always exists
* and be valid.
*/
DOM::Node html, body, head;
signals:
/**
* Emitted when an error occurs when loading kafka. Can be called multiple times.
* @param node The node which caused this error.
*/
void loadingError(Node *node);
/**
* Called whenever a DOM::Node get the focus
*/
void newCursorPosition(int col, int row);
/**
* Called whenever a DOM::Node get the focus
*/
void nodeGetFocus(Node *_node);
/**
* Called when the wKafkaPart is loaded.
*/
void loaded();
/**
* Called when the wKafkaPart is unloaded.
*/
void unloaded();
public slots:
/**
* Called whenever a DOM::Node is inserted in the Kafka tree.
* @param domNode is the Node inserted.
* @param insertChilds Specifies if the _domNode's child should be inserted
* @param modifs The changes made are logged into modifs.
*/
void slotDomNodeInserted(DOM::Node domNode, bool insertChilds, NodeModifsSet *modifs);
/**
* Called whenever DOM::Node's attributes are modified.
* @param domNode is the Node modified.
* @param modifs The changes made are logged into modifs.
*/
void slotDomNodeModified(DOM::Node domNode, NodeModifsSet *modifs);
/**
* Called whenever a DOM::Node is about to be removed from the Kafka tree.
* @param domNode is the Node to be deleted.
* @param deleteChilds Specifies if we should delete the child nodes of _node
* @param modifs The changes made are logged into modifs.
*/
void slotDomNodeAboutToBeRemoved(DOM::Node domNode, bool deleteChilds, NodeModifsSet *modifs);
/**
* Called whenever a DOM::Node is moved.
* @param domNode The DOM::Node to move.
* @param newParent The new parent DOM::Node of domNode.
* @param before domNode will be inserted before before.
* @param modifs The changes made are logged into modifs.
*/
void slotDomNodeIsAboutToBeMoved(DOM::Node domNode, DOM::Node newParent, DOM::Node before, NodeModifsSet *modifs);
/**
* Called whenever a DOM::Node get the focus
*/
void slotdomNodeNewCursorPos(DOM::Node _domNode, int offset);
void slotCut();
void slotCopy();
void slotPaste();
void slotCut(Node* startNode, int startOffset, Node* endNode, int endOffset,
Node** cursorNode, long cursorOffset, TQString const& plainText);
void slotCopy(Node* startNode, int startOffset, Node* endNode, int endOffset, TQString const& plainText);
public:
//use a TQPtrList aferwards
NodeEnhancer *mainEnhancer;
private:
/**
* Create a KafkaWidget.
*/
KafkaDocument(TQWidget *parent, TQWidget *widgetParent, const char *name);
TQMap<TQString, TQString> decodedChars;
TQMap<TQString, TQString> encodedChars;
TQPtrDict<kNodeAttrs> domNodeProps;
TQGuardedPtr<KafkaWidget> m_kafkaPart;
Document *m_currentDoc;
bool _docLoaded;
};
#endif