You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/lib/kotext/KoRichText.h

852 lines
24 KiB

/****************************************************************************
**
** Definition of internal rich text classes
**
** Created : 990124
**
** Copyright (C) 1999-2000 Trolltech AS. All rights reserved.
**
** This file is part of the kernel module of the TQt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.TQPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as publish by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition
** licenses may use this file in accordance with the TQt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
** information about TQt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for TQPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#ifndef KORICHTEXT_H
#define KORICHTEXT_H
#include <tqptrlist.h>
#include <tqrect.h>
#include <tqmap.h>
#include <tqstringlist.h>
#include <tqcolor.h>
#include <tqsize.h>
#include <tqvaluelist.h>
#include <tqobject.h>
#include <tqstylesheet.h>
#include <tqpainter.h>
#include "KoComplexText.h"
#include <koffice_export.h>
class KoXmlWriter;
class KoGenStyles;
class KoTextParag;
class KoTextString;
class KoTextCursor;
class KoTextCustomItem;
class KoTextFlow;
class KoTextDocument;
//class KoTextPreProcessor;
class KoTextFormatterBase;
class KoTextFormat;
class KoTextFormatCollection;
struct KoBidiContext;
//// kotext additions (needed by the #included headers)
class KCommand;
class TQDomElement;
class KoTextZoomHandler;
class KoTextFormatter;
class KoParagVisitor;
class KoTextDocCommand;
class KoXmlWriter;
class KoSavingContext;
#include <tqmemarray.h>
#include "KoParagLayout.h"
////
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class KOTEXT_EXPORT KoTextStringChar
{
friend class KoTextString;
public:
// this is never called, initialize variables in KoTextString::insert()!!!
KoTextStringChar() : lineStart( 0 ), type( Regular ), startOfRun( 0 ) {d.format=0; }
~KoTextStringChar();
TQChar c;
// this is the same struct as in qtextengine_p.h. Don't change!
uchar softBreak :1; // Potential linebreak point
uchar whiteSpace :1; // A unicode whitespace character, except NBSP, ZWNBSP
uchar charStop :1; // Valid cursor position (for left/right arrow)
uchar wordStop :1; // Valid cursor position (for ctrl + left/right arrow) (TODO: use)
//uchar nobreak :1;
enum Type { Regular, Custom };
uint lineStart : 1;
Type type : 1;
uint startOfRun : 1;
uint rightToLeft : 1;
// --- added for WYSIWYG ---
TQ_INT8 pixelxadj; // adjustment to apply to lu2pixel(x)
short int pixelwidth; // width in pixels
short int width; // width in LU
int x;
int height() const;
int ascent() const;
int descent() const;
bool isCustom() const { return type == Custom; }
KoTextFormat *format() const;
KoTextCustomItem *customItem() const;
void setFormat( KoTextFormat *f,bool setFormatAgain=TRUE );
void setCustomItem( KoTextCustomItem *i );
void loseCustomItem();
struct CustomData
{
KoTextFormat *format;
KoTextCustomItem *custom;
};
union {
KoTextFormat* format;
CustomData* custom;
} d;
private:
KoTextStringChar &operator=( const KoTextStringChar & ) {
//abort();
return *this;
}
KoTextStringChar( const KoTextStringChar & ); // copy-constructor, forbidden
friend class KoComplexText;
friend class KoTextParag;
};
#if defined(TQ_TEMPLATEDLL)
// MOC_SKIP_BEGIN
template class TQMemArray<KoTextStringChar>;
// MOC_SKIP_END
#endif
class KOTEXT_EXPORT KoTextString
{
public:
KoTextString();
KoTextString( const KoTextString &s );
virtual ~KoTextString();
TQString toString() const;
static TQString toString( const TQMemArray<KoTextStringChar> &data );
TQString toReverseString() const;
TQString stringToSpellCheck();
KoTextStringChar &at( int i ) const;
int length() const;
//int width( int idx ) const; // moved to KoTextFormat
void insert( int index, const TQString &s, KoTextFormat *f );
void insert( int index, KoTextStringChar *c );
void truncate( int index );
void remove( int index, int len );
void clear();
void setFormat( int index, KoTextFormat *f, bool useCollection, bool setFormatAgain = FALSE );
void setBidi( bool b ) { bidi = b; }
bool isBidi() const;
bool isRightToLeft() const;
TQChar::Direction direction() const;
void setDirection( TQChar::Direction d ) { dir = d; bidiDirty = TRUE; }
/** Set dirty flag for background spell-checking */
void setNeedsSpellCheck( bool b ) { bNeedsSpellCheck = b; }
bool needsSpellCheck() const { return bNeedsSpellCheck; }
TQMemArray<KoTextStringChar> subString( int start = 0, int len = 0xFFFFFF ) const;
TQString mid( int start = 0, int len = 0xFFFFFF ) const; // kotext addition
TQMemArray<KoTextStringChar> rawData() const { return data.copy(); }
void operator=( const TQString &s ) { clear(); insert( 0, s, 0 ); }
void operator+=( const TQString &s );
void prepend( const TQString &s ) { insert( 0, s, 0 ); }
// return next and previous valid cursor positions.
bool validCursorPosition( int idx );
int nextCursorPosition( int idx );
int previousCursorPosition( int idx );
private:
void checkBidi() const;
TQMemArray<KoTextStringChar> data;
uint bidiDirty : 1;
uint bidi : 1; // true when the paragraph has right to left characters
uint rightToLeft : 1;
uint dir : 5;
uint bNeedsSpellCheck : 1;
};
inline bool KoTextString::isBidi() const
{
if ( bidiDirty )
checkBidi();
return bidi;
}
inline bool KoTextString::isRightToLeft() const
{
if ( bidiDirty )
checkBidi();
return rightToLeft;
}
inline TQChar::Direction KoTextString::direction() const
{
return (TQChar::Direction) dir;
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class KOTEXT_EXPORT KoTextCursor
{
public:
KoTextCursor( KoTextDocument *d );
KoTextCursor();
KoTextCursor( const KoTextCursor &c );
KoTextCursor &operator=( const KoTextCursor &c );
virtual ~KoTextCursor() {}
bool operator==( const KoTextCursor &c ) const;
bool operator!=( const KoTextCursor &c ) const { return !(*this == c); }
KoTextDocument *document() const { return doc; }
void setDocument( KoTextDocument *d );
KoTextParag *parag() const;
int index() const;
void setParag( KoTextParag *s, bool restore = TRUE );
void gotoLeft();
void gotoRight();
void gotoNextLetter();
void gotoPreviousLetter();
void gotoUp();
void gotoDown();
void gotoLineEnd();
void gotoLineStart();
void gotoHome();
void gotoEnd();
void gotoPageUp( int visibleHeight );
void gotoPageDown( int visibleHeight );
void gotoNextWord();
void gotoPreviousWord();
void gotoWordLeft();
void gotoWordRight();
void insert( const TQString &s, bool checkNewLine, TQMemArray<KoTextStringChar> *formatting = 0 );
void splitAndInsertEmptyParag( bool ind = TRUE, bool updateIds = TRUE );
bool remove();
bool removePreviousChar();
void killLine();
//void indent();
bool atParagStart() const;
bool atParagEnd() const;
void setIndex( int i, bool restore = TRUE );
//void checkIndex();
//int offsetX() const { return ox; }
//int offsetY() const { return oy; }
bool place( const TQPoint &pos, KoTextParag *s, bool link = false, int *customItemIndex = 0 );
int x() const;
int y() const;
void fixCursorPosition();
private:
KoTextParag *string;
KoTextDocument *doc;
int idx, tmpIndex;
//int ox, oy;
};
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class KoTextDocCommand
{
public:
enum Commands { Invalid, Insert, Delete, Format, Alignment, ParagType };
KoTextDocCommand( KoTextDocument *d ) : doc( d ), cursor( d ) {}
virtual ~KoTextDocCommand() {}
virtual Commands type() const { return Invalid; };
virtual KoTextCursor *execute( KoTextCursor *c ) = 0;
virtual KoTextCursor *unexecute( KoTextCursor *c ) = 0;
protected:
KoTextDocument *doc;
KoTextCursor cursor;
};
#if defined(TQ_TEMPLATEDLL)
// MOC_SKIP_BEGIN
template class TQPtrList<KoTextDocCommand>;
// MOC_SKIP_END
#endif
class KoTextDocCommandHistory
{
public:
KoTextDocCommandHistory( int s ) : current( -1 ), steps( s ) { history.setAutoDelete( TRUE ); }
virtual ~KoTextDocCommandHistory() { clear(); }
void clear() { history.clear(); current = -1; }
void addCommand( KoTextDocCommand *cmd );
KoTextCursor *undo( KoTextCursor *c );
KoTextCursor *redo( KoTextCursor *c );
bool isUndoAvailable();
bool isRedoAvailable();
void setUndoDepth( int d ) { steps = d; }
int undoDepth() const { return steps; }
int historySize() const { return history.count(); }
int currentPosition() const { return current; }
private:
TQPtrList<KoTextDocCommand> history;
int current, steps;
};
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include "KoTextCustomItem.h"
#if defined(TQ_TEMPLATEDLL)
// MOC_SKIP_BEGIN
template class TQMap<TQString, TQString>;
// MOC_SKIP_END
#endif
#if 0
class KoTextImage : public KoTextCustomItem
{
public:
KoTextImage( KoTextDocument *p, const TQMap<TQString, TQString> &attr, const TQString& context,
TQMimeSourceFactory &factory );
virtual ~KoTextImage();
Placement placement() const { return place; }
//void setPainter( TQPainter*, bool );
int widthHint() const { return width; }
int minimumWidth() const { return width; }
TQString richText() const;
void draw( TQPainter* p, int x, int y, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected );
private:
TQRegion* reg;
TQPixmap pm;
Placement place;
int tmpwidth, tmpheight;
TQMap<TQString, TQString> attributes;
TQString imgId;
};
#endif
class KoTextHorizontalLine : public KoTextCustomItem
{
public:
KoTextHorizontalLine( KoTextDocument *p, const TQMap<TQString, TQString> &attr, const TQString& context,
TQMimeSourceFactory &factory );
virtual ~KoTextHorizontalLine();
//void setPainter( TQPainter*, bool );
void draw(TQPainter* p, int x, int y, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected );
TQString richText() const;
bool ownLine() const { return TRUE; }
private:
int tmpheight;
TQColor color;
};
#if defined(TQ_TEMPLATEDLL)
// MOC_SKIP_BEGIN
template class TQPtrList<KoTextCustomItem>;
// MOC_SKIP_END
#endif
class KOTEXT_EXPORT KoTextFlow
{
friend class KoTextDocument;
friend class KoTextTableCell;
public:
KoTextFlow();
virtual ~KoTextFlow();
// Called by KoTextDocument::setWidth()
virtual void setWidth( int width );
// This is the value returned by KoTextDocument::width()
int width() const { return w; }
//virtual void setPageSize( int ps );
//int pageSize() const { return pagesize; }
/**
* Called by the formatter to find out the left and right margin for a paragraph at ( yp, yp+h )
* @param leftMargin returns the left margin
* @param rightMargin returns the right margin (from the page width)
* @param pageWidth returns the page width at that point
* This method merges TQRichText's adjustLMargin and adjustRMargin for efficiency reasons
*/
virtual void adjustMargins( int yp, int h, int reqMinWidth, int& leftMargin, int& rightMargin, int& pageWidth, KoTextParag* parag );
virtual void registerFloatingItem( KoTextCustomItem* item );
virtual void unregisterFloatingItem( KoTextCustomItem* item );
//virtual TQRect boundingRect() const;
/// kotext addition. Allows the textformatter to stop when it goes too far.
virtual int availableHeight() const;
virtual void drawFloatingItems(TQPainter* p, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected );
virtual int adjustFlow( int y, int w, int h ); // adjusts y according to the defined pagesize. Returns the shift.
virtual bool isEmpty();
void clear();
private:
int w;
//int pagesize;
TQPtrList<KoTextCustomItem> leftItems;
TQPtrList<KoTextCustomItem> rightItems;
};
#ifdef TQTEXTTABLE_AVAILABLE
class KoTextTable;
class KoTextTableCell : public TQLayoutItem
{
friend class KoTextTable;
public:
KoTextTableCell( KoTextTable* table,
int row, int column,
const TQMap<TQString, TQString> &attr,
const TQStyleSheetItem* style,
const KoTextFormat& fmt, const TQString& context,
TQMimeSourceFactory &factory, TQStyleSheet *sheet, const TQString& doc );
KoTextTableCell( KoTextTable* table, int row, int column );
virtual ~KoTextTableCell();
TQSize sizeHint() const ;
TQSize minimumSize() const ;
TQSize maximumSize() const ;
TQSizePolicy::ExpandData expanding() const;
bool isEmpty() const;
void setGeometry( const TQRect& ) ;
TQRect geometry() const;
bool hasHeightForWidth() const;
int heightForWidth( int ) const;
void setPainter( TQPainter*, bool );
int row() const { return row_; }
int column() const { return col_; }
int rowspan() const { return rowspan_; }
int colspan() const { return colspan_; }
int stretch() const { return stretch_; }
KoTextDocument* richText() const { return richtext; }
KoTextTable* table() const { return parent; }
void draw( int x, int y, int cx, int cy, int cw, int ch, const TQColorGroup& cg, bool selected );
TQBrush *backGround() const { return background; }
virtual void invalidate();
int verticalAlignmentOffset() const;
int horizontalAlignmentOffset() const;
private:
TQPainter* painter() const;
TQRect geom;
KoTextTable* parent;
KoTextDocument* richtext;
int row_;
int col_;
int rowspan_;
int colspan_;
int stretch_;
int maxw;
int minw;
bool hasFixedWidth;
TQBrush *background;
int cached_width;
int cached_sizehint;
TQMap<TQString, TQString> attributes;
int align;
};
#if defined(TQ_TEMPLATEDLL)
// MOC_SKIP_BEGIN
template class TQPtrList<KoTextTableCell>;
template class TQMap<KoTextCursor*, int>;
// MOC_SKIP_END
#endif
class KoTextTable: public KoTextCustomItem
{
friend class KoTextTableCell;
public:
KoTextTable( KoTextDocument *p, const TQMap<TQString, TQString> &attr );
virtual ~KoTextTable();
void setPainter( TQPainter *p, bool adjust );
void pageBreak( int y, KoTextFlow* flow );
void draw( TQPainter* p, int x, int y, int cx, int cy, int cw, int ch,
const TQColorGroup& cg, bool selected );
bool noErase() const { return TRUE; }
bool ownLine() const { return TRUE; }
Placement placement() const { return place; }
bool isNested() const { return TRUE; }
void resize( int nwidth );
virtual void invalidate();
/// ## TQString anchorAt( TQPainter* p, int x, int y );
virtual bool enter( KoTextCursor *c, KoTextDocument *&doc, KoTextParag *&parag, int &idx, int &ox, int &oy, bool atEnd = FALSE );
virtual bool enterAt( KoTextCursor *c, KoTextDocument *&doc, KoTextParag *&parag, int &idx, int &ox, int &oy, const TQPoint &pos );
virtual bool next( KoTextCursor *c, KoTextDocument *&doc, KoTextParag *&parag, int &idx, int &ox, int &oy );
virtual bool prev( KoTextCursor *c, KoTextDocument *&doc, KoTextParag *&parag, int &idx, int &ox, int &oy );
virtual bool down( KoTextCursor *c, KoTextDocument *&doc, KoTextParag *&parag, int &idx, int &ox, int &oy );
virtual bool up( KoTextCursor *c, KoTextDocument *&doc, KoTextParag *&parag, int &idx, int &ox, int &oy );
TQString richText() const;
int minimumWidth() const { return layout ? layout->minimumSize().width() : 0; }
int widthHint() const { return ( layout ? layout->sizeHint().width() : 0 ) + 2 * outerborder; }
TQPtrList<KoTextTableCell> tableCells() const { return cells; }
TQRect geometry() const { return layout ? layout->geometry() : TQRect(); }
bool isStretching() const { return stretch; }
private:
void format( int &w );
void addCell( KoTextTableCell* cell );
private:
TQGridLayout* layout;
TQPtrList<KoTextTableCell> cells;
TQPainter* painter;
int cachewidth;
int fixwidth;
int cellpadding;
int cellspacing;
int border;
int outerborder;
int stretch;
int innerborder;
int us_cp, us_ib, us_b, us_ob, us_cs;
TQMap<TQString, TQString> attributes;
TQMap<KoTextCursor*, int> currCell;
Placement place;
void adjustCells( int y , int shift );
int pageBreakFor;
};
#endif // TQTEXTTABLE_AVAILABLE
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class KoTextTableCell;
struct KoTextDocumentSelection
{
KoTextCursor startCursor, endCursor;
bool swapped;
};
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class KOTEXT_EXPORT KoTextDocDeleteCommand : public KoTextDocCommand
{
public:
KoTextDocDeleteCommand( KoTextDocument *d, int i, int idx, const TQMemArray<KoTextStringChar> &str );
//KoTextDocDeleteCommand( KoTextParag *p, int idx, const TQMemArray<KoTextStringChar> &str );
virtual ~KoTextDocDeleteCommand();
Commands type() const { return Delete; }
KoTextCursor *execute( KoTextCursor *c );
KoTextCursor *unexecute( KoTextCursor *c );
protected:
int id, index;
KoTextParag *parag;
TQMemArray<KoTextStringChar> text;
};
#if 0
class KoTextDocInsertCommand : public KoTextDocDeleteCommand
{
public:
KoTextDocInsertCommand( KoTextDocument *d, int i, int idx, const TQMemArray<KoTextStringChar> &str )
: KoTextDocDeleteCommand( d, i, idx, str ) {}
KoTextDocInsertCommand( KoTextParag *p, int idx, const TQMemArray<KoTextStringChar> &str )
: KoTextDocDeleteCommand( p, idx, str ) {}
virtual ~KoTextDocInsertCommand() {}
Commands type() const { return Insert; }
KoTextCursor *execute( KoTextCursor *c ) { return KoTextDocDeleteCommand::unexecute( c ); }
KoTextCursor *unexecute( KoTextCursor *c ) { return KoTextDocDeleteCommand::execute( c ); }
};
#endif
class KoTextDocFormatCommand : public KoTextDocCommand
{
public:
KoTextDocFormatCommand( KoTextDocument *d, int sid, int sidx, int eid, int eidx, const TQMemArray<KoTextStringChar> &old, const KoTextFormat *f, int fl );
virtual ~KoTextDocFormatCommand();
Commands type() const { return Format; }
KoTextCursor *execute( KoTextCursor *c );
KoTextCursor *unexecute( KoTextCursor *c );
protected:
int startId, startIndex, endId, endIndex;
KoTextFormat *format;
TQMemArray<KoTextStringChar> oldFormats;
int flags;
};
class KoTextAlignmentCommand : public KoTextDocCommand
{
public:
KoTextAlignmentCommand( KoTextDocument *d, int fParag, int lParag, int na, const TQMemArray<int> &oa );
virtual ~KoTextAlignmentCommand() {}
Commands type() const { return Alignment; }
KoTextCursor *execute( KoTextCursor *c );
KoTextCursor *unexecute( KoTextCursor *c );
private:
int firstParag, lastParag;
int newAlign;
TQMemArray<int> oldAligns;
};
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
struct KoTextParagLineStart
{
KoTextParagLineStart() : y( 0 ), baseLine( 0 ), h( 0 ), lineSpacing( 0 ), hyphenated( false )
#ifndef TQT_NO_COMPLEXTEXT
, bidicontext( 0 )
#endif
{ }
KoTextParagLineStart( ushort y_, ushort bl, ushort h_ ) : y( y_ ), baseLine( bl ), h( h_ ),
lineSpacing( 0 ), hyphenated( false ),
w( 0 )
#ifndef TQT_NO_COMPLEXTEXT
, bidicontext( 0 )
#endif
{ }
#ifndef TQT_NO_COMPLEXTEXT
KoTextParagLineStart( KoBidiContext *c, KoBidiStatus s ) : y(0), baseLine(0), h(0),
lineSpacing( 0 ), hyphenated( false ),
status( s ), bidicontext( c ) { if ( bidicontext ) bidicontext->ref(); }
#endif
virtual ~KoTextParagLineStart()
{
#ifndef TQT_NO_COMPLEXTEXT
if ( bidicontext && bidicontext->deref() )
delete bidicontext;
#endif
}
#ifndef TQT_NO_COMPLEXTEXT
void setContext( KoBidiContext *c ) {
if ( c == bidicontext )
return;
if ( bidicontext && bidicontext->deref() )
delete bidicontext;
bidicontext = c;
if ( bidicontext )
bidicontext->ref();
}
KoBidiContext *context() const { return bidicontext; }
#endif
public:
ushort y, baseLine, h;
short lineSpacing;
bool hyphenated;
#ifndef TQT_NO_COMPLEXTEXT
KoBidiStatus status;
#endif
int w;
private:
#ifndef TQT_NO_COMPLEXTEXT
KoBidiContext *bidicontext;
#endif
};
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class KOTEXT_EXPORT KoTextFormatterBase
{
public:
KoTextFormatterBase();
virtual ~KoTextFormatterBase() {}
virtual bool format( KoTextDocument *doc, KoTextParag *parag, int start, const TQMap<int, KoTextParagLineStart*> &oldLineStarts, int& y, int& widthUsed ) = 0;
virtual int formatVertically( KoTextDocument* doc, KoTextParag* parag );
// Called after formatting a paragraph
virtual void postFormat( KoTextParag* parag ) = 0;
int wrapAtColumn() const { return wrapColumn;}
//virtual void setWrapEnabled( bool b ) { wrapEnabled = b; }
virtual void setWrapAtColumn( int c ) { wrapColumn = c; }
virtual void setAllowBreakInWords( bool b ) { biw = b; }
bool allowBreakInWords() const { return biw; }
// This setting is passed to KoTextParag::fixParagWidth by postFormat()
void setViewFormattingChars( bool b ) { m_bViewFormattingChars = b; }
bool viewFormattingChars() const { return m_bViewFormattingChars; }
/*virtual*/ bool isBreakable( KoTextString *string, int pos ) const;
/*virtual*/ bool isStretchable( KoTextString *string, int pos ) const;
protected:
//virtual KoTextParagLineStart *formatLine( KoTextParag *parag, KoTextString *string, KoTextParagLineStart *line, KoTextStringChar *start,
// KoTextStringChar *last, int align = AlignAuto, int space = 0 );
//KoTextStringChar
#ifndef TQT_NO_COMPLEXTEXT
virtual KoTextParagLineStart *bidiReorderLine( KoTextParag *parag, KoTextString *string, KoTextParagLineStart *line, KoTextStringChar *start,
KoTextStringChar *last, int align, int space );
#endif
private:
int wrapColumn;
//bool wrapEnabled;
bool m_bViewFormattingChars;
bool biw;
bool unused; // for future extensions
#ifdef HAVE_THAI_BREAKS
static TQCString *thaiCache;
static KoTextString *cachedString;
static ThBreakIterator *thaiIt;
#endif
};
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
inline int KoTextString::length() const
{
return data.size();
}
inline void KoTextString::operator+=( const TQString &s )
{
insert( length(), s, 0 );
}
inline KoTextParag *KoTextCursor::parag() const
{
return string;
}
inline int KoTextCursor::index() const
{
return idx;
}
inline void KoTextCursor::setParag( KoTextParag *s, bool /*restore*/ )
{
idx = 0;
string = s;
tmpIndex = -1;
}
//inline void KoTextCursor::checkIndex()
//{
// if ( idx >= string->length() )
// idx = string->length() - 1;
//}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
inline KoTextStringChar &KoTextString::at( int i ) const
{
return data[ i ];
}
inline TQString KoTextString::toString() const
{
return toString( data );
}
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
inline KoTextFormat *KoTextStringChar::format() const
{
return (type == Regular) ? d.format : d.custom->format;
}
inline KoTextCustomItem *KoTextStringChar::customItem() const
{
return isCustom() ? d.custom->custom : 0;
}
#endif