3f492c34a1
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_8_BRANCH@46289 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1969 lines
63 KiB
OpenEdge ABL
1969 lines
63 KiB
OpenEdge ABL
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: _richtextbuffer.i
|
|
// Purpose: wxRichTextAttr
|
|
//
|
|
// Author: Robin Dunn
|
|
//
|
|
// Created: 11-April-2006
|
|
// RCS-ID: $Id$
|
|
// Copyright: (c) 2006 by Total Control Software
|
|
// Licence: wxWindows license
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Not a %module
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
%{
|
|
#include <wx/sstream.h>
|
|
#include "wx/wxPython/pyistream.h"
|
|
%}
|
|
|
|
//---------------------------------------------------------------------------
|
|
%newgroup
|
|
|
|
enum {
|
|
/*!
|
|
* File types
|
|
*/
|
|
wxRICHTEXT_TYPE_ANY,
|
|
wxRICHTEXT_TYPE_TEXT,
|
|
wxRICHTEXT_TYPE_XML,
|
|
wxRICHTEXT_TYPE_HTML,
|
|
wxRICHTEXT_TYPE_RTF,
|
|
wxRICHTEXT_TYPE_PDF,
|
|
|
|
/*!
|
|
* Flags determining the available space, passed to Layout
|
|
*/
|
|
wxRICHTEXT_FIXED_WIDTH,
|
|
wxRICHTEXT_FIXED_HEIGHT,
|
|
wxRICHTEXT_VARIABLE_WIDTH,
|
|
wxRICHTEXT_VARIABLE_HEIGHT,
|
|
|
|
|
|
wxRICHTEXT_LAYOUT_SPECIFIED_RECT,
|
|
wxRICHTEXT_DRAW_IGNORE_CACHE,
|
|
|
|
|
|
/*!
|
|
* Flags returned from hit-testing
|
|
*/
|
|
wxRICHTEXT_HITTEST_NONE,
|
|
wxRICHTEXT_HITTEST_BEFORE,
|
|
wxRICHTEXT_HITTEST_AFTER,
|
|
wxRICHTEXT_HITTEST_ON,
|
|
wxRICHTEXT_HITTEST_OUTSIDE,
|
|
|
|
/*!
|
|
* Flags for GetRangeSize
|
|
*/
|
|
wxRICHTEXT_FORMATTED,
|
|
wxRICHTEXT_UNFORMATTED,
|
|
|
|
/*!
|
|
* Flags for SetStyle/SetListStyle
|
|
*/
|
|
wxRICHTEXT_SETSTYLE_NONE,
|
|
wxRICHTEXT_SETSTYLE_WITH_UNDO,
|
|
wxRICHTEXT_SETSTYLE_OPTIMIZE,
|
|
wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY,
|
|
wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY,
|
|
wxRICHTEXT_SETSTYLE_RENUMBER,
|
|
wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL,
|
|
wxRICHTEXT_SETSTYLE_RESET,
|
|
wxRICHTEXT_SETSTYLE_REMOVE,
|
|
|
|
/*!
|
|
* Flags for text insertion
|
|
*/
|
|
wxRICHTEXT_INSERT_NONE,
|
|
wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE,
|
|
|
|
|
|
// TODO: Rename these to be wxRICHTEXT_* ??
|
|
|
|
wxTEXT_ATTR_TEXT_COLOUR,
|
|
wxTEXT_ATTR_BACKGROUND_COLOUR,
|
|
wxTEXT_ATTR_FONT_FACE,
|
|
wxTEXT_ATTR_FONT_SIZE,
|
|
wxTEXT_ATTR_FONT_WEIGHT,
|
|
wxTEXT_ATTR_FONT_ITALIC,
|
|
wxTEXT_ATTR_FONT_UNDERLINE,
|
|
wxTEXT_ATTR_FONT,
|
|
wxTEXT_ATTR_ALIGNMENT,
|
|
wxTEXT_ATTR_LEFT_INDENT,
|
|
wxTEXT_ATTR_RIGHT_INDENT,
|
|
wxTEXT_ATTR_TABS,
|
|
|
|
wxTEXT_ATTR_PARA_SPACING_AFTER,
|
|
wxTEXT_ATTR_PARA_SPACING_BEFORE,
|
|
wxTEXT_ATTR_LINE_SPACING,
|
|
wxTEXT_ATTR_CHARACTER_STYLE_NAME,
|
|
wxTEXT_ATTR_PARAGRAPH_STYLE_NAME,
|
|
wxTEXT_ATTR_BULLET_STYLE,
|
|
wxTEXT_ATTR_BULLET_NUMBER,
|
|
wxTEXT_ATTR_BULLET_TEXT,
|
|
wxTEXT_ATTR_BULLET_NAME,
|
|
wxTEXT_ATTR_URL,
|
|
wxTEXT_ATTR_PAGE_BREAK,
|
|
wxTEXT_ATTR_EFFECTS,
|
|
wxTEXT_ATTR_OUTLINE_LEVEL,
|
|
|
|
/*!
|
|
* Styles for wxTextAttrEx::SetBulletStyle
|
|
*/
|
|
wxTEXT_ATTR_BULLET_STYLE_NONE,
|
|
wxTEXT_ATTR_BULLET_STYLE_ARABIC,
|
|
wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER,
|
|
wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER,
|
|
wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER,
|
|
wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER,
|
|
wxTEXT_ATTR_BULLET_STYLE_SYMBOL,
|
|
wxTEXT_ATTR_BULLET_STYLE_BITMAP,
|
|
wxTEXT_ATTR_BULLET_STYLE_PARENTHESES,
|
|
wxTEXT_ATTR_BULLET_STYLE_PERIOD,
|
|
wxTEXT_ATTR_BULLET_STYLE_STANDARD,
|
|
wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS,
|
|
wxTEXT_ATTR_BULLET_STYLE_OUTLINE,
|
|
|
|
wxTEXT_ATTR_BULLET_STYLE_ALIGN_LEFT,
|
|
wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT,
|
|
wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE,
|
|
|
|
/*!
|
|
* Styles for wxTextAttrEx::SetTextEffects
|
|
*/
|
|
wxTEXT_ATTR_EFFECT_NONE,
|
|
wxTEXT_ATTR_EFFECT_CAPITALS,
|
|
wxTEXT_ATTR_EFFECT_SMALL_CAPITALS,
|
|
wxTEXT_ATTR_EFFECT_STRIKETHROUGH,
|
|
wxTEXT_ATTR_EFFECT_DOUBLE_STRIKETHROUGH,
|
|
wxTEXT_ATTR_EFFECT_SHADOW,
|
|
wxTEXT_ATTR_EFFECT_EMBOSS,
|
|
wxTEXT_ATTR_EFFECT_OUTLINE,
|
|
wxTEXT_ATTR_EFFECT_ENGRAVE,
|
|
wxTEXT_ATTR_EFFECT_SUPERSCRIPT,
|
|
wxTEXT_ATTR_EFFECT_SUBSCRIPT,
|
|
|
|
/*!
|
|
* Line spacing values
|
|
*/
|
|
wxTEXT_ATTR_LINE_SPACING_NORMAL,
|
|
wxTEXT_ATTR_LINE_SPACING_HALF,
|
|
wxTEXT_ATTR_LINE_SPACING_TWICE,
|
|
|
|
/*!
|
|
* Character and paragraph combined styles
|
|
*/
|
|
wxTEXT_ATTR_CHARACTER,
|
|
wxTEXT_ATTR_PARAGRAPH,
|
|
wxTEXT_ATTR_ALL,
|
|
|
|
};
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
%newgroup
|
|
|
|
|
|
|
|
%typemap(in) wxRichTextRange& (wxRichTextRange temp) {
|
|
$1 = &temp;
|
|
if ( ! wxRichTextRange_helper($input, &$1)) SWIG_fail;
|
|
}
|
|
%typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxRichTextRange& {
|
|
$1 = wxPySimple_typecheck($input, wxT("wxRichTextRange"), 2);
|
|
}
|
|
|
|
|
|
%{
|
|
bool wxRichTextRange_helper(PyObject* source, wxRichTextRange** obj)
|
|
{
|
|
if (source == Py_None) {
|
|
**obj = wxRICHTEXT_NONE;
|
|
return true;
|
|
}
|
|
return wxPyTwoIntItem_helper(source, obj, wxT("wxRichTextRange"));
|
|
}
|
|
%}
|
|
|
|
|
|
|
|
DocStr(wxRichTextRange,
|
|
"RichTextRange is a data structure that represents a range of text
|
|
within a `RichTextCtrl`. It simply contains integer ``start`` and
|
|
``end`` properties and a few operations useful for dealing with
|
|
ranges. In most places in wxPython where a RichTextRange is expected a
|
|
2-tuple containing (start, end) can be used instead.", "");
|
|
|
|
// Turn off the generation of code that aquires the Global Interpreter Lock
|
|
%threadWrapperOff
|
|
|
|
class wxRichTextRange
|
|
{
|
|
public:
|
|
DocCtorStr(
|
|
wxRichTextRange(long start=0, long end=0),
|
|
"Creates a new range object.", "");
|
|
|
|
~wxRichTextRange();
|
|
|
|
%extend {
|
|
DocStr(__eq__, "Test for equality of RichTextRange objects.", "");
|
|
bool __eq__(PyObject* other) {
|
|
wxRichTextRange temp, *obj = &temp;
|
|
if ( other == Py_None ) return false;
|
|
if ( ! wxRichTextRange_helper(other, &obj) ) {
|
|
PyErr_Clear();
|
|
return false;
|
|
}
|
|
return self->operator==(*obj);
|
|
}
|
|
}
|
|
|
|
|
|
DocDeclStr(
|
|
wxRichTextRange , operator -(const wxRichTextRange& range) const,
|
|
"", "");
|
|
|
|
DocDeclStr(
|
|
wxRichTextRange , operator +(const wxRichTextRange& range) const,
|
|
"", "");
|
|
|
|
|
|
DocDeclStr(
|
|
void , SetRange(long start, long end),
|
|
"", "");
|
|
|
|
|
|
DocDeclStr(
|
|
void , SetStart(long start),
|
|
"", "");
|
|
DocDeclStr(
|
|
long , GetStart() const,
|
|
"", "");
|
|
%pythoncode { start = property(GetStart, SetStart) }
|
|
|
|
|
|
DocDeclStr(
|
|
void , SetEnd(long end),
|
|
"", "");
|
|
DocDeclStr(
|
|
long , GetEnd() const,
|
|
"", "");
|
|
%pythoncode { end = property(GetEnd, SetEnd) }
|
|
|
|
|
|
DocDeclStr(
|
|
bool , IsOutside(const wxRichTextRange& range) const,
|
|
"Returns true if this range is completely outside 'range'", "");
|
|
|
|
|
|
DocDeclStr(
|
|
bool , IsWithin(const wxRichTextRange& range) const,
|
|
"Returns true if this range is completely within 'range'", "");
|
|
|
|
|
|
DocDeclStr(
|
|
bool , Contains(long pos) const,
|
|
"Returns true if the given position is within this range. Allow for the
|
|
possibility of an empty range - assume the position is within this
|
|
empty range.", "");
|
|
|
|
|
|
DocDeclStr(
|
|
bool , LimitTo(const wxRichTextRange& range) ,
|
|
"Limit this range to be within 'range'", "");
|
|
|
|
|
|
DocDeclStr(
|
|
long , GetLength() const,
|
|
"Gets the length of the range", "");
|
|
|
|
|
|
DocDeclStr(
|
|
void , Swap(),
|
|
"Swaps the start and end", "");
|
|
|
|
|
|
DocDeclStr(
|
|
wxRichTextRange , ToInternal() const,
|
|
"Convert to internal form: (n, n) is the range of a single character.", "");
|
|
|
|
|
|
DocDeclStr(
|
|
wxRichTextRange , FromInternal() const,
|
|
"Convert from internal to public API form: (n, n+1) is the range of a
|
|
single character.", "");
|
|
|
|
|
|
%extend {
|
|
DocAStr(Get,
|
|
"Get() -> (start,end)",
|
|
"Returns the start and end properties as a tuple.", "");
|
|
PyObject* Get() {
|
|
PyObject* tup = PyTuple_New(2);
|
|
PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetStart()));
|
|
PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetEnd()));
|
|
return tup;
|
|
}
|
|
}
|
|
%pythoncode {
|
|
def __str__(self): return str(self.Get())
|
|
def __repr__(self): return 'RichTextRange'+str(self.Get())
|
|
def __len__(self): return len(self.Get())
|
|
def __getitem__(self, index): return self.Get()[index]
|
|
def __setitem__(self, index, val):
|
|
if index == 0: self.start = val
|
|
elif index == 1: self.end = val
|
|
else: raise IndexError
|
|
def __nonzero__(self): return self.Get() != (0,0)
|
|
__safe_for_unpickling__ = True
|
|
def __reduce__(self): return (RichTextRange, self.Get())
|
|
}
|
|
|
|
%property(End, GetEnd, SetEnd, doc="See `GetEnd` and `SetEnd`");
|
|
%property(Length, GetLength, doc="See `GetLength`");
|
|
%property(Start, GetStart, SetStart, doc="See `GetStart` and `SetStart`");
|
|
};
|
|
|
|
|
|
|
|
%{
|
|
wxRichTextRange wxPy_RTR_ALL(wxRICHTEXT_ALL);
|
|
wxRichTextRange wxPy_RTR_NONE(wxRICHTEXT_NONE);
|
|
%}
|
|
|
|
%rename(RICHTEXT_ALL) wxPy_RTR_ALL;
|
|
%rename(RICHTEXT_NONE) wxPy_RTR_NONE;
|
|
|
|
%immutable;
|
|
wxRichTextRange wxPy_RTR_ALL;
|
|
wxRichTextRange wxPy_RTR_NONE;
|
|
%mutable;
|
|
|
|
// Turn back on the generation of code that aquires the Global Interpreter Lock
|
|
%threadWrapperOn
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
%newgroup
|
|
|
|
|
|
DocStr(wxRichTextAttr,
|
|
"The RichTextAttr class stores information about the various attributes
|
|
for a block of text, including font, colour, indents, alignments, and
|
|
etc.", "");
|
|
|
|
class wxRichTextAttr
|
|
{
|
|
public:
|
|
|
|
wxRichTextAttr(const wxColour& colText = wxNullColour,
|
|
const wxColour& colBack = wxNullColour,
|
|
wxTextAttrAlignment alignment = wxTEXT_ALIGNMENT_DEFAULT);
|
|
|
|
~wxRichTextAttr();
|
|
|
|
// // Making a wxTextAttrEx object.
|
|
// operator wxTextAttrEx () const ;
|
|
|
|
// // Copy to a wxTextAttr
|
|
// void CopyTo(wxTextAttrEx& attr) const;
|
|
|
|
|
|
DocDeclStr(
|
|
void , Init(),
|
|
"Initialise this object.", "");
|
|
|
|
|
|
DocDeclStr(
|
|
void , Copy(const wxRichTextAttr& attr),
|
|
"Copy from attr to self.", "");
|
|
|
|
|
|
// Equality test
|
|
bool operator== (const wxRichTextAttr& attr) const;
|
|
|
|
|
|
|
|
DocDeclStr(
|
|
wxFont , CreateFont() const,
|
|
"Create font from the font attributes in this attr object.", "");
|
|
|
|
|
|
DocDeclStr(
|
|
bool , GetFontAttributes(const wxFont& font),
|
|
"Set our font attributes from the font.", "");
|
|
|
|
|
|
%pythoncode {
|
|
def GetFont(self):
|
|
return self.CreateFont()
|
|
def SetFont(self, font):
|
|
return self.GetFontAttributes(font)
|
|
}
|
|
|
|
// setters
|
|
void SetTextColour(const wxColour& colText);
|
|
void SetBackgroundColour(const wxColour& colBack);
|
|
void SetAlignment(wxTextAttrAlignment alignment);
|
|
void SetTabs(const wxArrayInt& tabs);
|
|
void SetLeftIndent(int indent, int subIndent = 0);
|
|
void SetRightIndent(int indent);
|
|
|
|
void SetFontSize(int pointSize);
|
|
void SetFontStyle(int fontStyle);
|
|
void SetFontWeight(int fontWeight);
|
|
void SetFontFaceName(const wxString& faceName);
|
|
void SetFontUnderlined(bool underlined);
|
|
|
|
void SetFlags(long flags);
|
|
|
|
void SetCharacterStyleName(const wxString& name);
|
|
void SetParagraphStyleName(const wxString& name);
|
|
void SetListStyleName(const wxString& name);
|
|
void SetParagraphSpacingAfter(int spacing);
|
|
void SetParagraphSpacingBefore(int spacing);
|
|
void SetLineSpacing(int spacing);
|
|
void SetBulletStyle(int style);
|
|
void SetBulletNumber(int n);
|
|
void SetBulletText(wxChar symbol);
|
|
void SetBulletFont(const wxString& bulletFont);
|
|
void SetBulletName(const wxString& name);
|
|
void SetURL(const wxString& url);
|
|
void SetPageBreak(bool pageBreak = true);
|
|
void SetTextEffects(int effects);
|
|
void SetTextEffectFlags(int effects);
|
|
void SetOutlineLevel(int level);
|
|
|
|
const wxColour& GetTextColour() const;
|
|
const wxColour& GetBackgroundColour() const;
|
|
wxTextAttrAlignment GetAlignment() const;
|
|
const wxArrayInt& GetTabs() const;
|
|
long GetLeftIndent() const;
|
|
long GetLeftSubIndent() const;
|
|
long GetRightIndent() const;
|
|
long GetFlags() const;
|
|
|
|
int GetFontSize() const;
|
|
int GetFontStyle() const;
|
|
int GetFontWeight() const;
|
|
bool GetFontUnderlined() const;
|
|
const wxString& GetFontFaceName() const;
|
|
|
|
const wxString& GetCharacterStyleName() const;
|
|
const wxString& GetParagraphStyleName() const;
|
|
const wxString& GetListStyleName() const;
|
|
int GetParagraphSpacingAfter() const;
|
|
int GetParagraphSpacingBefore() const;
|
|
int GetLineSpacing() const;
|
|
int GetBulletStyle() const;
|
|
int GetBulletNumber() const;
|
|
const wxString& GetBulletText() const;
|
|
const wxString& GetBulletFont() const;
|
|
const wxString& GetBulletName() const;
|
|
const wxString& GetURL() const;
|
|
int GetTextEffects() const;
|
|
int GetTextEffectFlags() const;
|
|
int GetOutlineLevel() const;
|
|
|
|
// accessors
|
|
bool HasTextColour() const;
|
|
bool HasBackgroundColour() const;
|
|
bool HasAlignment() const;
|
|
bool HasTabs() const;
|
|
bool HasLeftIndent() const;
|
|
bool HasRightIndent() const;
|
|
bool HasFontWeight() const;
|
|
bool HasFontSize() const;
|
|
bool HasFontItalic() const;
|
|
bool HasFontUnderlined() const;
|
|
bool HasFontFaceName() const;
|
|
bool HasFont() const;
|
|
|
|
bool HasParagraphSpacingAfter() const;
|
|
bool HasParagraphSpacingBefore() const;
|
|
bool HasLineSpacing() const;
|
|
bool HasCharacterStyleName() const;
|
|
bool HasParagraphStyleName() const;
|
|
bool HasListStyleName() const;
|
|
bool HasBulletStyle() const;
|
|
bool HasBulletNumber() const;
|
|
bool HasBulletText() const;
|
|
bool HasBulletName() const;
|
|
bool HasURL() const;
|
|
bool HasPageBreak() const;
|
|
bool HasTextEffects() const;
|
|
bool HasTextEffect(int effect) const;
|
|
bool HasOutlineLevel() const;
|
|
|
|
bool HasFlag(long flag) const;
|
|
|
|
bool IsCharacterStyle() const;
|
|
bool IsParagraphStyle() const;
|
|
|
|
|
|
DocDeclStr(
|
|
bool , IsDefault() const,
|
|
"Returns false if we have any attributes set, true otherwise", "");
|
|
|
|
|
|
DocDeclStr(
|
|
bool , Apply(const wxRichTextAttr& style, const wxRichTextAttr* compareWith = NULL),
|
|
"Merges the given attributes. Does not affect self. If compareWith is
|
|
not None, then it will be used to mask out those attributes that are
|
|
the same in style and compareWith, for situations where we don't want
|
|
to explicitly set inherited attributes.
|
|
", "");
|
|
|
|
|
|
DocDeclStr(
|
|
wxRichTextAttr , Combine(const wxRichTextAttr& style, const wxRichTextAttr* compareWith = NULL) const,
|
|
"Merges the given attributes and returns the result. Does not affect
|
|
self. If compareWith is not None, then it will be used to mask out
|
|
those attributes that are the same in style and compareWith, for
|
|
situations where we don't want to explicitly set inherited attributes.
|
|
", "");
|
|
|
|
|
|
|
|
%property(Alignment, GetAlignment, SetAlignment);
|
|
%property(BackgroundColour, GetBackgroundColour, SetBackgroundColour);
|
|
%property(BulletFont, GetBulletFont, SetBulletFont);
|
|
%property(BulletNumber, GetBulletNumber, SetBulletNumber);
|
|
%property(BulletStyle, GetBulletStyle, SetBulletStyle);
|
|
%property(BulletText, GetBulletText, SetBulletText);
|
|
%property(CharacterStyleName, GetCharacterStyleName, SetCharacterStyleName);
|
|
%property(Flags, GetFlags, SetFlags);
|
|
%property(Font, GetFont, SetFont);
|
|
%property(FontAttributes, GetFontAttributes);
|
|
%property(FontFaceName, GetFontFaceName, SetFontFaceName);
|
|
%property(FontSize, GetFontSize, SetFontSize);
|
|
%property(FontStyle, GetFontStyle, SetFontStyle);
|
|
%property(FontUnderlined, GetFontUnderlined, SetFontUnderlined);
|
|
%property(FontWeight, GetFontWeight, SetFontWeight);
|
|
%property(LeftIndent, GetLeftIndent, SetLeftIndent);
|
|
%property(LeftSubIndent, GetLeftSubIndent);
|
|
%property(LineSpacing, GetLineSpacing, SetLineSpacing);
|
|
%property(ParagraphSpacingAfter, GetParagraphSpacingAfter, SetParagraphSpacingAfter);
|
|
%property(ParagraphSpacingBefore, GetParagraphSpacingBefore, SetParagraphSpacingBefore);
|
|
%property(ParagraphStyleName, GetParagraphStyleName, SetParagraphStyleName);
|
|
%property(RightIndent, GetRightIndent, SetRightIndent);
|
|
%property(Tabs, GetTabs, SetTabs);
|
|
%property(TextColour, GetTextColour, SetTextColour);
|
|
|
|
%property(ListStyleName, GetListStyleName, SetListStyleName);
|
|
%property(BulletName, GetBulletName, SetBulletName);
|
|
%property(URL, GetURL, SetURL);
|
|
%property(TextEffects, GetTextEffects, SetTextEffects);
|
|
%property(TextEffectFlags, GetTextEffectFlags, SetTextEffectFlags);
|
|
%property(OutlineLevel, GetOutlineLevel, SetOutlineLevel);
|
|
};
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
// TODO TODO TODO
|
|
// There's still lots to do for these classes...
|
|
//
|
|
// 1. Decide how to coalesce overloaded methods and ctors
|
|
// 2. correctly set disown flags and re-ownership as needed
|
|
// 3. Implement PyRichTextObject
|
|
// 4. Decide how to typemap and tweak the virtuals that pass back
|
|
// values in their parameters (yuck! damn C++)
|
|
// 5. better handling of streams
|
|
// 6. list-like wrapper for C++ wxLists
|
|
// 7. wrappers for wxTextAttrEx --> wxRichTextAttr (as needed)
|
|
// 8. Add more properties
|
|
|
|
|
|
|
|
DocStr(wxRichTextObject,
|
|
"This is the base class for all drawable objects in a `RichTextCtrl`.
|
|
|
|
The data displayed in a `RichTextCtrl` is handled by `RichTextBuffer`,
|
|
and a `RichTextCtrl` always has one such buffer.
|
|
|
|
The content is represented by a hierarchy of objects, all derived from
|
|
`RichTextObject`. An object might be an image, a fragment of text, a
|
|
paragraph, or a whole buffer. Objects store a an attribute object
|
|
containing style information; a paragraph object can contain both
|
|
paragraph and character information, but content objects such as text
|
|
can only store character information. The final style displayed in the
|
|
control or in a printout is a combination of base style, paragraph
|
|
style and content (character) style.
|
|
|
|
The top of the hierarchy is the buffer, a kind of
|
|
`RichTextParagraphLayoutBox`. containing further `RichTextParagraph`
|
|
objects, each of which can include text, images and potentially other
|
|
types of objects.
|
|
|
|
Each object maintains a range (start and end position) measured from
|
|
the start of the main parent object.
|
|
|
|
When Layout is called on an object, it is given a size which the
|
|
object must limit itself to, or one or more flexible directions
|
|
(vertical or horizontal). So, for example, a centred paragraph is
|
|
given the page width to play with (minus any margins), but can extend
|
|
indefinitely in the vertical direction. The implementation of Layout
|
|
caches the calculated size and position.
|
|
|
|
When the buffer is modified, a range is invalidated (marked as
|
|
requiring layout), so that only the minimum amount of layout is
|
|
performed.
|
|
|
|
A paragraph of pure text with the same style contains just one further
|
|
object, a `RichTextPlainText` object. When styling is applied to part
|
|
of this object, the object is decomposed into separate objects, one
|
|
object for each different character style. So each object within a
|
|
paragraph always has just one attribute object to denote its character
|
|
style. Of course, this can lead to fragmentation after a lot of edit
|
|
operations, potentially leading to several objects with the same style
|
|
where just one would do. So a Defragment function is called when
|
|
updating the control's display, to ensure that the minimum number of
|
|
objects is used.
|
|
|
|
To implement your own RichTextObjects in Python you must derive a
|
|
class from `PyRichTextObject`, which has been instrumented to forward
|
|
the virtual C++ method calls to the Python methods in the derived
|
|
class. (This class hasn't been implemented yet!)", "");
|
|
|
|
// argout typemap for wxPoint
|
|
%typemap(in, numinputs=0, noblock=1) wxPoint& OUTPUT (wxPoint temp) {
|
|
$1 = &temp;
|
|
}
|
|
%typemap(argout, noblock=1) wxPoint& OUTPUT {
|
|
%append_output(SWIG_NewPointerObj((void*)new wxPoint(*$1), $1_descriptor, SWIG_POINTER_OWN));
|
|
}
|
|
|
|
// argout typemap for wxSize
|
|
%typemap(in, numinputs=0, noblock=1) wxSize& OUTPUT (wxSize temp) {
|
|
$1 = &temp;
|
|
}
|
|
%typemap(argout, noblock=1) wxSize& OUTPUT {
|
|
%append_output(SWIG_NewPointerObj((void*)new wxSize(*$1), $1_descriptor, SWIG_POINTER_OWN));
|
|
}
|
|
|
|
|
|
class wxRichTextObject: public wxObject
|
|
{
|
|
public:
|
|
// wxRichTextObject(wxRichTextObject* parent = NULL); // **** This is an ABC
|
|
virtual ~wxRichTextObject();
|
|
|
|
|
|
// Overrideables
|
|
|
|
/// Draw the item, within the given range. Some objects may ignore the range (for
|
|
/// example paragraphs) while others must obey it (lines, to implement wrapping)
|
|
virtual bool Draw(wxDC& dc, const wxRichTextRange& range,
|
|
const wxRichTextRange& selectionRange, const wxRect& rect,
|
|
int descent, int style);
|
|
|
|
/// Lay the item out at the specified position with the given size constraint.
|
|
/// Layout must set the cached size.
|
|
virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
|
|
|
|
/// Hit-testing: returns a flag indicating hit test details, plus
|
|
/// information about position
|
|
virtual int HitTest(wxDC& dc, const wxPoint& pt, long& OUTPUT /*textPosition*/);
|
|
|
|
/// Finds the absolute position and row height for the given character position
|
|
virtual bool FindPosition(wxDC& dc, long index, wxPoint& OUTPUT /*pt*/,
|
|
int* OUTPUT /*height*/, bool forceLineStart);
|
|
|
|
|
|
/// Get the best size, i.e. the ideal starting size for this object irrespective
|
|
/// of available space. For a short text string, it will be the size that exactly encloses
|
|
/// the text. For a longer string, it might use the parent width for example.
|
|
virtual wxSize GetBestSize() const;
|
|
|
|
/// Get the object size for the given range. Returns false if the range
|
|
/// is invalid for this object.
|
|
virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& OUTPUT /*size*/,
|
|
int& OUTPUT /*descent*/, wxDC& dc, int flags,
|
|
wxPoint position = wxPoint(0,0)) const;
|
|
|
|
/// Do a split, returning an object containing the second part, and setting
|
|
/// the first part in 'this'.
|
|
virtual wxRichTextObject* DoSplit(long pos);
|
|
|
|
/// Calculate range. By default, guess that the object is 1 unit long.
|
|
virtual void CalculateRange(long start, long& OUTPUT /*end*/);
|
|
|
|
/// Delete range
|
|
virtual bool DeleteRange(const wxRichTextRange& range);
|
|
|
|
/// Returns true if the object is empty
|
|
virtual bool IsEmpty() const;
|
|
|
|
/// Get any text in this object for the given range
|
|
virtual wxString GetTextForRange(const wxRichTextRange& range) const;
|
|
|
|
/// Returns true if this object can merge itself with the given one.
|
|
virtual bool CanMerge(wxRichTextObject* object) const;
|
|
|
|
/// Returns true if this object merged itself with the given one.
|
|
/// The calling code will then delete the given object.
|
|
virtual bool Merge(wxRichTextObject* object);
|
|
|
|
/// Dump to output stream for debugging
|
|
//virtual void Dump(wxTextOutputStream& stream);
|
|
%extend {
|
|
wxString Dump() {
|
|
wxStringOutputStream strstream;
|
|
wxTextOutputStream txtstream(strstream);
|
|
self->Dump(txtstream);
|
|
return strstream.GetString();
|
|
}
|
|
}
|
|
|
|
// Accessors
|
|
|
|
/// Get/set the cached object size as calculated by Layout.
|
|
virtual wxSize GetCachedSize() const;
|
|
virtual void SetCachedSize(const wxSize& sz);
|
|
%property(CachedSize, GetCachedSize, SetCachedSize);
|
|
|
|
/// Get/set the object position
|
|
virtual wxPoint GetPosition() const;
|
|
virtual void SetPosition(const wxPoint& pos);
|
|
%property(Position, GetPosition, SetPosition);
|
|
|
|
/// Get the rectangle enclosing the object
|
|
virtual wxRect GetRect() const;
|
|
%property(Rect, GetRect);
|
|
|
|
|
|
/// Set the range
|
|
void SetRange(const wxRichTextRange& range);
|
|
/// Get the range
|
|
wxRichTextRange GetRange();
|
|
%property(Range, GetRange, SetRange);
|
|
|
|
|
|
/// Get/set dirty flag (whether the object needs Layout to be called)
|
|
virtual bool GetDirty() const;
|
|
virtual void SetDirty(bool dirty);
|
|
%property(Dirty, GetDirty, SetDirty);
|
|
|
|
|
|
/// Is this composite?
|
|
virtual bool IsComposite() const;
|
|
|
|
/// Get/set the parent.
|
|
virtual wxRichTextObject* GetParent() const;
|
|
virtual void SetParent(wxRichTextObject* parent);
|
|
%property(Parent, GetParent, SetParent);
|
|
|
|
|
|
// TODO: Morph these into SetLeftMargin and etc. for wxPython so
|
|
// there can be proper properties
|
|
|
|
/// Set the margin around the object
|
|
%Rename(SetSameMargins,
|
|
virtual void , SetMargins(int margin));
|
|
virtual void SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin);
|
|
virtual int GetLeftMargin() const;
|
|
virtual int GetRightMargin() const;
|
|
virtual int GetTopMargin() const;
|
|
virtual int GetBottomMargin() const;
|
|
|
|
|
|
/// Set attributes object
|
|
void SetAttributes(const wxRichTextAttr& attr);
|
|
wxRichTextAttr GetAttributes();
|
|
%property(Attributes, GetAttributes, SetAttributes);
|
|
|
|
/// Set/get stored descent
|
|
void SetDescent(int descent);
|
|
int GetDescent() const;
|
|
%property(Descent, GetDescent, SetDescent);
|
|
|
|
/// Gets the containing buffer
|
|
wxRichTextBuffer* GetBuffer() const;
|
|
|
|
// Operations
|
|
|
|
/// Clone the object
|
|
virtual wxRichTextObject* Clone() const;
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextObject& obj);
|
|
|
|
/// Reference-counting allows us to use the same object in multiple
|
|
/// lists (not yet used)
|
|
void Reference();
|
|
void Dereference();
|
|
|
|
/// Convert units in tenths of a millimetre to device units
|
|
%Rename(ConvertTenthsMMToPixelsDC,
|
|
int, ConvertTenthsMMToPixels(wxDC& dc, int units));
|
|
static int ConvertTenthsMMToPixels(int ppi, int units);
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
wxLIST_WRAPPER(wxRichTextObjectList, wxRichTextObject);
|
|
|
|
|
|
DocStr(wxRichTextCompositeObject,
|
|
"Objects of this class can contain other rich text objects.", "");
|
|
|
|
|
|
class wxRichTextCompositeObject: public wxRichTextObject
|
|
{
|
|
public:
|
|
// wxRichTextCompositeObject(wxRichTextObject* parent = NULL); **** This is an ABC
|
|
virtual ~wxRichTextCompositeObject();
|
|
|
|
// Accessors
|
|
|
|
/// Get the children
|
|
wxRichTextObjectList& GetChildren();
|
|
|
|
/// Get the child count
|
|
size_t GetChildCount() const ;
|
|
|
|
/// Get the nth child
|
|
wxRichTextObject* GetChild(size_t n) const ;
|
|
|
|
// Operations
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextCompositeObject& obj);
|
|
|
|
%disownarg(wxRichTextObject* child);
|
|
|
|
/// Append a child, returning the position
|
|
size_t AppendChild(wxRichTextObject* child) ;
|
|
|
|
/// Insert the child in front of the given object, or at the beginning
|
|
bool InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf) ;
|
|
|
|
%cleardisown(wxRichTextObject* child);
|
|
|
|
|
|
/// Delete the child
|
|
%feature("shadow") RemoveChild %{
|
|
def RemoveChild(self, child, deleteChild=False):
|
|
val = _richtext.RichTextCompositeObject_RemoveChild(self, child, deleteChild)
|
|
self.this.own(not deleteChild)
|
|
return val
|
|
%}
|
|
bool RemoveChild(wxRichTextObject* child, bool deleteChild = false) ;
|
|
|
|
/// Delete all children
|
|
bool DeleteChildren();
|
|
|
|
/// Recursively merge all pieces that can be merged.
|
|
bool Defragment();
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DocStr(wxRichTextBox,
|
|
"This defines a 2D space to lay out objects.", "");
|
|
|
|
class wxRichTextBox: public wxRichTextCompositeObject
|
|
{
|
|
public:
|
|
wxRichTextBox(wxRichTextObject* parent = NULL);
|
|
|
|
virtual wxRichTextObject* Clone() const;
|
|
void Copy(const wxRichTextBox& obj);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DocStr(wxRichTextParagraphBox,
|
|
"This box knows how to lay out paragraphs.", "");
|
|
|
|
class wxRichTextParagraphLayoutBox: public wxRichTextBox
|
|
{
|
|
public:
|
|
|
|
wxRichTextParagraphLayoutBox(wxRichTextObject* parent = NULL);
|
|
|
|
// Accessors
|
|
|
|
/// Associate a control with the buffer, for operations that for example require refreshing the window.
|
|
void SetRichTextCtrl(wxRichTextCtrl* ctrl);
|
|
|
|
/// Get the associated control.
|
|
wxRichTextCtrl* GetRichTextCtrl() const;
|
|
|
|
/// Get/set whether the last paragraph is partial or complete
|
|
void SetPartialParagraph(bool partialPara);
|
|
bool GetPartialParagraph() const;
|
|
|
|
/// If this is a buffer, returns the current style sheet. The base layout box
|
|
/// class doesn't have an associated style sheet.
|
|
virtual wxRichTextStyleSheet* GetStyleSheet() const;
|
|
|
|
// Operations
|
|
|
|
/// Initialize the object.
|
|
void Init();
|
|
|
|
/// Clear all children
|
|
virtual void Clear();
|
|
|
|
/// Clear and initialize with one blank paragraph
|
|
virtual void Reset();
|
|
|
|
/// Convenience function to add a paragraph of text
|
|
virtual wxRichTextRange AddParagraph(const wxString& text, wxTextAttrEx* paraStyle = NULL);
|
|
|
|
/// Convenience function to add an image
|
|
virtual wxRichTextRange AddImage(const wxImage& image, wxTextAttrEx* paraStyle = NULL);
|
|
|
|
/// Adds multiple paragraphs, based on newlines.
|
|
virtual wxRichTextRange AddParagraphs(const wxString& text, wxTextAttrEx* paraStyle = NULL);
|
|
|
|
/// Get the line at the given position. If caretPosition is true, the position is
|
|
/// a caret position, which is normally a smaller number.
|
|
virtual wxRichTextLine* GetLineAtPosition(long pos, bool caretPosition = false) const;
|
|
|
|
/// Get the line at the given y pixel position, or the last line.
|
|
virtual wxRichTextLine* GetLineAtYPosition(int y) const;
|
|
|
|
/// Get the paragraph at the given character or caret position
|
|
virtual wxRichTextParagraph* GetParagraphAtPosition(long pos, bool caretPosition = false) const;
|
|
|
|
/// Get the line size at the given position
|
|
virtual wxSize GetLineSizeAtPosition(long pos, bool caretPosition = false) const;
|
|
|
|
/// Given a position, get the number of the visible line (potentially many to a paragraph),
|
|
/// starting from zero at the start of the buffer. We also have to pass a bool (startOfLine)
|
|
/// that indicates whether the caret is being shown at the end of the previous line or at the start
|
|
/// of the next, since the caret can be shown at 2 visible positions for the same underlying
|
|
/// position.
|
|
virtual long GetVisibleLineNumber(long pos, bool caretPosition = false, bool startOfLine = false) const;
|
|
|
|
/// Given a line number, get the corresponding wxRichTextLine object.
|
|
virtual wxRichTextLine* GetLineForVisibleLineNumber(long lineNumber) const;
|
|
|
|
/// Get the leaf object in a paragraph at this position.
|
|
/// Given a line number, get the corresponding wxRichTextLine object.
|
|
virtual wxRichTextObject* GetLeafObjectAtPosition(long position) const;
|
|
|
|
/// Get the paragraph by number
|
|
virtual wxRichTextParagraph* GetParagraphAtLine(long paragraphNumber) const;
|
|
|
|
/// Get the paragraph for a given line
|
|
virtual wxRichTextParagraph* GetParagraphForLine(wxRichTextLine* line) const;
|
|
|
|
/// Get the length of the paragraph
|
|
virtual int GetParagraphLength(long paragraphNumber) const;
|
|
|
|
/// Get the number of paragraphs
|
|
virtual int GetParagraphCount() const { return GetChildCount(); }
|
|
|
|
/// Get the number of visible lines
|
|
virtual int GetLineCount() const;
|
|
|
|
/// Get the text of the paragraph
|
|
virtual wxString GetParagraphText(long paragraphNumber) const;
|
|
|
|
/// Convert zero-based line column and paragraph number to a position.
|
|
virtual long XYToPosition(long x, long y) const;
|
|
|
|
/// Convert zero-based position to line column and paragraph number
|
|
virtual bool PositionToXY(long pos, long* x, long* y) const;
|
|
|
|
/// Set text attributes: character and/or paragraph styles.
|
|
virtual bool SetStyle(const wxRichTextRange& range,
|
|
const wxRichTextAttr& style,
|
|
int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
|
|
// virtual bool SetStyle(const wxRichTextRange& range,
|
|
// const wxTextAttrEx& style,
|
|
// int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
|
|
|
|
/// Get the conbined text attributes for this position.
|
|
// virtual bool GetStyle(long position, wxTextAttrEx& style);
|
|
virtual bool GetStyle(long position, wxRichTextAttr& style);
|
|
|
|
/// Get the content (uncombined) attributes for this position.
|
|
// virtual bool GetUncombinedStyle(long position, wxTextAttrEx& style);
|
|
virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style);
|
|
|
|
// /// Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
|
|
// /// context attributes.
|
|
// virtual bool DoGetStyle(long position, wxTextAttrEx& style, bool combineStyles = true);
|
|
|
|
/// Get the combined style for a range - if any attribute is different within the range,
|
|
/// that attribute is not present within the flags
|
|
virtual bool GetStyleForRange(const wxRichTextRange& range, wxTextAttrEx& style);
|
|
|
|
/// Combines 'style' with 'currentStyle' for the purpose of summarising the attributes of a range of
|
|
/// content.
|
|
bool CollectStyle(wxTextAttrEx& currentStyle, const wxTextAttrEx& style, long& multipleStyleAttributes, int& multipleTextEffectAttributes);
|
|
|
|
/// Set list style
|
|
//virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
|
|
virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName,
|
|
int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO,
|
|
int startFrom = 1, int specifiedLevel = -1);
|
|
|
|
/// Clear list for given range
|
|
virtual bool ClearListStyle(const wxRichTextRange& range,
|
|
int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
|
|
|
|
/// Number/renumber any list elements in the given range.
|
|
/// def/defName can be NULL/empty to indicate that the existing list style should be used.
|
|
//virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
|
|
virtual bool NumberList(const wxRichTextRange& range, const wxString& defName,
|
|
int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO,
|
|
int startFrom = 1, int specifiedLevel = -1);
|
|
|
|
/// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
|
|
/// def/defName can be NULL/empty to indicate that the existing list style should be used.
|
|
//virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
|
|
virtual bool PromoteList(int promoteBy, const wxRichTextRange& range,
|
|
const wxString& defName,
|
|
int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO,
|
|
int specifiedLevel = -1);
|
|
|
|
/// Helper for NumberList and PromoteList, that does renumbering and promotion simultaneously
|
|
/// def/defName can be NULL/empty to indicate that the existing list style should be used.
|
|
virtual bool DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
|
|
|
|
/// Fills in the attributes for numbering a paragraph after previousParagraph.
|
|
virtual bool FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const;
|
|
|
|
/// Test if this whole range has character attributes of the specified kind. If any
|
|
/// of the attributes are different within the range, the test fails. You
|
|
/// can use this to implement, for example, bold button updating. style must have
|
|
/// flags indicating which attributes are of interest.
|
|
//virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const;
|
|
virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
|
|
|
|
/// Test if this whole range has paragraph attributes of the specified kind. If any
|
|
/// of the attributes are different within the range, the test fails. You
|
|
/// can use this to implement, for example, centering button updating. style must have
|
|
/// flags indicating which attributes are of interest.
|
|
//virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const;
|
|
virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
|
|
|
|
/// Clone
|
|
virtual wxRichTextObject* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
|
|
|
|
/// Insert fragment into this box at the given position. If partialParagraph is true,
|
|
/// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
|
|
/// marker.
|
|
virtual bool InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment);
|
|
|
|
/// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
|
|
virtual bool CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment);
|
|
|
|
/// Apply the style sheet to the buffer, for example if the styles have changed.
|
|
virtual bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet);
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextParagraphLayoutBox& obj);
|
|
|
|
/// Calculate ranges
|
|
virtual void UpdateRanges();
|
|
|
|
/// Get all the text
|
|
virtual wxString GetText() const;
|
|
|
|
/// Set default style for new content. Setting it to a default attribute
|
|
/// makes new content take on the 'basic' style.
|
|
virtual bool SetDefaultStyle(const wxTextAttrEx& style);
|
|
|
|
/// Get default style
|
|
virtual const wxTextAttrEx& GetDefaultStyle() const;
|
|
|
|
/// Set basic (overall) style
|
|
//virtual void SetBasicStyle(const wxTextAttrEx& style);
|
|
virtual void SetBasicStyle(const wxRichTextAttr& style);
|
|
|
|
/// Get basic (overall) style
|
|
virtual const wxTextAttrEx& GetBasicStyle() const;
|
|
|
|
/// Invalidate the buffer. With no argument, invalidates whole buffer.
|
|
void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
|
|
|
|
/// Get invalid range, rounding to entire paragraphs if argument is true.
|
|
wxRichTextRange GetInvalidRange(bool wholeParagraphs = false) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
DocStr(wxRichTextLine,
|
|
"This object represents a line in a paragraph, and stores offsets from
|
|
the start of the paragraph representing the start and end positions of
|
|
the line.", "");
|
|
|
|
class wxRichTextLine
|
|
{
|
|
public:
|
|
wxRichTextLine(wxRichTextParagraph* parent);
|
|
virtual ~wxRichTextLine();
|
|
|
|
/// Set the range
|
|
void SetRange(const wxRichTextRange& range);
|
|
|
|
/// Get the parent paragraph
|
|
wxRichTextParagraph* GetParent();
|
|
|
|
/// Get the range
|
|
wxRichTextRange GetRange();
|
|
|
|
/// Get the absolute range
|
|
wxRichTextRange GetAbsoluteRange() const;
|
|
|
|
/// Get/set the line size as calculated by Layout.
|
|
virtual wxSize GetSize() const;
|
|
virtual void SetSize(const wxSize& sz);
|
|
|
|
/// Get/set the object position relative to the parent
|
|
virtual wxPoint GetPosition() const;
|
|
virtual void SetPosition(const wxPoint& pos);
|
|
|
|
/// Get the absolute object position
|
|
virtual wxPoint GetAbsolutePosition() const;
|
|
|
|
/// Get the rectangle enclosing the line
|
|
virtual wxRect GetRect() const;
|
|
|
|
/// Set/get stored descent
|
|
void SetDescent(int descent);
|
|
int GetDescent() const;
|
|
|
|
// Operations
|
|
|
|
/// Initialisation
|
|
void Init(wxRichTextParagraph* parent);
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextLine& obj);
|
|
|
|
/// Clone
|
|
virtual wxRichTextLine* Clone() const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DocStr(wxRichTextParagraph,
|
|
"This object represents a single paragraph (or in a straight text
|
|
editor, a line).", "");
|
|
|
|
class wxRichTextParagraph: public wxRichTextBox
|
|
{
|
|
public:
|
|
%extend {
|
|
wxRichTextParagraph(const wxString& text = wxPyEmptyString,
|
|
wxRichTextObject* parent = NULL,
|
|
wxRichTextAttr* paraStyle = NULL,
|
|
wxRichTextAttr* charStyle = NULL)
|
|
{
|
|
wxTextAttrEx* psAttr = NULL;
|
|
wxTextAttrEx* csAttr = NULL;
|
|
wxTextAttrEx psAttr_v;
|
|
wxTextAttrEx csAttr_v;
|
|
if (paraStyle) {
|
|
psAttr_v = *paraStyle;
|
|
psAttr = &psAttr_v;
|
|
}
|
|
if (charStyle) {
|
|
csAttr_v = *charStyle;
|
|
csAttr = &csAttr_v;
|
|
}
|
|
return new wxRichTextParagraph(text, parent, psAttr, csAttr);
|
|
}
|
|
}
|
|
virtual ~wxRichTextParagraph();
|
|
|
|
|
|
// Accessors
|
|
|
|
/// Get the cached lines
|
|
wxRichTextLineList& GetLines();
|
|
|
|
// Operations
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextParagraph& obj);
|
|
|
|
/// Clone
|
|
virtual wxRichTextObject* Clone() const;
|
|
|
|
/// Clear the cached lines
|
|
void ClearLines();
|
|
|
|
// Implementation
|
|
|
|
/// Apply paragraph styles such as centering to the wrapped lines
|
|
virtual void ApplyParagraphStyle(const wxTextAttrEx& attr, const wxRect& rect);
|
|
|
|
/// Insert text at the given position
|
|
virtual bool InsertText(long pos, const wxString& text);
|
|
|
|
/// Split an object at this position if necessary, and return
|
|
/// the previous object, or NULL if inserting at beginning.
|
|
virtual wxRichTextObject* SplitAt(long pos, wxRichTextObject** previousObject = NULL);
|
|
|
|
/// Move content to a list from this point
|
|
virtual void MoveToList(wxRichTextObject* obj, wxList& list);
|
|
|
|
/// Add content back from list
|
|
virtual void MoveFromList(wxList& list);
|
|
|
|
/// Get the plain text searching from the start or end of the range.
|
|
/// The resulting string may be shorter than the range given.
|
|
bool GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart = true);
|
|
|
|
/// Find a suitable wrap position. wrapPosition is the last position in the line to the left
|
|
/// of the split.
|
|
bool FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition);
|
|
|
|
/// Find the object at the given position
|
|
wxRichTextObject* FindObjectAtPosition(long position);
|
|
|
|
/// Get the bullet text for this paragraph.
|
|
wxString GetBulletText();
|
|
|
|
/// Allocate or reuse a line object
|
|
wxRichTextLine* AllocateLine(int pos);
|
|
|
|
/// Clear remaining unused line objects, if any
|
|
bool ClearUnusedLines(int lineCount);
|
|
|
|
/// Get combined attributes of the base style, paragraph style and character style. We use this to dynamically
|
|
/// retrieve the actual style.
|
|
// wxTextAttrEx GetCombinedAttributes(const wxTextAttrEx& contentStyle) const;
|
|
|
|
/// Get combined attributes of the base style and paragraph style.
|
|
wxTextAttrEx GetCombinedAttributes() const;
|
|
|
|
/// Get the first position from pos that has a line break character.
|
|
long GetFirstLineBreakPosition(long pos);
|
|
|
|
/// Create default tabstop array
|
|
static void InitDefaultTabs();
|
|
|
|
/// Clear default tabstop array
|
|
static void ClearDefaultTabs();
|
|
|
|
/// Get default tabstop array
|
|
static const wxArrayInt& GetDefaultTabs() { return sm_defaultTabs; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DocStr(wxRichTextPlainText,
|
|
"This object represents a single piece of text.", "");
|
|
|
|
class wxRichTextPlainText: public wxRichTextObject
|
|
{
|
|
public:
|
|
wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxTextAttrEx* style = NULL);
|
|
|
|
/// Get the first position from pos that has a line break character.
|
|
long GetFirstLineBreakPosition(long pos);
|
|
|
|
/// Get the text
|
|
const wxString& GetText() const;
|
|
|
|
/// Set the text
|
|
void SetText(const wxString& text);
|
|
|
|
// Operations
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextPlainText& obj);
|
|
|
|
/// Clone
|
|
virtual wxRichTextObject* Clone() const;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
// TODO: we may not even need wrappers for this class. It looks to me
|
|
// like wxRichTextImage might be enough...
|
|
DocStr(wxRichTextImageBlock,
|
|
"Stores information about an image, in binary in-memory form.", "");
|
|
|
|
class wxRichTextImageBlock: public wxObject
|
|
{
|
|
public:
|
|
wxRichTextImageBlock();
|
|
virtual ~wxRichTextImageBlock();
|
|
|
|
void Init();
|
|
void Clear();
|
|
|
|
// Load the original image into a memory block.
|
|
// If the image is not a JPEG, we must convert it into a JPEG
|
|
// to conserve space.
|
|
// If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
|
|
// load the image a 2nd time.
|
|
virtual bool MakeImageBlock(const wxString& filename, int imageType, wxImage& image, bool convertToJPEG = true);
|
|
|
|
// Make an image block from the wxImage in the given
|
|
// format.
|
|
virtual bool MakeImageBlock(wxImage& image, int imageType, int quality = 80);
|
|
|
|
// Write to a file
|
|
bool Write(const wxString& filename);
|
|
|
|
// Write data in hex to a stream
|
|
bool WriteHex(wxOutputStream& stream);
|
|
|
|
// Read data in hex from a stream
|
|
bool ReadHex(wxInputStream& stream, int length, int imageType);
|
|
|
|
// Copy from 'block'
|
|
void Copy(const wxRichTextImageBlock& block);
|
|
|
|
// Load a wxImage from the block
|
|
bool Load(wxImage& image);
|
|
|
|
|
|
//// Accessors
|
|
|
|
unsigned char* GetData() const;
|
|
size_t GetDataSize() const;
|
|
int GetImageType() const;
|
|
|
|
void SetData(unsigned char* image);
|
|
void SetDataSize(size_t size);
|
|
void SetImageType(int imageType);
|
|
|
|
bool IsOk() const;
|
|
|
|
// Gets the extension for the block's type
|
|
wxString GetExtension() const;
|
|
|
|
/// Implementation
|
|
|
|
// Allocate and read from stream as a block of memory
|
|
static unsigned char* ReadBlock(wxInputStream& stream, size_t size);
|
|
static unsigned char* ReadBlock(const wxString& filename, size_t size);
|
|
|
|
// Write memory block to stream
|
|
static bool WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size);
|
|
|
|
// Write memory block to file
|
|
static bool WriteBlock(const wxString& filename, unsigned char* block, size_t size);
|
|
};
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DocStr(wxRichTextImage,
|
|
"This object represents an image.", "");
|
|
|
|
class wxRichTextImage: public wxRichTextObject
|
|
{
|
|
public:
|
|
// TODO: Which of these constructors?
|
|
wxRichTextImage(wxRichTextObject* parent = NULL);
|
|
//wxRichTextImage(const wxImage& image, wxRichTextObject* parent = NULL, wxTextAttrEx* charStyle = NULL);
|
|
//wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL, wxTextAttrEx* charStyle = NULL);
|
|
|
|
|
|
// Accessors
|
|
|
|
/// Get the image
|
|
const wxImage& GetImage() const;
|
|
|
|
/// Set the image
|
|
void SetImage(const wxImage& image);
|
|
|
|
/// Get the image block containing the raw data
|
|
wxRichTextImageBlock& GetImageBlock();
|
|
|
|
// Operations
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextImage& obj);
|
|
|
|
/// Clone
|
|
virtual wxRichTextObject* Clone() const;
|
|
|
|
/// Load wxImage from the block
|
|
virtual bool LoadFromBlock();
|
|
|
|
/// Make block from the wxImage
|
|
virtual bool MakeBlock();
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
%typemap(out) wxRichTextFileHandler* { $result = wxPyMake_wxObject($1, (bool)$owner); }
|
|
wxUNTYPED_LIST_WRAPPER(wxRichTextFileHandlerList, wxRichTextFileHandler);
|
|
|
|
DocStr(wxRichTextBuffer,
|
|
"This is a kind of box, used to represent the whole buffer.", "");
|
|
|
|
class wxRichTextCommand;
|
|
class wxRichTextAction;
|
|
|
|
class wxRichTextBuffer: public wxRichTextParagraphLayoutBox
|
|
{
|
|
public:
|
|
wxRichTextBuffer();
|
|
virtual ~wxRichTextBuffer() ;
|
|
|
|
// Accessors
|
|
|
|
/// Gets the command processor
|
|
wxCommandProcessor* GetCommandProcessor() const;
|
|
|
|
/// Set style sheet, if any.
|
|
void SetStyleSheet(wxRichTextStyleSheet* styleSheet);
|
|
virtual wxRichTextStyleSheet* GetStyleSheet() const;
|
|
|
|
/// Set style sheet and notify of the change
|
|
bool SetStyleSheetAndNotify(wxRichTextStyleSheet* sheet);
|
|
|
|
/// Push style sheet to top of stack
|
|
bool PushStyleSheet(wxRichTextStyleSheet* styleSheet);
|
|
|
|
/// Pop style sheet from top of stack
|
|
wxRichTextStyleSheet* PopStyleSheet();
|
|
|
|
// Operations
|
|
|
|
/// Initialisation
|
|
void Init();
|
|
|
|
/// Clears the buffer, adds an empty paragraph, and clears the command processor.
|
|
virtual void ResetAndClearCommands();
|
|
|
|
/// Load a file
|
|
virtual bool LoadFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY);
|
|
|
|
/// Save a file
|
|
virtual bool SaveFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY);
|
|
|
|
/// Load from a stream
|
|
%Rename(LoadStream,
|
|
virtual bool , LoadFile(wxInputStream& stream, int type = wxRICHTEXT_TYPE_ANY));
|
|
|
|
/// Save to a stream
|
|
%Rename(SaveStream,
|
|
virtual bool , SaveFile(wxOutputStream& stream, int type = wxRICHTEXT_TYPE_ANY));
|
|
|
|
/// Set the handler flags, controlling loading and saving
|
|
void SetHandlerFlags(int flags) { m_handlerFlags = flags; }
|
|
|
|
/// Get the handler flags, controlling loading and saving
|
|
int GetHandlerFlags() const { return m_handlerFlags; }
|
|
|
|
/// Convenience function to add a paragraph of text
|
|
virtual wxRichTextRange AddParagraph(const wxString& text, wxTextAttrEx* paraStyle = NULL) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text, paraStyle); }
|
|
|
|
/// Begin collapsing undo/redo commands. Note that this may not work properly
|
|
/// if combining commands that delete or insert content, changing ranges for
|
|
/// subsequent actions.
|
|
virtual bool BeginBatchUndo(const wxString& cmdName);
|
|
|
|
/// End collapsing undo/redo commands
|
|
virtual bool EndBatchUndo();
|
|
|
|
/// Collapsing commands?
|
|
virtual bool BatchingUndo() const;
|
|
|
|
/// Submit immediately, or delay according to whether collapsing is on
|
|
virtual bool SubmitAction(wxRichTextAction* action);
|
|
|
|
/// Get collapsed command
|
|
virtual wxRichTextCommand* GetBatchedCommand() const;
|
|
|
|
/// Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
|
|
/// differently by each command. If not dealt with by a command implementation, then
|
|
/// it will be implemented automatically by not storing the command in the undo history
|
|
/// when the action is submitted to the command processor.
|
|
virtual bool BeginSuppressUndo();
|
|
|
|
/// End suppressing undo/redo commands.
|
|
virtual bool EndSuppressUndo();
|
|
|
|
/// Collapsing commands?
|
|
virtual bool SuppressingUndo() const;
|
|
|
|
/// Copy the range to the clipboard
|
|
virtual bool CopyToClipboard(const wxRichTextRange& range);
|
|
|
|
/// Paste the clipboard content to the buffer
|
|
virtual bool PasteFromClipboard(long position);
|
|
|
|
/// Can we paste from the clipboard?
|
|
virtual bool CanPasteFromClipboard() const;
|
|
|
|
/// Begin using a style
|
|
virtual bool BeginStyle(const wxTextAttrEx& style);
|
|
|
|
/// End the style
|
|
virtual bool EndStyle();
|
|
|
|
/// End all styles
|
|
virtual bool EndAllStyles();
|
|
|
|
/// Clear the style stack
|
|
virtual void ClearStyleStack();
|
|
|
|
/// Get the size of the style stack, for example to check correct nesting
|
|
virtual size_t GetStyleStackSize() const;
|
|
|
|
/// Begin using bold
|
|
bool BeginBold();
|
|
|
|
/// End using bold
|
|
bool EndBold();
|
|
|
|
/// Begin using italic
|
|
bool BeginItalic();
|
|
|
|
/// End using italic
|
|
bool EndItalic();
|
|
|
|
/// Begin using underline
|
|
bool BeginUnderline();
|
|
|
|
/// End using underline
|
|
bool EndUnderline();
|
|
|
|
/// Begin using point size
|
|
bool BeginFontSize(int pointSize);
|
|
|
|
/// End using point size
|
|
bool EndFontSize();
|
|
|
|
/// Begin using this font
|
|
bool BeginFont(const wxFont& font);
|
|
|
|
/// End using a font
|
|
bool EndFont();
|
|
|
|
/// Begin using this colour
|
|
bool BeginTextColour(const wxColour& colour);
|
|
|
|
/// End using a colour
|
|
bool EndTextColour();
|
|
|
|
/// Begin using alignment
|
|
bool BeginAlignment(wxTextAttrAlignment alignment);
|
|
|
|
/// End alignment
|
|
bool EndAlignment();
|
|
|
|
/// Begin left indent
|
|
bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0);
|
|
|
|
/// End left indent
|
|
bool EndLeftIndent();
|
|
|
|
/// Begin right indent
|
|
bool BeginRightIndent(int rightIndent);
|
|
|
|
/// End right indent
|
|
bool EndRightIndent();
|
|
|
|
/// Begin paragraph spacing
|
|
bool BeginParagraphSpacing(int before, int after);
|
|
|
|
/// End paragraph spacing
|
|
bool EndParagraphSpacing();
|
|
|
|
/// Begin line spacing
|
|
bool BeginLineSpacing(int lineSpacing);
|
|
|
|
/// End line spacing
|
|
bool EndLineSpacing();
|
|
|
|
/// Begin numbered bullet
|
|
bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD);
|
|
|
|
/// End numbered bullet
|
|
bool EndNumberedBullet();
|
|
|
|
/// Begin symbol bullet
|
|
bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL);
|
|
|
|
/// End symbol bullet
|
|
bool EndSymbolBullet();
|
|
|
|
/// Begin standard bullet
|
|
bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD);
|
|
|
|
/// End standard bullet
|
|
bool EndStandardBullet();
|
|
|
|
/// Begin named character style
|
|
bool BeginCharacterStyle(const wxString& characterStyle);
|
|
|
|
/// End named character style
|
|
bool EndCharacterStyle();
|
|
|
|
/// Begin named paragraph style
|
|
bool BeginParagraphStyle(const wxString& paragraphStyle);
|
|
|
|
/// End named character style
|
|
bool EndParagraphStyle();
|
|
|
|
/// Begin named list style
|
|
bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1);
|
|
|
|
/// End named character style
|
|
bool EndListStyle();
|
|
|
|
/// Begin URL
|
|
bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString);
|
|
|
|
/// End URL
|
|
bool EndURL();
|
|
|
|
// Event handling
|
|
|
|
/// Add an event handler
|
|
bool AddEventHandler(wxEvtHandler* handler);
|
|
|
|
/// Remove an event handler
|
|
bool RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler = false);
|
|
|
|
/// Clear event handlers
|
|
void ClearEventHandlers();
|
|
|
|
/// Send event to event handlers. If sendToAll is true, will send to all event handlers,
|
|
/// otherwise will stop at the first successful one.
|
|
bool SendEvent(wxEvent& event, bool sendToAll = true);
|
|
|
|
// Implementation
|
|
|
|
/// Copy
|
|
void Copy(const wxRichTextBuffer& obj);
|
|
|
|
/// Clone
|
|
virtual wxRichTextObject* Clone() const;
|
|
|
|
/// Submit command to insert paragraphs
|
|
bool InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags = 0);
|
|
|
|
/// Submit command to insert the given text
|
|
bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags = 0);
|
|
|
|
/// Submit command to insert a newline
|
|
bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, int flags = 0);
|
|
|
|
/// Submit command to insert the given image
|
|
bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl, int flags = 0);
|
|
|
|
/// Submit command to delete this range
|
|
bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl);
|
|
|
|
/// Mark modified
|
|
void Modify(bool modify = true);
|
|
bool IsModified() const;
|
|
|
|
/// Get the style that is appropriate for a new paragraph at this position.
|
|
/// If the previous paragraph has a paragraph style name, look up the next-paragraph
|
|
/// style.
|
|
wxRichTextAttr GetStyleForNewParagraph(long pos, bool caretPosition = false, bool lookUpNewParaStyle=false) const;
|
|
|
|
|
|
/// Returns the file handlers
|
|
static wxRichTextFileHandlerList_t& GetHandlers();
|
|
|
|
%disownarg(wxRichTextFileHandler *handler);
|
|
|
|
/// Adds a handler to the end
|
|
static void AddHandler(wxRichTextFileHandler *handler);
|
|
|
|
/// Inserts a handler at the front
|
|
static void InsertHandler(wxRichTextFileHandler *handler);
|
|
|
|
%cleardisown(wxRichTextFileHandler *handler);
|
|
|
|
|
|
/// Removes a handler
|
|
static bool RemoveHandler(const wxString& name);
|
|
|
|
/// Finds a handler by name
|
|
%Rename(FindHandlerByName,
|
|
static wxRichTextFileHandler* , FindHandler(const wxString& name));
|
|
|
|
/// Finds a handler by extension and type
|
|
%Rename(FindHandlerByExtension,
|
|
static wxRichTextFileHandler*, FindHandler(const wxString& extension, int imageType));
|
|
|
|
/// Finds a handler by filename or, if supplied, type
|
|
%Rename(FindHandlerByFilename,
|
|
static wxRichTextFileHandler* , FindHandlerFilenameOrType(const wxString& filename, int imageType));
|
|
|
|
/// Finds a handler by type
|
|
%Rename(FindHandlerByType,
|
|
static wxRichTextFileHandler* , FindHandler(int imageType));
|
|
|
|
|
|
// TODO: Handle returning the types array?
|
|
|
|
/// Gets a wildcard incorporating all visible handlers. If 'types' is present,
|
|
/// will be filled with the file type corresponding to each filter. This can be
|
|
/// used to determine the type to pass to LoadFile given a selected filter.
|
|
//static wxString GetExtWildcard(bool combine = false, bool save = false,
|
|
// wxArrayInt* types = NULL);
|
|
%extend {
|
|
KeepGIL(GetExtWildcard);
|
|
DocAStr(GetExtWildcard,
|
|
"GetExtWildcard(self, bool combine=False, bool save=False) --> (wildcards, types)",
|
|
"Gets a wildcard string for the file dialog based on all the currently
|
|
loaded richtext file handlers, and a list that can be used to map
|
|
those filter types to the file handler type.", "");
|
|
static PyObject* GetExtWildcard(bool combine = false, bool save = false) {
|
|
wxString wildcards;
|
|
wxArrayInt types;
|
|
wildcards = wxRichTextBuffer::GetExtWildcard(combine, save, &types);
|
|
PyObject* tup = PyTuple_New(2);
|
|
PyTuple_SET_ITEM(tup, 0, wx2PyString(wildcards));
|
|
PyTuple_SET_ITEM(tup, 1, wxArrayInt2PyList_helper(types));
|
|
return tup;
|
|
}
|
|
}
|
|
|
|
/// Clean up handlers
|
|
static void CleanUpHandlers();
|
|
|
|
/// Initialise the standard handlers
|
|
static void InitStandardHandlers();
|
|
|
|
/// Get renderer
|
|
static wxRichTextRenderer* GetRenderer();
|
|
|
|
/// Set renderer, deleting old one
|
|
static void SetRenderer(wxRichTextRenderer* renderer);
|
|
|
|
/// Minimum margin between bullet and paragraph in 10ths of a mm
|
|
static int GetBulletRightMargin();
|
|
static void SetBulletRightMargin(int margin);
|
|
|
|
/// Factor to multiply by character height to get a reasonable bullet size
|
|
static float GetBulletProportion();
|
|
static void SetBulletProportion(float prop);
|
|
|
|
/// Scale factor for calculating dimensions
|
|
double GetScale() const;
|
|
void SetScale(double scale);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// TODO: Do we need wrappers for the command processor, undo/redo, etc.?
|
|
//
|
|
// enum wxRichTextCommandId
|
|
// {
|
|
// wxRICHTEXT_INSERT,
|
|
// wxRICHTEXT_DELETE,
|
|
// wxRICHTEXT_CHANGE_STYLE
|
|
// };
|
|
// class WXDLLIMPEXP_RICHTEXT wxRichTextCommand: public wxCommand
|
|
// class WXDLLIMPEXP_RICHTEXT wxRichTextAction: public wxObject
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
%newgroup
|
|
|
|
|
|
/*!
|
|
* Handler flags
|
|
*/
|
|
|
|
enum {
|
|
// Include style sheet when loading and saving
|
|
wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET,
|
|
|
|
// Save images to memory file system in HTML handler
|
|
wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY,
|
|
|
|
// Save images to files in HTML handler
|
|
wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES,
|
|
|
|
// Save images as inline base64 data in HTML handler
|
|
wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64,
|
|
|
|
// Don't write header and footer (or BODY), so we can include the
|
|
// fragment in a larger document
|
|
wxRICHTEXT_HANDLER_NO_HEADER_FOOTER,
|
|
};
|
|
|
|
|
|
|
|
|
|
DocStr(wxRichTextFileHandler,
|
|
"Base class for file handlers", "");
|
|
|
|
class wxRichTextFileHandler: public wxObject
|
|
{
|
|
public:
|
|
//wxRichTextFileHandler(const wxString& name = wxEmptyString, **** This is an ABC
|
|
// const wxString& ext = wxEmptyString,
|
|
// int type = 0);
|
|
|
|
~wxRichTextFileHandler();
|
|
|
|
%Rename(LoadStream,
|
|
bool, LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream));
|
|
%Rename(SaveStream,
|
|
bool, SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream));
|
|
|
|
bool LoadFile(wxRichTextBuffer *buffer, const wxString& filename);
|
|
bool SaveFile(wxRichTextBuffer *buffer, const wxString& filename);
|
|
|
|
/// Can we handle this filename (if using files)? By default, checks the extension.
|
|
virtual bool CanHandle(const wxString& filename) const;
|
|
|
|
/// Can we save using this handler?
|
|
virtual bool CanSave() const;
|
|
|
|
/// Can we load using this handler?
|
|
virtual bool CanLoad() const;
|
|
|
|
/// Should this handler be visible to the user?
|
|
virtual bool IsVisible() const;
|
|
virtual void SetVisible(bool visible);
|
|
|
|
/// The name of the nandler
|
|
void SetName(const wxString& name);
|
|
wxString GetName() const;
|
|
%property(Name, GetName, SetName)
|
|
|
|
/// The default extension to recognise
|
|
void SetExtension(const wxString& ext);
|
|
wxString GetExtension() const;
|
|
%property(Extension, GetExtension, SetExtension)
|
|
|
|
/// The handler type
|
|
void SetType(int type);
|
|
int GetType() const;
|
|
%property(Type, GetType, SetType)
|
|
|
|
/// Flags controlling how loading and saving is done
|
|
void SetFlags(int flags);
|
|
int GetFlags() const;
|
|
%property(Flags, GetFlags, SetFlags)
|
|
|
|
/// Encoding to use when saving a file. If empty, a suitable encoding is chosen
|
|
void SetEncoding(const wxString& encoding);
|
|
const wxString& GetEncoding() const;
|
|
%property(Encoding, GetEncoding, SetEncoding)
|
|
};
|
|
|
|
|
|
|
|
MAKE_CONST_WXSTRING2(TextName, wxT("Text"));
|
|
MAKE_CONST_WXSTRING2(TextExt, wxT("txt"));
|
|
|
|
class wxRichTextPlainTextHandler: public wxRichTextFileHandler
|
|
{
|
|
public:
|
|
wxRichTextPlainTextHandler(const wxString& name = wxPyTextName,
|
|
const wxString& ext = wxPyTextExt,
|
|
int type = wxRICHTEXT_TYPE_TEXT);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
%newgroup
|
|
|
|
|
|
// TODO: Make a PyRichTextRenderer class
|
|
|
|
|
|
/*!
|
|
* wxRichTextRenderer isolates common drawing functionality
|
|
*/
|
|
|
|
class wxRichTextRenderer: public wxObject
|
|
{
|
|
public:
|
|
wxRichTextRenderer() {}
|
|
virtual ~wxRichTextRenderer() {}
|
|
|
|
/// Draw a standard bullet, as specified by the value of GetBulletName
|
|
virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttrEx& attr, const wxRect& rect) = 0;
|
|
|
|
/// Draw a bullet that can be described by text, such as numbered or symbol bullets
|
|
virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttrEx& attr, const wxRect& rect, const wxString& text) = 0;
|
|
|
|
/// Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
|
|
virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttrEx& attr, const wxRect& rect) = 0;
|
|
|
|
/// Enumerate the standard bullet names currently supported
|
|
virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames) = 0;
|
|
};
|
|
|
|
/*!
|
|
* wxRichTextStdRenderer: standard renderer
|
|
*/
|
|
|
|
class wxRichTextStdRenderer: public wxRichTextRenderer
|
|
{
|
|
public:
|
|
wxRichTextStdRenderer() {}
|
|
|
|
/// Draw a standard bullet, as specified by the value of GetBulletName
|
|
virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttrEx& attr, const wxRect& rect);
|
|
|
|
/// Draw a bullet that can be described by text, such as numbered or symbol bullets
|
|
virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttrEx& attr, const wxRect& rect, const wxString& text);
|
|
|
|
/// Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
|
|
virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttrEx& attr, const wxRect& rect);
|
|
|
|
/// Enumerate the standard bullet names currently supported
|
|
virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames);
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|