mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-27 05:32:41 -06:00
2823 lines
68 KiB
Text
Executable file
2823 lines
68 KiB
Text
Executable file
# -*- coding: utf-8 -*-
|
|
#---------------------------------------------------------------------------
|
|
# This file is generated by wxPython's PI generator. Do not edit by hand.
|
|
#
|
|
# (The *.pi files are used by WingIDE to provide more information than it is
|
|
# able to glean from introspection of extension types and methods.)
|
|
#
|
|
# Copyright: (c) 2013 by Total Control Software
|
|
# License: wxWindows License
|
|
#---------------------------------------------------------------------------
|
|
|
|
#-- begin-_html --#
|
|
|
|
import wx
|
|
#-- end-_html --#
|
|
#-- begin-htmldefs --#
|
|
HTML_ALIGN_LEFT = 0
|
|
HTML_ALIGN_RIGHT = 0
|
|
HTML_ALIGN_JUSTIFY = 0
|
|
HTML_ALIGN_TOP = 0
|
|
HTML_ALIGN_BOTTOM = 0
|
|
HTML_ALIGN_CENTER = 0
|
|
HTML_CLR_FOREGROUND = 0
|
|
HTML_CLR_BACKGROUND = 0
|
|
HTML_CLR_TRANSPARENT_BACKGROUND = 0
|
|
HTML_UNITS_PIXELS = 0
|
|
HTML_UNITS_PERCENT = 0
|
|
HTML_INDENT_LEFT = 0
|
|
HTML_INDENT_RIGHT = 0
|
|
HTML_INDENT_TOP = 0
|
|
HTML_INDENT_BOTTOM = 0
|
|
HTML_INDENT_HORIZONTAL = 0
|
|
HTML_INDENT_VERTICAL = 0
|
|
HTML_INDENT_ALL = 0
|
|
HTML_COND_ISANCHOR = 0
|
|
HTML_COND_ISIMAGEMAP = 0
|
|
HTML_COND_USER = 0
|
|
INT_MAX = 0
|
|
#-- end-htmldefs --#
|
|
#-- begin-htmlcell --#
|
|
HTML_SEL_OUT = 0
|
|
HTML_SEL_IN = 0
|
|
HTML_SEL_CHANGING = 0
|
|
HTML_FIND_EXACT = 0
|
|
HTML_FIND_NEAREST_BEFORE = 0
|
|
HTML_FIND_NEAREST_AFTER = 0
|
|
HTML_SCRIPT_NORMAL = 0
|
|
HTML_SCRIPT_SUB = 0
|
|
HTML_SCRIPT_SUP = 0
|
|
|
|
class HtmlSelection(object):
|
|
"""
|
|
HtmlSelection()
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlSelection()
|
|
"""
|
|
|
|
def Set(self, *args, **kw):
|
|
"""
|
|
Set(fromPos, fromCell, toPos, toCell)
|
|
Set(fromCell, toCell)
|
|
"""
|
|
|
|
def GetFromCell(self):
|
|
"""
|
|
GetFromCell() -> HtmlCell
|
|
"""
|
|
|
|
def GetToCell(self):
|
|
"""
|
|
GetToCell() -> HtmlCell
|
|
"""
|
|
|
|
def GetFromPos(self):
|
|
"""
|
|
GetFromPos() -> wx.Point
|
|
"""
|
|
|
|
def GetToPos(self):
|
|
"""
|
|
GetToPos() -> wx.Point
|
|
"""
|
|
|
|
def ClearFromToCharacterPos(self):
|
|
"""
|
|
ClearFromToCharacterPos()
|
|
"""
|
|
|
|
def AreFromToCharacterPosSet(self):
|
|
"""
|
|
AreFromToCharacterPosSet() -> bool
|
|
"""
|
|
|
|
def SetFromCharacterPos(self, pos):
|
|
"""
|
|
SetFromCharacterPos(pos)
|
|
"""
|
|
|
|
def SetToCharacterPos(self, pos):
|
|
"""
|
|
SetToCharacterPos(pos)
|
|
"""
|
|
|
|
def GetFromCharacterPos(self):
|
|
"""
|
|
GetFromCharacterPos() -> Coord
|
|
"""
|
|
|
|
def GetToCharacterPos(self):
|
|
"""
|
|
GetToCharacterPos() -> Coord
|
|
"""
|
|
|
|
def IsEmpty(self):
|
|
"""
|
|
IsEmpty() -> bool
|
|
"""
|
|
FromCell = property(None, None)
|
|
FromCharacterPos = property(None, None)
|
|
FromPos = property(None, None)
|
|
ToCell = property(None, None)
|
|
ToCharacterPos = property(None, None)
|
|
ToPos = property(None, None)
|
|
# end of class HtmlSelection
|
|
|
|
|
|
class HtmlRenderingState(object):
|
|
"""
|
|
HtmlRenderingState()
|
|
|
|
Selection state is passed to wxHtmlCell::Draw so that it can render
|
|
itself differently e.g.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlRenderingState()
|
|
|
|
Selection state is passed to wxHtmlCell::Draw so that it can render
|
|
itself differently e.g.
|
|
"""
|
|
|
|
def SetSelectionState(self, s):
|
|
"""
|
|
SetSelectionState(s)
|
|
"""
|
|
|
|
def GetSelectionState(self):
|
|
"""
|
|
GetSelectionState() -> HtmlSelectionState
|
|
"""
|
|
|
|
def SetFgColour(self, c):
|
|
"""
|
|
SetFgColour(c)
|
|
"""
|
|
|
|
def GetFgColour(self):
|
|
"""
|
|
GetFgColour() -> wx.Colour
|
|
"""
|
|
|
|
def SetBgColour(self, c):
|
|
"""
|
|
SetBgColour(c)
|
|
"""
|
|
|
|
def GetBgColour(self):
|
|
"""
|
|
GetBgColour() -> wx.Colour
|
|
"""
|
|
|
|
def SetBgMode(self, m):
|
|
"""
|
|
SetBgMode(m)
|
|
"""
|
|
|
|
def GetBgMode(self):
|
|
"""
|
|
GetBgMode() -> int
|
|
"""
|
|
BgColour = property(None, None)
|
|
BgMode = property(None, None)
|
|
FgColour = property(None, None)
|
|
SelectionState = property(None, None)
|
|
# end of class HtmlRenderingState
|
|
|
|
|
|
class HtmlRenderingStyle(object):
|
|
"""
|
|
wxHtmlSelection is data holder with information about text selection.
|
|
"""
|
|
|
|
def GetSelectedTextColour(self, clr):
|
|
"""
|
|
GetSelectedTextColour(clr) -> wx.Colour
|
|
|
|
Returns the colour to use for the selected text.
|
|
"""
|
|
|
|
def GetSelectedTextBgColour(self, clr):
|
|
"""
|
|
GetSelectedTextBgColour(clr) -> wx.Colour
|
|
|
|
Returns the colour to use for the selected text's background.
|
|
"""
|
|
# end of class HtmlRenderingStyle
|
|
|
|
|
|
class HtmlRenderingInfo(object):
|
|
"""
|
|
HtmlRenderingInfo()
|
|
|
|
This class contains information given to cells when drawing them.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlRenderingInfo()
|
|
|
|
This class contains information given to cells when drawing them.
|
|
"""
|
|
|
|
def SetSelection(self, s):
|
|
"""
|
|
SetSelection(s)
|
|
|
|
Accessors.
|
|
"""
|
|
|
|
def GetSelection(self):
|
|
"""
|
|
GetSelection() -> HtmlSelection
|
|
|
|
Accessors.
|
|
"""
|
|
|
|
def SetStyle(self, style):
|
|
"""
|
|
SetStyle(style)
|
|
|
|
Accessors.
|
|
"""
|
|
|
|
def GetStyle(self):
|
|
"""
|
|
GetStyle() -> HtmlRenderingStyle
|
|
|
|
Accessors.
|
|
"""
|
|
|
|
def GetState(self):
|
|
"""
|
|
GetState() -> HtmlRenderingState
|
|
|
|
Accessors.
|
|
"""
|
|
Selection = property(None, None)
|
|
State = property(None, None)
|
|
Style = property(None, None)
|
|
# end of class HtmlRenderingInfo
|
|
|
|
|
|
class HtmlCell(wx.Object):
|
|
"""
|
|
HtmlCell()
|
|
|
|
Internal data structure.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlCell()
|
|
|
|
Internal data structure.
|
|
"""
|
|
|
|
def AdjustPagebreak(self, pagebreak, known_pagebreaks, pageHeight):
|
|
"""
|
|
AdjustPagebreak(pagebreak, known_pagebreaks, pageHeight) -> (bool, pagebreak)
|
|
|
|
This method is used to adjust pagebreak position.
|
|
"""
|
|
|
|
def Draw(self, dc, x, y, view_y1, view_y2, info):
|
|
"""
|
|
Draw(dc, x, y, view_y1, view_y2, info)
|
|
|
|
Renders the cell.
|
|
"""
|
|
|
|
def DrawInvisible(self, dc, x, y, info):
|
|
"""
|
|
DrawInvisible(dc, x, y, info)
|
|
|
|
This method is called instead of Draw() when the cell is certainly out
|
|
of the screen (and thus invisible).
|
|
"""
|
|
|
|
def Find(self, condition, param):
|
|
"""
|
|
Find(condition, param) -> HtmlCell
|
|
|
|
Returns pointer to itself if this cell matches condition (or if any of
|
|
the cells following in the list matches), NULL otherwise.
|
|
"""
|
|
|
|
def GetDescent(self):
|
|
"""
|
|
GetDescent() -> int
|
|
|
|
Returns descent value of the cell (m_Descent member).
|
|
"""
|
|
|
|
def GetFirstChild(self):
|
|
"""
|
|
GetFirstChild() -> HtmlCell
|
|
|
|
Returns pointer to the first cell in the list.
|
|
"""
|
|
|
|
def GetHeight(self):
|
|
"""
|
|
GetHeight() -> int
|
|
|
|
Returns height of the cell (m_Height member).
|
|
"""
|
|
|
|
def GetId(self):
|
|
"""
|
|
GetId() -> String
|
|
|
|
Returns unique cell identifier if there is any, the empty string
|
|
otherwise.
|
|
"""
|
|
|
|
def GetLink(self, x=0, y=0):
|
|
"""
|
|
GetLink(x=0, y=0) -> HtmlLinkInfo
|
|
|
|
Returns hypertext link if associated with this cell or NULL otherwise.
|
|
"""
|
|
|
|
def GetMouseCursor(self, window):
|
|
"""
|
|
GetMouseCursor(window) -> wx.Cursor
|
|
|
|
Returns cursor to show when mouse pointer is over the cell.
|
|
"""
|
|
|
|
def GetMouseCursorAt(self, window, rePos):
|
|
"""
|
|
GetMouseCursorAt(window, rePos) -> wx.Cursor
|
|
|
|
Returns cursor to show when mouse pointer is over the specified point.
|
|
"""
|
|
|
|
def GetNext(self):
|
|
"""
|
|
GetNext() -> HtmlCell
|
|
|
|
Returns pointer to the next cell in list (see htmlcell.h if you're
|
|
interested in details).
|
|
"""
|
|
|
|
def GetParent(self):
|
|
"""
|
|
GetParent() -> HtmlContainerCell
|
|
|
|
Returns pointer to parent container.
|
|
"""
|
|
|
|
def GetPosX(self):
|
|
"""
|
|
GetPosX() -> int
|
|
|
|
Returns X position within parent (the value is relative to parent's
|
|
upper left corner).
|
|
"""
|
|
|
|
def GetPosY(self):
|
|
"""
|
|
GetPosY() -> int
|
|
|
|
Returns Y position within parent (the value is relative to parent's
|
|
upper left corner).
|
|
"""
|
|
|
|
def GetWidth(self):
|
|
"""
|
|
GetWidth() -> int
|
|
|
|
Returns width of the cell (m_Width member).
|
|
"""
|
|
|
|
def Layout(self, w):
|
|
"""
|
|
Layout(w)
|
|
|
|
Layouts the cell.
|
|
"""
|
|
|
|
def ProcessMouseClick(self, window, pos, event):
|
|
"""
|
|
ProcessMouseClick(window, pos, event) -> bool
|
|
|
|
This function is simple event handler.
|
|
"""
|
|
|
|
def SetId(self, id):
|
|
"""
|
|
SetId(id)
|
|
|
|
Sets unique cell identifier.
|
|
"""
|
|
|
|
def SetLink(self, link):
|
|
"""
|
|
SetLink(link)
|
|
|
|
Sets the hypertext link associated with this cell.
|
|
"""
|
|
|
|
def SetNext(self, cell):
|
|
"""
|
|
SetNext(cell)
|
|
|
|
Sets the next cell in the list.
|
|
"""
|
|
|
|
def SetParent(self, p):
|
|
"""
|
|
SetParent(p)
|
|
|
|
Sets parent container of this cell.
|
|
"""
|
|
|
|
def SetPos(self, x, y):
|
|
"""
|
|
SetPos(x, y)
|
|
|
|
Sets the cell's position within parent container.
|
|
"""
|
|
Descent = property(None, None)
|
|
FirstChild = property(None, None)
|
|
Height = property(None, None)
|
|
Id = property(None, None)
|
|
Link = property(None, None)
|
|
Next = property(None, None)
|
|
Parent = property(None, None)
|
|
PosX = property(None, None)
|
|
PosY = property(None, None)
|
|
Width = property(None, None)
|
|
# end of class HtmlCell
|
|
|
|
|
|
class HtmlContainerCell(HtmlCell):
|
|
"""
|
|
HtmlContainerCell(parent)
|
|
|
|
The wxHtmlContainerCell class is an implementation of a cell that may
|
|
contain more cells in it.
|
|
"""
|
|
|
|
def __init__(self, parent):
|
|
"""
|
|
HtmlContainerCell(parent)
|
|
|
|
The wxHtmlContainerCell class is an implementation of a cell that may
|
|
contain more cells in it.
|
|
"""
|
|
|
|
def GetAlignHor(self):
|
|
"""
|
|
GetAlignHor() -> int
|
|
|
|
Returns container's horizontal alignment.
|
|
"""
|
|
|
|
def GetAlignVer(self):
|
|
"""
|
|
GetAlignVer() -> int
|
|
|
|
Returns container's vertical alignment.
|
|
"""
|
|
|
|
def GetBackgroundColour(self):
|
|
"""
|
|
GetBackgroundColour() -> wx.Colour
|
|
|
|
Returns the background colour of the container or wxNullColour if no
|
|
background colour is set.
|
|
"""
|
|
|
|
def GetIndent(self, ind):
|
|
"""
|
|
GetIndent(ind) -> int
|
|
|
|
Returns the indentation.
|
|
"""
|
|
|
|
def GetIndentUnits(self, ind):
|
|
"""
|
|
GetIndentUnits(ind) -> int
|
|
|
|
Returns the units of indentation for ind where ind is one of the
|
|
wxHTML_INDENT_* constants.
|
|
"""
|
|
|
|
def InsertCell(self, cell):
|
|
"""
|
|
InsertCell(cell)
|
|
|
|
Inserts a new cell into the container.
|
|
"""
|
|
|
|
def SetAlign(self, tag):
|
|
"""
|
|
SetAlign(tag)
|
|
|
|
Sets the container's alignment (both horizontal and vertical)
|
|
according to the values stored in tag.
|
|
"""
|
|
|
|
def SetAlignHor(self, al):
|
|
"""
|
|
SetAlignHor(al)
|
|
|
|
Sets the container's horizontal alignment.
|
|
"""
|
|
|
|
def SetAlignVer(self, al):
|
|
"""
|
|
SetAlignVer(al)
|
|
|
|
Sets the container's vertical alignment.
|
|
"""
|
|
|
|
def SetBackgroundColour(self, clr):
|
|
"""
|
|
SetBackgroundColour(clr)
|
|
|
|
Sets the background colour for this container.
|
|
"""
|
|
|
|
def SetBorder(self, clr1, clr2, border=1):
|
|
"""
|
|
SetBorder(clr1, clr2, border=1)
|
|
|
|
Sets the border (frame) colours.
|
|
"""
|
|
|
|
def SetIndent(self, i, what, units=HTML_UNITS_PIXELS):
|
|
"""
|
|
SetIndent(i, what, units=HTML_UNITS_PIXELS)
|
|
|
|
Sets the indentation (free space between borders of container and
|
|
subcells).
|
|
"""
|
|
|
|
def SetMinHeight(self, h, align=HTML_ALIGN_TOP):
|
|
"""
|
|
SetMinHeight(h, align=HTML_ALIGN_TOP)
|
|
|
|
Sets minimal height of the container.
|
|
"""
|
|
|
|
def SetWidthFloat(self, *args, **kw):
|
|
"""
|
|
SetWidthFloat(w, units)
|
|
SetWidthFloat(tag, pixel_scale=1.0)
|
|
|
|
Sets floating width adjustment.
|
|
"""
|
|
AlignHor = property(None, None)
|
|
AlignVer = property(None, None)
|
|
BackgroundColour = property(None, None)
|
|
# end of class HtmlContainerCell
|
|
|
|
|
|
class HtmlLinkInfo(wx.Object):
|
|
"""
|
|
HtmlLinkInfo()
|
|
HtmlLinkInfo(href, target=wx.EmptyString)
|
|
|
|
This class stores all necessary information about hypertext links (as
|
|
represented by <A> tag in HTML documents).
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
HtmlLinkInfo()
|
|
HtmlLinkInfo(href, target=wx.EmptyString)
|
|
|
|
This class stores all necessary information about hypertext links (as
|
|
represented by <A> tag in HTML documents).
|
|
"""
|
|
|
|
def GetEvent(self):
|
|
"""
|
|
GetEvent() -> wx.MouseEvent
|
|
|
|
Return pointer to event that generated OnLinkClicked() event.
|
|
"""
|
|
|
|
def GetHref(self):
|
|
"""
|
|
GetHref() -> String
|
|
|
|
Return HREF value of the <A> tag.
|
|
"""
|
|
|
|
def GetHtmlCell(self):
|
|
"""
|
|
GetHtmlCell() -> HtmlCell
|
|
|
|
Return pointer to the cell that was clicked.
|
|
"""
|
|
|
|
def GetTarget(self):
|
|
"""
|
|
GetTarget() -> String
|
|
|
|
Return TARGET value of the <A> tag (this value is used to specify in
|
|
which frame should be the page pointed by GetHref() Href opened).
|
|
"""
|
|
Event = property(None, None)
|
|
Href = property(None, None)
|
|
HtmlCell = property(None, None)
|
|
Target = property(None, None)
|
|
# end of class HtmlLinkInfo
|
|
|
|
|
|
class HtmlColourCell(HtmlCell):
|
|
"""
|
|
HtmlColourCell(clr, flags=HTML_CLR_FOREGROUND)
|
|
|
|
This cell changes the colour of either the background or the
|
|
foreground.
|
|
"""
|
|
|
|
def __init__(self, clr, flags=HTML_CLR_FOREGROUND):
|
|
"""
|
|
HtmlColourCell(clr, flags=HTML_CLR_FOREGROUND)
|
|
|
|
This cell changes the colour of either the background or the
|
|
foreground.
|
|
"""
|
|
# end of class HtmlColourCell
|
|
|
|
|
|
class HtmlWidgetCell(HtmlCell):
|
|
"""
|
|
HtmlWidgetCell(wnd, w=0)
|
|
|
|
wxHtmlWidgetCell is a class that provides a connection between HTML
|
|
cells and widgets (an object derived from wxWindow).
|
|
"""
|
|
|
|
def __init__(self, wnd, w=0):
|
|
"""
|
|
HtmlWidgetCell(wnd, w=0)
|
|
|
|
wxHtmlWidgetCell is a class that provides a connection between HTML
|
|
cells and widgets (an object derived from wxWindow).
|
|
"""
|
|
# end of class HtmlWidgetCell
|
|
|
|
|
|
class HtmlWordCell(HtmlCell):
|
|
"""
|
|
HtmlWordCell(word, dc)
|
|
|
|
This html cell represents a single word or text fragment in the
|
|
document stream.
|
|
"""
|
|
|
|
def __init__(self, word, dc):
|
|
"""
|
|
HtmlWordCell(word, dc)
|
|
|
|
This html cell represents a single word or text fragment in the
|
|
document stream.
|
|
"""
|
|
# end of class HtmlWordCell
|
|
|
|
|
|
class HtmlWordWithTabsCell(HtmlWordCell):
|
|
"""
|
|
HtmlWordWithTabsCell(word, wordOrig, linepos, dc)
|
|
|
|
wxHtmlWordCell is a specialization for storing text fragments with
|
|
embedded tab characters.
|
|
"""
|
|
|
|
def __init__(self, word, wordOrig, linepos, dc):
|
|
"""
|
|
HtmlWordWithTabsCell(word, wordOrig, linepos, dc)
|
|
|
|
wxHtmlWordCell is a specialization for storing text fragments with
|
|
embedded tab characters.
|
|
"""
|
|
# end of class HtmlWordWithTabsCell
|
|
|
|
|
|
class HtmlFontCell(HtmlCell):
|
|
"""
|
|
HtmlFontCell(font)
|
|
|
|
This cell represents a font change in the document stream.
|
|
"""
|
|
|
|
def __init__(self, font):
|
|
"""
|
|
HtmlFontCell(font)
|
|
|
|
This cell represents a font change in the document stream.
|
|
"""
|
|
# end of class HtmlFontCell
|
|
|
|
#-- end-htmlcell --#
|
|
#-- begin-htmlfilt --#
|
|
|
|
class HtmlFilter(wx.Object):
|
|
"""
|
|
HtmlFilter()
|
|
|
|
This class is the parent class of input filters for wxHtmlWindow.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlFilter()
|
|
|
|
This class is the parent class of input filters for wxHtmlWindow.
|
|
"""
|
|
|
|
def CanRead(self, file):
|
|
"""
|
|
CanRead(file) -> bool
|
|
|
|
Returns true if this filter is capable of reading file file.
|
|
"""
|
|
|
|
def ReadFile(self, file):
|
|
"""
|
|
ReadFile(file) -> String
|
|
|
|
Reads the file and returns string with HTML document.
|
|
"""
|
|
# end of class HtmlFilter
|
|
|
|
#-- end-htmlfilt --#
|
|
#-- begin-htmltag --#
|
|
|
|
class HtmlTag(object):
|
|
"""
|
|
This class represents a single HTML tag.
|
|
"""
|
|
|
|
def GetAllParams(self):
|
|
"""
|
|
GetAllParams() -> String
|
|
|
|
Returns a string containing all parameters.
|
|
"""
|
|
|
|
def GetBeginPos(self):
|
|
"""
|
|
GetBeginPos() -> int
|
|
|
|
Returns beginning position of the text between this tag and paired
|
|
ending tag.
|
|
"""
|
|
|
|
def GetEndPos1(self):
|
|
"""
|
|
GetEndPos1() -> int
|
|
|
|
Returns ending position of the text between this tag and paired ending
|
|
tag.
|
|
"""
|
|
|
|
def GetEndPos2(self):
|
|
"""
|
|
GetEndPos2() -> int
|
|
|
|
Returns ending position 2 of the text between this tag and paired
|
|
ending tag.
|
|
"""
|
|
|
|
def GetName(self):
|
|
"""
|
|
GetName() -> String
|
|
|
|
Returns tag's name.
|
|
"""
|
|
|
|
def GetParam(self, par, with_quotes=False):
|
|
"""
|
|
GetParam(par, with_quotes=False) -> String
|
|
|
|
Returns the value of the parameter.
|
|
"""
|
|
|
|
def GetParamAsColour(self, par):
|
|
"""
|
|
GetParamAsColour(par) -> (bool, clr)
|
|
|
|
Interprets tag parameter par as colour specification and saves its
|
|
value into wxColour variable pointed by clr.
|
|
"""
|
|
|
|
def GetParamAsInt(self, par):
|
|
"""
|
|
GetParamAsInt(par) -> (bool, value)
|
|
|
|
Interprets tag parameter par as an integer and saves its value into
|
|
int variable pointed by value.
|
|
"""
|
|
|
|
def GetParamAsString(self, par, value):
|
|
"""
|
|
GetParamAsString(par, value) -> bool
|
|
|
|
Get the value of the parameter.
|
|
"""
|
|
|
|
def HasEnding(self):
|
|
"""
|
|
HasEnding() -> bool
|
|
|
|
Returns true if this tag is paired with ending tag, false otherwise.
|
|
"""
|
|
|
|
def HasParam(self, par):
|
|
"""
|
|
HasParam(par) -> bool
|
|
|
|
Returns true if the tag has a parameter of the given name.
|
|
"""
|
|
|
|
@staticmethod
|
|
def ParseAsColour(str):
|
|
"""
|
|
ParseAsColour(str) -> (bool, clr)
|
|
|
|
Parses the given string as an HTML colour.
|
|
"""
|
|
AllParams = property(None, None)
|
|
BeginPos = property(None, None)
|
|
EndPos1 = property(None, None)
|
|
EndPos2 = property(None, None)
|
|
Name = property(None, None)
|
|
# end of class HtmlTag
|
|
|
|
#-- end-htmltag --#
|
|
#-- begin-htmlpars --#
|
|
HTML_URL_PAGE = 0
|
|
HTML_URL_IMAGE = 0
|
|
HTML_URL_OTHER = 0
|
|
|
|
class HtmlTagHandler(wx.Object):
|
|
"""
|
|
HtmlTagHandler()
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlTagHandler()
|
|
"""
|
|
|
|
def GetSupportedTags(self):
|
|
"""
|
|
GetSupportedTags() -> String
|
|
|
|
Returns list of supported tags.
|
|
"""
|
|
|
|
def HandleTag(self, tag):
|
|
"""
|
|
HandleTag(tag) -> bool
|
|
|
|
This is the core method of each handler.
|
|
"""
|
|
|
|
def SetParser(self, parser):
|
|
"""
|
|
SetParser(parser)
|
|
|
|
Assigns parser to this handler.
|
|
"""
|
|
|
|
def GetParser(self):
|
|
"""
|
|
GetParser() -> HtmlParser
|
|
|
|
Returns the parser associated with this tag handler.
|
|
"""
|
|
Parser = property(None, None)
|
|
SupportedTags = property(None, None)
|
|
|
|
def ParseInner(self, tag):
|
|
"""
|
|
ParseInner(tag)
|
|
|
|
This method calls parser's wxHtmlParser::DoParsing method for the
|
|
string between this tag and the paired ending tag:
|
|
"""
|
|
|
|
def ParseInnerSource(self, source):
|
|
"""
|
|
ParseInnerSource(source)
|
|
|
|
Parses given source as if it was tag's inner code (see
|
|
wxHtmlParser::GetInnerSource).
|
|
"""
|
|
# end of class HtmlTagHandler
|
|
|
|
|
|
class HtmlParser(object):
|
|
"""
|
|
HtmlParser()
|
|
|
|
Classes derived from this handle the generic parsing of HTML
|
|
documents: it scans the document and divide it into blocks of tags
|
|
(where one block consists of beginning and ending tag and of text
|
|
between these two tags).
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlParser()
|
|
|
|
Classes derived from this handle the generic parsing of HTML
|
|
documents: it scans the document and divide it into blocks of tags
|
|
(where one block consists of beginning and ending tag and of text
|
|
between these two tags).
|
|
"""
|
|
|
|
def AddTagHandler(self, handler):
|
|
"""
|
|
AddTagHandler(handler)
|
|
|
|
Adds handler to the internal list ( hash table) of handlers.
|
|
"""
|
|
|
|
def DoParsing(self, *args, **kw):
|
|
"""
|
|
DoParsing()
|
|
|
|
Parses the whole m_Source.
|
|
"""
|
|
|
|
def DoneParser(self):
|
|
"""
|
|
DoneParser()
|
|
|
|
This must be called after DoParsing().
|
|
"""
|
|
|
|
def GetFS(self):
|
|
"""
|
|
GetFS() -> wx.FileSystem
|
|
|
|
Returns pointer to the file system.
|
|
"""
|
|
|
|
def GetProduct(self):
|
|
"""
|
|
GetProduct() -> wx.Object
|
|
|
|
Returns product of parsing.
|
|
"""
|
|
|
|
def GetSource(self):
|
|
"""
|
|
GetSource() -> String
|
|
|
|
Returns pointer to the source being parsed.
|
|
"""
|
|
|
|
def InitParser(self, source):
|
|
"""
|
|
InitParser(source)
|
|
|
|
Setups the parser for parsing the source string.
|
|
"""
|
|
|
|
def OpenURL(self, type, url):
|
|
"""
|
|
OpenURL(type, url) -> wx.FSFile
|
|
|
|
Opens given URL and returns wxFSFile object that can be used to read
|
|
data from it.
|
|
"""
|
|
|
|
def Parse(self, source):
|
|
"""
|
|
Parse(source) -> wx.Object
|
|
|
|
Proceeds parsing of the document.
|
|
"""
|
|
|
|
def PopTagHandler(self):
|
|
"""
|
|
PopTagHandler()
|
|
|
|
Restores parser's state before last call to PushTagHandler().
|
|
"""
|
|
|
|
def PushTagHandler(self, handler, tags):
|
|
"""
|
|
PushTagHandler(handler, tags)
|
|
|
|
Forces the handler to handle additional tags (not returned by
|
|
wxHtmlTagHandler::GetSupportedTags).
|
|
"""
|
|
|
|
def SetFS(self, fs):
|
|
"""
|
|
SetFS(fs)
|
|
|
|
Sets the virtual file system that will be used to request additional
|
|
files.
|
|
"""
|
|
|
|
def StopParsing(self):
|
|
"""
|
|
StopParsing()
|
|
|
|
Call this function to interrupt parsing from a tag handler.
|
|
"""
|
|
FS = property(None, None)
|
|
Product = property(None, None)
|
|
Source = property(None, None)
|
|
|
|
def AddTag(self, tag):
|
|
"""
|
|
AddTag(tag)
|
|
|
|
This may (and may not) be overwritten in derived class.
|
|
"""
|
|
# end of class HtmlParser
|
|
|
|
#-- end-htmlpars --#
|
|
#-- begin-htmlwin --#
|
|
HW_SCROLLBAR_NEVER = 0
|
|
HW_SCROLLBAR_AUTO = 0
|
|
HW_NO_SELECTION = 0
|
|
HW_DEFAULT_STYLE = 0
|
|
HTML_OPEN = 0
|
|
HTML_BLOCK = 0
|
|
HTML_REDIRECT = 0
|
|
wxEVT_HTML_CELL_CLICKED = 0
|
|
wxEVT_HTML_CELL_HOVER = 0
|
|
wxEVT_HTML_LINK_CLICKED = 0
|
|
|
|
class HtmlWindowInterface(object):
|
|
"""
|
|
HtmlWindowInterface()
|
|
|
|
Abstract interface to a HTML rendering window (such as wxHtmlWindow or
|
|
wxHtmlListBox) that is passed to wxHtmlWinParser.
|
|
"""
|
|
HTMLCursor_Default = 0
|
|
HTMLCursor_Link = 0
|
|
HTMLCursor_Text = 0
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlWindowInterface()
|
|
|
|
Abstract interface to a HTML rendering window (such as wxHtmlWindow or
|
|
wxHtmlListBox) that is passed to wxHtmlWinParser.
|
|
"""
|
|
|
|
def SetHTMLWindowTitle(self, title):
|
|
"""
|
|
SetHTMLWindowTitle(title)
|
|
|
|
Called by the parser to set window's title to given text.
|
|
"""
|
|
|
|
def OnHTMLLinkClicked(self, link):
|
|
"""
|
|
OnHTMLLinkClicked(link)
|
|
|
|
Called when a link is clicked.
|
|
"""
|
|
|
|
def OnHTMLOpeningURL(self, type, url, redirect):
|
|
"""
|
|
OnHTMLOpeningURL(type, url, redirect) -> HtmlOpeningStatus
|
|
|
|
Called when the parser needs to open another URL (e.g.
|
|
"""
|
|
|
|
def HTMLCoordsToWindow(self, cell, pos):
|
|
"""
|
|
HTMLCoordsToWindow(cell, pos) -> wx.Point
|
|
|
|
Converts coordinates pos relative to given cell to physical
|
|
coordinates in the window.
|
|
"""
|
|
|
|
def GetHTMLWindow(self):
|
|
"""
|
|
GetHTMLWindow() -> wx.Window
|
|
|
|
Returns the window used for rendering (may be NULL).
|
|
"""
|
|
|
|
def GetHTMLBackgroundColour(self):
|
|
"""
|
|
GetHTMLBackgroundColour() -> wx.Colour
|
|
|
|
Returns background colour to use by default.
|
|
"""
|
|
|
|
def SetHTMLBackgroundColour(self, clr):
|
|
"""
|
|
SetHTMLBackgroundColour(clr)
|
|
|
|
Sets window's background to colour clr.
|
|
"""
|
|
|
|
def SetHTMLBackgroundImage(self, bmpBg):
|
|
"""
|
|
SetHTMLBackgroundImage(bmpBg)
|
|
|
|
Sets window's background to given bitmap.
|
|
"""
|
|
|
|
def SetHTMLStatusText(self, text):
|
|
"""
|
|
SetHTMLStatusText(text)
|
|
|
|
Sets status bar text.
|
|
"""
|
|
|
|
def GetHTMLCursor(self, type):
|
|
"""
|
|
GetHTMLCursor(type) -> wx.Cursor
|
|
|
|
Returns mouse cursor of given type.
|
|
"""
|
|
HTMLBackgroundColour = property(None, None)
|
|
HTMLWindow = property(None, None)
|
|
# end of class HtmlWindowInterface
|
|
|
|
|
|
class HtmlWindow(wx.ScrolledWindow):
|
|
"""
|
|
HtmlWindow()
|
|
HtmlWindow(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=HW_DEFAULT_STYLE, name="htmlWindow")
|
|
|
|
wxHtmlWindow is probably the only class you will directly use unless
|
|
you want to do something special (like adding new tag handlers or MIME
|
|
filters).
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
HtmlWindow()
|
|
HtmlWindow(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=HW_DEFAULT_STYLE, name="htmlWindow")
|
|
|
|
wxHtmlWindow is probably the only class you will directly use unless
|
|
you want to do something special (like adding new tag handlers or MIME
|
|
filters).
|
|
"""
|
|
|
|
def AppendToPage(self, source):
|
|
"""
|
|
AppendToPage(source) -> bool
|
|
|
|
Appends HTML fragment to currently displayed text and refreshes the
|
|
window.
|
|
"""
|
|
|
|
def GetInternalRepresentation(self):
|
|
"""
|
|
GetInternalRepresentation() -> HtmlContainerCell
|
|
|
|
Returns pointer to the top-level container.
|
|
"""
|
|
|
|
def GetOpenedAnchor(self):
|
|
"""
|
|
GetOpenedAnchor() -> String
|
|
|
|
Returns anchor within currently opened page (see
|
|
wxHtmlWindow::GetOpenedPage).
|
|
"""
|
|
|
|
def GetOpenedPage(self):
|
|
"""
|
|
GetOpenedPage() -> String
|
|
|
|
Returns full location of the opened page.
|
|
"""
|
|
|
|
def GetOpenedPageTitle(self):
|
|
"""
|
|
GetOpenedPageTitle() -> String
|
|
|
|
Returns title of the opened page or wxEmptyString if the current page
|
|
does not contain <TITLE> tag.
|
|
"""
|
|
|
|
def GetRelatedFrame(self):
|
|
"""
|
|
GetRelatedFrame() -> wx.Frame
|
|
|
|
Returns the related frame.
|
|
"""
|
|
|
|
def HistoryBack(self):
|
|
"""
|
|
HistoryBack() -> bool
|
|
|
|
Moves back to the previous page.
|
|
"""
|
|
|
|
def HistoryCanBack(self):
|
|
"""
|
|
HistoryCanBack() -> bool
|
|
|
|
Returns true if it is possible to go back in the history i.e.
|
|
"""
|
|
|
|
def HistoryCanForward(self):
|
|
"""
|
|
HistoryCanForward() -> bool
|
|
|
|
Returns true if it is possible to go forward in the history i.e.
|
|
"""
|
|
|
|
def HistoryClear(self):
|
|
"""
|
|
HistoryClear()
|
|
|
|
Clears history.
|
|
"""
|
|
|
|
def HistoryForward(self):
|
|
"""
|
|
HistoryForward() -> bool
|
|
|
|
Moves to next page in history.
|
|
"""
|
|
|
|
def LoadFile(self, filename):
|
|
"""
|
|
LoadFile(filename) -> bool
|
|
|
|
Loads an HTML page from a file and displays it.
|
|
"""
|
|
|
|
def LoadPage(self, location):
|
|
"""
|
|
LoadPage(location) -> bool
|
|
|
|
Unlike SetPage() this function first loads the HTML page from location
|
|
and then displays it.
|
|
"""
|
|
|
|
def OnLinkClicked(self, link):
|
|
"""
|
|
OnLinkClicked(link)
|
|
|
|
Called when user clicks on hypertext link.
|
|
"""
|
|
|
|
def OnOpeningURL(self, type, url, redirect):
|
|
"""
|
|
OnOpeningURL(type, url, redirect) -> HtmlOpeningStatus
|
|
|
|
Called when an URL is being opened (either when the user clicks on a
|
|
link or an image is loaded).
|
|
"""
|
|
|
|
def OnSetTitle(self, title):
|
|
"""
|
|
OnSetTitle(title)
|
|
|
|
Called on parsing <TITLE> tag.
|
|
"""
|
|
|
|
def ReadCustomization(self, cfg, path=wx.EmptyString):
|
|
"""
|
|
ReadCustomization(cfg, path=wx.EmptyString)
|
|
|
|
This reads custom settings from wxConfig.
|
|
"""
|
|
|
|
def SelectAll(self):
|
|
"""
|
|
SelectAll()
|
|
|
|
Selects all text in the window.
|
|
"""
|
|
|
|
def SelectLine(self, pos):
|
|
"""
|
|
SelectLine(pos)
|
|
|
|
Selects the line of text that pos points at.
|
|
"""
|
|
|
|
def SelectWord(self, pos):
|
|
"""
|
|
SelectWord(pos)
|
|
|
|
Selects the word at position pos.
|
|
"""
|
|
|
|
def SelectionToText(self):
|
|
"""
|
|
SelectionToText() -> String
|
|
|
|
Returns the current selection as plain text.
|
|
"""
|
|
|
|
def SetBorders(self, b):
|
|
"""
|
|
SetBorders(b)
|
|
|
|
This function sets the space between border of window and HTML
|
|
contents.
|
|
"""
|
|
|
|
def SetFonts(self, normal_face, fixed_face, sizes):
|
|
"""
|
|
SetFonts(normal_face, fixed_face, sizes)
|
|
|
|
This function sets font sizes and faces.
|
|
"""
|
|
|
|
def SetStandardFonts(self, size=-1, normal_face=wx.EmptyString, fixed_face=wx.EmptyString):
|
|
"""
|
|
SetStandardFonts(size=-1, normal_face=wx.EmptyString, fixed_face=wx.EmptyString)
|
|
|
|
Sets default font sizes and/or default font size.
|
|
"""
|
|
|
|
def SetPage(self, source):
|
|
"""
|
|
SetPage(source) -> bool
|
|
|
|
Sets the source of a page and displays it, for example:
|
|
"""
|
|
|
|
def SetRelatedFrame(self, frame, format):
|
|
"""
|
|
SetRelatedFrame(frame, format)
|
|
|
|
Sets the frame in which page title will be displayed.
|
|
"""
|
|
|
|
def SetRelatedStatusBar(self, *args, **kw):
|
|
"""
|
|
SetRelatedStatusBar(index)
|
|
SetRelatedStatusBar(statusbar, index=0)
|
|
|
|
After calling SetRelatedFrame(), this sets statusbar slot where
|
|
messages will be displayed.
|
|
"""
|
|
|
|
def ToText(self):
|
|
"""
|
|
ToText() -> String
|
|
|
|
Returns content of currently displayed page as plain text.
|
|
"""
|
|
|
|
def WriteCustomization(self, cfg, path=wx.EmptyString):
|
|
"""
|
|
WriteCustomization(cfg, path=wx.EmptyString)
|
|
|
|
Saves custom settings into wxConfig.
|
|
"""
|
|
|
|
@staticmethod
|
|
def AddFilter(filter):
|
|
"""
|
|
AddFilter(filter)
|
|
|
|
Adds input filter to the static list of available filters.
|
|
"""
|
|
InternalRepresentation = property(None, None)
|
|
OpenedAnchor = property(None, None)
|
|
OpenedPage = property(None, None)
|
|
OpenedPageTitle = property(None, None)
|
|
RelatedFrame = property(None, None)
|
|
|
|
def OnCellClicked(self, cell, x, y, event):
|
|
"""
|
|
OnCellClicked(cell, x, y, event) -> bool
|
|
|
|
This method is called when a mouse button is clicked inside
|
|
wxHtmlWindow.
|
|
"""
|
|
|
|
def OnCellMouseHover(self, cell, x, y):
|
|
"""
|
|
OnCellMouseHover(cell, x, y)
|
|
|
|
This method is called when a mouse moves over an HTML cell.
|
|
"""
|
|
# end of class HtmlWindow
|
|
|
|
|
|
class HtmlLinkEvent(wx.CommandEvent):
|
|
"""
|
|
HtmlLinkEvent(id, linkinfo)
|
|
|
|
This event class is used for the events generated by wxHtmlWindow.
|
|
"""
|
|
|
|
def __init__(self, id, linkinfo):
|
|
"""
|
|
HtmlLinkEvent(id, linkinfo)
|
|
|
|
This event class is used for the events generated by wxHtmlWindow.
|
|
"""
|
|
|
|
def GetLinkInfo(self):
|
|
"""
|
|
GetLinkInfo() -> HtmlLinkInfo
|
|
|
|
Returns the wxHtmlLinkInfo which contains info about the cell clicked
|
|
and the hyperlink it contains.
|
|
"""
|
|
LinkInfo = property(None, None)
|
|
# end of class HtmlLinkEvent
|
|
|
|
|
|
class HtmlCellEvent(wx.CommandEvent):
|
|
"""
|
|
HtmlCellEvent(commandType, id, cell, point, ev)
|
|
|
|
This event class is used for the events generated by wxHtmlWindow.
|
|
"""
|
|
|
|
def __init__(self, commandType, id, cell, point, ev):
|
|
"""
|
|
HtmlCellEvent(commandType, id, cell, point, ev)
|
|
|
|
This event class is used for the events generated by wxHtmlWindow.
|
|
"""
|
|
|
|
def GetCell(self):
|
|
"""
|
|
GetCell() -> HtmlCell
|
|
|
|
Returns the wxHtmlCellEvent associated with the event.
|
|
"""
|
|
|
|
def GetLinkClicked(self):
|
|
"""
|
|
GetLinkClicked() -> bool
|
|
|
|
Returns true if SetLinkClicked(true) has previously been called; false
|
|
otherwise.
|
|
"""
|
|
|
|
def GetPoint(self):
|
|
"""
|
|
GetPoint() -> wx.Point
|
|
|
|
Returns the wxPoint associated with the event.
|
|
"""
|
|
|
|
def SetLinkClicked(self, linkclicked):
|
|
"""
|
|
SetLinkClicked(linkclicked)
|
|
|
|
Call this function with linkclicked set to true if the cell which has
|
|
been clicked contained a link or false otherwise (which is the
|
|
default).
|
|
"""
|
|
Cell = property(None, None)
|
|
LinkClicked = property(None, None)
|
|
Point = property(None, None)
|
|
# end of class HtmlCellEvent
|
|
|
|
|
|
EVT_HTML_CELL_CLICKED = wx.PyEventBinder( wxEVT_HTML_CELL_CLICKED, 1 )
|
|
EVT_HTML_CELL_HOVER = wx.PyEventBinder( wxEVT_HTML_CELL_HOVER, 1 )
|
|
EVT_HTML_LINK_CLICKED = wx.PyEventBinder( wxEVT_HTML_LINK_CLICKED, 1 )
|
|
|
|
# deprecated wxEVT aliases
|
|
wxEVT_COMMAND_HTML_CELL_CLICKED = wxEVT_HTML_CELL_CLICKED
|
|
wxEVT_COMMAND_HTML_CELL_HOVER = wxEVT_HTML_CELL_HOVER
|
|
wxEVT_COMMAND_HTML_LINK_CLICKED = wxEVT_HTML_LINK_CLICKED
|
|
#-- end-htmlwin --#
|
|
#-- begin-htmlprint --#
|
|
PAGE_ODD = 0
|
|
PAGE_EVEN = 0
|
|
PAGE_ALL = 0
|
|
|
|
class HtmlDCRenderer(wx.Object):
|
|
"""
|
|
HtmlDCRenderer()
|
|
|
|
This class can render HTML document into a specified area of a DC.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlDCRenderer()
|
|
|
|
This class can render HTML document into a specified area of a DC.
|
|
"""
|
|
|
|
def GetTotalWidth(self):
|
|
"""
|
|
GetTotalWidth() -> int
|
|
|
|
Returns the width of the HTML text in pixels.
|
|
"""
|
|
|
|
def GetTotalHeight(self):
|
|
"""
|
|
GetTotalHeight() -> int
|
|
|
|
Returns the height of the HTML text in pixels.
|
|
"""
|
|
|
|
def Render(self, x, y, known_pagebreaks, from_=0, dont_render=False, to_=INT_MAX):
|
|
"""
|
|
Render(x, y, known_pagebreaks, from_=0, dont_render=False, to_=INT_MAX) -> int
|
|
|
|
Renders HTML text to the DC.
|
|
"""
|
|
|
|
def SetDC(self, dc, pixel_scale=1.0):
|
|
"""
|
|
SetDC(dc, pixel_scale=1.0)
|
|
|
|
Assign DC instance to the renderer.
|
|
"""
|
|
|
|
def SetFonts(self, normal_face, fixed_face, sizes):
|
|
"""
|
|
SetFonts(normal_face, fixed_face, sizes)
|
|
|
|
This function sets font sizes and faces.
|
|
"""
|
|
|
|
def SetStandardFonts(self, size=-1, normal_face=wx.EmptyString, fixed_face=wx.EmptyString):
|
|
"""
|
|
SetStandardFonts(size=-1, normal_face=wx.EmptyString, fixed_face=wx.EmptyString)
|
|
|
|
Sets font sizes to be relative to the given size or the system default
|
|
size; use either specified or default font.
|
|
"""
|
|
|
|
def SetHtmlText(self, html, basepath=wx.EmptyString, isdir=True):
|
|
"""
|
|
SetHtmlText(html, basepath=wx.EmptyString, isdir=True)
|
|
|
|
Assign text to the renderer.
|
|
"""
|
|
|
|
def SetSize(self, width, height):
|
|
"""
|
|
SetSize(width, height)
|
|
|
|
Set size of output rectangle, in pixels.
|
|
"""
|
|
TotalHeight = property(None, None)
|
|
TotalWidth = property(None, None)
|
|
# end of class HtmlDCRenderer
|
|
|
|
|
|
class HtmlEasyPrinting(wx.Object):
|
|
"""
|
|
HtmlEasyPrinting(name="Printing", parentWindow=None)
|
|
|
|
This class provides very simple interface to printing architecture.
|
|
"""
|
|
|
|
def __init__(self, name="Printing", parentWindow=None):
|
|
"""
|
|
HtmlEasyPrinting(name="Printing", parentWindow=None)
|
|
|
|
This class provides very simple interface to printing architecture.
|
|
"""
|
|
|
|
def GetName(self):
|
|
"""
|
|
GetName() -> String
|
|
|
|
Returns the current name being used for preview frames and setup
|
|
dialogs.
|
|
"""
|
|
|
|
def GetPageSetupData(self):
|
|
"""
|
|
GetPageSetupData() -> wx.PageSetupDialogData
|
|
|
|
Returns a pointer to wxPageSetupDialogData instance used by this
|
|
class.
|
|
"""
|
|
|
|
def GetParentWindow(self):
|
|
"""
|
|
GetParentWindow() -> wx.Window
|
|
|
|
Gets the parent window for dialogs.
|
|
"""
|
|
|
|
def GetPrintData(self):
|
|
"""
|
|
GetPrintData() -> wx.PrintData
|
|
|
|
Returns pointer to wxPrintData instance used by this class.
|
|
"""
|
|
|
|
def PageSetup(self):
|
|
"""
|
|
PageSetup()
|
|
|
|
Display page setup dialog and allows the user to modify settings.
|
|
"""
|
|
|
|
def PreviewFile(self, htmlfile):
|
|
"""
|
|
PreviewFile(htmlfile) -> bool
|
|
|
|
Preview HTML file.
|
|
"""
|
|
|
|
def PreviewText(self, htmltext, basepath=wx.EmptyString):
|
|
"""
|
|
PreviewText(htmltext, basepath=wx.EmptyString) -> bool
|
|
|
|
Preview HTML text (not file!).
|
|
"""
|
|
|
|
def PrintFile(self, htmlfile):
|
|
"""
|
|
PrintFile(htmlfile) -> bool
|
|
|
|
Print HTML file.
|
|
"""
|
|
|
|
def PrintText(self, htmltext, basepath=wx.EmptyString):
|
|
"""
|
|
PrintText(htmltext, basepath=wx.EmptyString) -> bool
|
|
|
|
Print HTML text (not file!).
|
|
"""
|
|
|
|
def SetFonts(self, normal_face, fixed_face, sizes=None):
|
|
"""
|
|
SetFonts(normal_face, fixed_face, sizes=None)
|
|
|
|
Sets fonts.
|
|
"""
|
|
|
|
def SetName(self, name):
|
|
"""
|
|
SetName(name)
|
|
|
|
Sets the name used for preview frames and setup dialogs.
|
|
"""
|
|
|
|
def SetStandardFonts(self, size=-1, normal_face=wx.EmptyString, fixed_face=wx.EmptyString):
|
|
"""
|
|
SetStandardFonts(size=-1, normal_face=wx.EmptyString, fixed_face=wx.EmptyString)
|
|
|
|
Sets default font sizes and/or default font size.
|
|
"""
|
|
|
|
def SetFooter(self, footer, pg=PAGE_ALL):
|
|
"""
|
|
SetFooter(footer, pg=PAGE_ALL)
|
|
|
|
Set page footer.
|
|
"""
|
|
|
|
def SetHeader(self, header, pg=PAGE_ALL):
|
|
"""
|
|
SetHeader(header, pg=PAGE_ALL)
|
|
|
|
Set page header.
|
|
"""
|
|
|
|
def SetParentWindow(self, window):
|
|
"""
|
|
SetParentWindow(window)
|
|
|
|
Sets the parent window for dialogs.
|
|
"""
|
|
Name = property(None, None)
|
|
PageSetupData = property(None, None)
|
|
ParentWindow = property(None, None)
|
|
PrintData = property(None, None)
|
|
# end of class HtmlEasyPrinting
|
|
|
|
|
|
class HtmlPrintout(wx.Printout):
|
|
"""
|
|
HtmlPrintout(title="Printout")
|
|
|
|
This class serves as printout class for HTML documents.
|
|
"""
|
|
|
|
def __init__(self, title="Printout"):
|
|
"""
|
|
HtmlPrintout(title="Printout")
|
|
|
|
This class serves as printout class for HTML documents.
|
|
"""
|
|
|
|
def SetFonts(self, normal_face, fixed_face, sizes=None):
|
|
"""
|
|
SetFonts(normal_face, fixed_face, sizes=None)
|
|
|
|
This function sets font sizes and faces.
|
|
"""
|
|
|
|
def SetFooter(self, footer, pg=PAGE_ALL):
|
|
"""
|
|
SetFooter(footer, pg=PAGE_ALL)
|
|
|
|
Set page footer.
|
|
"""
|
|
|
|
def SetHeader(self, header, pg=PAGE_ALL):
|
|
"""
|
|
SetHeader(header, pg=PAGE_ALL)
|
|
|
|
Set page header.
|
|
"""
|
|
|
|
def SetHtmlFile(self, htmlfile):
|
|
"""
|
|
SetHtmlFile(htmlfile)
|
|
|
|
Prepare the class for printing this HTML file.
|
|
"""
|
|
|
|
def SetHtmlText(self, html, basepath=wx.EmptyString, isdir=True):
|
|
"""
|
|
SetHtmlText(html, basepath=wx.EmptyString, isdir=True)
|
|
|
|
Prepare the class for printing this HTML text.
|
|
"""
|
|
|
|
def SetMargins(self, top=25.2, bottom=25.2, left=25.2, right=25.2, spaces=5):
|
|
"""
|
|
SetMargins(top=25.2, bottom=25.2, left=25.2, right=25.2, spaces=5)
|
|
|
|
Sets margins in millimeters.
|
|
"""
|
|
|
|
@staticmethod
|
|
def AddFilter(filter):
|
|
"""
|
|
AddFilter(filter)
|
|
|
|
Adds a filter to the static list of filters for wxHtmlPrintout.
|
|
"""
|
|
# end of class HtmlPrintout
|
|
|
|
#-- end-htmlprint --#
|
|
#-- begin-htmlwinpars --#
|
|
|
|
class HtmlWinTagHandler(HtmlTagHandler):
|
|
"""
|
|
HtmlWinTagHandler()
|
|
|
|
This is basically wxHtmlTagHandler except that it is extended with
|
|
protected member m_WParser pointing to the wxHtmlWinParser object
|
|
(value of this member is identical to wxHtmlParser's m_Parser).
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlWinTagHandler()
|
|
|
|
This is basically wxHtmlTagHandler except that it is extended with
|
|
protected member m_WParser pointing to the wxHtmlWinParser object
|
|
(value of this member is identical to wxHtmlParser's m_Parser).
|
|
"""
|
|
|
|
def SetParser(self, parser):
|
|
"""
|
|
SetParser(parser)
|
|
|
|
Assigns parser to this handler.
|
|
"""
|
|
|
|
def GetParser(self):
|
|
"""
|
|
GetParser() -> HtmlWinParser
|
|
"""
|
|
Parser = property(None, None)
|
|
# end of class HtmlWinTagHandler
|
|
|
|
|
|
class HtmlWinParser(HtmlParser):
|
|
"""
|
|
HtmlWinParser(wndIface=None)
|
|
|
|
This class is derived from wxHtmlParser and its main goal is to parse
|
|
HTML input so that it can be displayed in wxHtmlWindow.
|
|
"""
|
|
|
|
def __init__(self, wndIface=None):
|
|
"""
|
|
HtmlWinParser(wndIface=None)
|
|
|
|
This class is derived from wxHtmlParser and its main goal is to parse
|
|
HTML input so that it can be displayed in wxHtmlWindow.
|
|
"""
|
|
|
|
def CloseContainer(self):
|
|
"""
|
|
CloseContainer() -> HtmlContainerCell
|
|
|
|
Closes the container, sets actual container to the parent one and
|
|
returns pointer to it (see Cells and Containers).
|
|
"""
|
|
|
|
def CreateCurrentFont(self):
|
|
"""
|
|
CreateCurrentFont() -> wx.Font
|
|
|
|
Creates font based on current setting (see SetFontSize(),
|
|
SetFontBold(), SetFontItalic(), SetFontFixed(),
|
|
wxHtmlWinParser::SetFontUnderlined) and returns pointer to it.
|
|
"""
|
|
|
|
def GetActualColor(self):
|
|
"""
|
|
GetActualColor() -> wx.Colour
|
|
|
|
Returns actual text colour.
|
|
"""
|
|
|
|
def GetAlign(self):
|
|
"""
|
|
GetAlign() -> int
|
|
|
|
Returns default horizontal alignment.
|
|
"""
|
|
|
|
def GetCharHeight(self):
|
|
"""
|
|
GetCharHeight() -> int
|
|
|
|
Returns (average) char height in standard font.
|
|
"""
|
|
|
|
def GetCharWidth(self):
|
|
"""
|
|
GetCharWidth() -> int
|
|
|
|
Returns average char width in standard font.
|
|
"""
|
|
|
|
def GetContainer(self):
|
|
"""
|
|
GetContainer() -> HtmlContainerCell
|
|
|
|
Returns pointer to the currently opened container (see Cells and
|
|
Containers).
|
|
"""
|
|
|
|
def GetDC(self):
|
|
"""
|
|
GetDC() -> wx.DC
|
|
|
|
Returns pointer to the DC used during parsing.
|
|
"""
|
|
|
|
def GetFontBold(self):
|
|
"""
|
|
GetFontBold() -> int
|
|
|
|
Returns true if actual font is bold, false otherwise.
|
|
"""
|
|
|
|
def GetFontFace(self):
|
|
"""
|
|
GetFontFace() -> String
|
|
|
|
Returns actual font face name.
|
|
"""
|
|
|
|
def GetFontFixed(self):
|
|
"""
|
|
GetFontFixed() -> int
|
|
|
|
Returns true if actual font is fixed face, false otherwise.
|
|
"""
|
|
|
|
def GetFontItalic(self):
|
|
"""
|
|
GetFontItalic() -> int
|
|
|
|
Returns true if actual font is italic, false otherwise.
|
|
"""
|
|
|
|
def GetFontSize(self):
|
|
"""
|
|
GetFontSize() -> int
|
|
|
|
Returns actual font size (HTML size varies from -2 to +4)
|
|
"""
|
|
|
|
def GetFontUnderlined(self):
|
|
"""
|
|
GetFontUnderlined() -> int
|
|
|
|
Returns true if actual font is underlined, false otherwise.
|
|
"""
|
|
|
|
def GetLink(self):
|
|
"""
|
|
GetLink() -> HtmlLinkInfo
|
|
|
|
Returns actual hypertext link.
|
|
"""
|
|
|
|
def GetLinkColor(self):
|
|
"""
|
|
GetLinkColor() -> wx.Colour
|
|
|
|
Returns the colour of hypertext link text.
|
|
"""
|
|
|
|
def GetWindowInterface(self):
|
|
"""
|
|
GetWindowInterface() -> HtmlWindowInterface
|
|
|
|
Returns associated window (wxHtmlWindow).
|
|
"""
|
|
|
|
def OpenContainer(self):
|
|
"""
|
|
OpenContainer() -> HtmlContainerCell
|
|
|
|
Opens new container and returns pointer to it (see Cells and
|
|
Containers).
|
|
"""
|
|
|
|
def SetActualColor(self, clr):
|
|
"""
|
|
SetActualColor(clr)
|
|
|
|
Sets actual text colour.
|
|
"""
|
|
|
|
def SetAlign(self, a):
|
|
"""
|
|
SetAlign(a)
|
|
|
|
Sets default horizontal alignment (see
|
|
wxHtmlContainerCell::SetAlignHor).
|
|
"""
|
|
|
|
def SetContainer(self, c):
|
|
"""
|
|
SetContainer(c) -> HtmlContainerCell
|
|
|
|
Allows you to directly set opened container.
|
|
"""
|
|
|
|
def SetDC(self, dc, pixel_scale=1.0e+0):
|
|
"""
|
|
SetDC(dc, pixel_scale=1.0e+0)
|
|
|
|
Sets the DC.
|
|
"""
|
|
|
|
def SetFontBold(self, x):
|
|
"""
|
|
SetFontBold(x)
|
|
|
|
Sets bold flag of actualfont.
|
|
"""
|
|
|
|
def SetFontFace(self, face):
|
|
"""
|
|
SetFontFace(face)
|
|
|
|
Sets current font face to face.
|
|
"""
|
|
|
|
def SetFontFixed(self, x):
|
|
"""
|
|
SetFontFixed(x)
|
|
|
|
Sets fixed face flag of actualfont.
|
|
"""
|
|
|
|
def SetFontItalic(self, x):
|
|
"""
|
|
SetFontItalic(x)
|
|
|
|
Sets italic flag of actualfont.
|
|
"""
|
|
|
|
def SetFontSize(self, s):
|
|
"""
|
|
SetFontSize(s)
|
|
|
|
Sets actual font size (HTML size varies from 1 to 7).
|
|
"""
|
|
|
|
def SetFontUnderlined(self, x):
|
|
"""
|
|
SetFontUnderlined(x)
|
|
|
|
Sets underlined flag of actualfont.
|
|
"""
|
|
|
|
def SetFonts(self, normal_face, fixed_face, sizes):
|
|
"""
|
|
SetFonts(normal_face, fixed_face, sizes)
|
|
|
|
Sets fonts.
|
|
"""
|
|
|
|
def SetLink(self, link):
|
|
"""
|
|
SetLink(link)
|
|
|
|
Sets actual hypertext link.
|
|
"""
|
|
|
|
def SetLinkColor(self, clr):
|
|
"""
|
|
SetLinkColor(clr)
|
|
|
|
Sets colour of hypertext link.
|
|
"""
|
|
ActualColor = property(None, None)
|
|
Align = property(None, None)
|
|
CharHeight = property(None, None)
|
|
CharWidth = property(None, None)
|
|
Container = property(None, None)
|
|
DC = property(None, None)
|
|
FontBold = property(None, None)
|
|
FontFace = property(None, None)
|
|
FontFixed = property(None, None)
|
|
FontItalic = property(None, None)
|
|
FontSize = property(None, None)
|
|
FontUnderlined = property(None, None)
|
|
Link = property(None, None)
|
|
LinkColor = property(None, None)
|
|
WindowInterface = property(None, None)
|
|
# end of class HtmlWinParser
|
|
|
|
|
|
def HtmlWinParser_AddTagHandler(self, tagHandlerClass):
|
|
"""
|
|
HtmlWinParser_AddTagHandler(tagHandlerClass)
|
|
"""
|
|
#-- end-htmlwinpars --#
|
|
#-- begin-helpdata --#
|
|
|
|
class HtmlBookRecord(object):
|
|
"""
|
|
HtmlBookRecord(bookfile, basepath, title, start)
|
|
|
|
Helper class for wxHtmlHelpData.
|
|
"""
|
|
|
|
def __init__(self, bookfile, basepath, title, start):
|
|
"""
|
|
HtmlBookRecord(bookfile, basepath, title, start)
|
|
|
|
Helper class for wxHtmlHelpData.
|
|
"""
|
|
|
|
def GetBookFile(self):
|
|
"""
|
|
GetBookFile() -> String
|
|
"""
|
|
|
|
def GetTitle(self):
|
|
"""
|
|
GetTitle() -> String
|
|
"""
|
|
|
|
def GetStart(self):
|
|
"""
|
|
GetStart() -> String
|
|
"""
|
|
|
|
def GetBasePath(self):
|
|
"""
|
|
GetBasePath() -> String
|
|
"""
|
|
|
|
def SetContentsRange(self, start, end):
|
|
"""
|
|
SetContentsRange(start, end)
|
|
"""
|
|
|
|
def GetContentsStart(self):
|
|
"""
|
|
GetContentsStart() -> int
|
|
"""
|
|
|
|
def GetContentsEnd(self):
|
|
"""
|
|
GetContentsEnd() -> int
|
|
"""
|
|
|
|
def SetTitle(self, title):
|
|
"""
|
|
SetTitle(title)
|
|
"""
|
|
|
|
def SetBasePath(self, path):
|
|
"""
|
|
SetBasePath(path)
|
|
"""
|
|
|
|
def SetStart(self, start):
|
|
"""
|
|
SetStart(start)
|
|
"""
|
|
|
|
def GetFullPath(self, page):
|
|
"""
|
|
GetFullPath(page) -> String
|
|
"""
|
|
BasePath = property(None, None)
|
|
BookFile = property(None, None)
|
|
ContentsEnd = property(None, None)
|
|
ContentsStart = property(None, None)
|
|
Start = property(None, None)
|
|
Title = property(None, None)
|
|
# end of class HtmlBookRecord
|
|
|
|
|
|
class HtmlHelpDataItem(object):
|
|
"""
|
|
HtmlHelpDataItem()
|
|
|
|
Helper class for wxHtmlHelpData.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlHelpDataItem()
|
|
|
|
Helper class for wxHtmlHelpData.
|
|
"""
|
|
level = property(None, None)
|
|
parent = property(None, None)
|
|
id = property(None, None)
|
|
name = property(None, None)
|
|
page = property(None, None)
|
|
book = property(None, None)
|
|
|
|
def GetFullPath(self):
|
|
"""
|
|
GetFullPath() -> String
|
|
"""
|
|
|
|
def GetIndentedName(self):
|
|
"""
|
|
GetIndentedName() -> String
|
|
"""
|
|
FullPath = property(None, None)
|
|
IndentedName = property(None, None)
|
|
# end of class HtmlHelpDataItem
|
|
|
|
|
|
class HtmlHelpData(wx.Object):
|
|
"""
|
|
HtmlHelpData()
|
|
|
|
This class is used by wxHtmlHelpController and wxHtmlHelpFrame to
|
|
access HTML help items.
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""
|
|
HtmlHelpData()
|
|
|
|
This class is used by wxHtmlHelpController and wxHtmlHelpFrame to
|
|
access HTML help items.
|
|
"""
|
|
|
|
def AddBook(self, book_url):
|
|
"""
|
|
AddBook(book_url) -> bool
|
|
|
|
Adds new book.
|
|
"""
|
|
|
|
def FindPageById(self, id):
|
|
"""
|
|
FindPageById(id) -> String
|
|
|
|
Returns page's URL based on integer ID stored in project.
|
|
"""
|
|
|
|
def FindPageByName(self, page):
|
|
"""
|
|
FindPageByName(page) -> String
|
|
|
|
Returns page's URL based on its (file)name.
|
|
"""
|
|
|
|
def GetBookRecArray(self):
|
|
"""
|
|
GetBookRecArray() -> HtmlBookRecArray
|
|
|
|
Returns array with help books info.
|
|
"""
|
|
|
|
def GetContentsArray(self):
|
|
"""
|
|
GetContentsArray() -> HtmlHelpDataItems
|
|
|
|
Returns reference to array with contents entries.
|
|
"""
|
|
|
|
def GetIndexArray(self):
|
|
"""
|
|
GetIndexArray() -> HtmlHelpDataItems
|
|
|
|
Returns reference to array with index entries.
|
|
"""
|
|
|
|
def SetTempDir(self, path):
|
|
"""
|
|
SetTempDir(path)
|
|
|
|
Sets the temporary directory where binary cached versions of MS HTML
|
|
Workshop files will be stored.
|
|
"""
|
|
BookRecArray = property(None, None)
|
|
ContentsArray = property(None, None)
|
|
IndexArray = property(None, None)
|
|
# end of class HtmlHelpData
|
|
|
|
#-- end-helpdata --#
|
|
#-- begin-helpfrm --#
|
|
HF_TOOLBAR = 0
|
|
HF_CONTENTS = 0
|
|
HF_INDEX = 0
|
|
HF_SEARCH = 0
|
|
HF_BOOKMARKS = 0
|
|
HF_OPEN_FILES = 0
|
|
HF_PRINT = 0
|
|
HF_FLAT_TOOLBAR = 0
|
|
HF_MERGE_BOOKS = 0
|
|
HF_ICONS_BOOK = 0
|
|
HF_ICONS_BOOK_CHAPTER = 0
|
|
HF_ICONS_FOLDER = 0
|
|
HF_DEFAULT_STYLE = 0
|
|
|
|
class HtmlHelpFrame(wx.Frame):
|
|
"""
|
|
HtmlHelpFrame(data=None)
|
|
HtmlHelpFrame(parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE, data=None, config=None, rootpath=wx.EmptyString)
|
|
|
|
This class is used by wxHtmlHelpController to display help.
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
HtmlHelpFrame(data=None)
|
|
HtmlHelpFrame(parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE, data=None, config=None, rootpath=wx.EmptyString)
|
|
|
|
This class is used by wxHtmlHelpController to display help.
|
|
"""
|
|
|
|
def AddToolbarButtons(self, toolBar, style):
|
|
"""
|
|
AddToolbarButtons(toolBar, style)
|
|
|
|
You may override this virtual method to add more buttons to the help
|
|
window's toolbar.
|
|
"""
|
|
|
|
def Create(self, parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE, config=None, rootpath=wx.EmptyString):
|
|
"""
|
|
Create(parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE, config=None, rootpath=wx.EmptyString) -> bool
|
|
|
|
Creates the frame.
|
|
"""
|
|
|
|
def GetController(self):
|
|
"""
|
|
GetController() -> HtmlHelpController
|
|
|
|
Returns the help controller associated with the frame.
|
|
"""
|
|
|
|
def SetController(self, controller):
|
|
"""
|
|
SetController(controller)
|
|
|
|
Sets the help controller associated with the frame.
|
|
"""
|
|
|
|
def SetTitleFormat(self, format):
|
|
"""
|
|
SetTitleFormat(format)
|
|
|
|
Sets the frame's title format.
|
|
"""
|
|
Controller = property(None, None)
|
|
# end of class HtmlHelpFrame
|
|
|
|
#-- end-helpfrm --#
|
|
#-- begin-helpdlg --#
|
|
|
|
class HtmlHelpDialog(wx.Dialog):
|
|
"""
|
|
HtmlHelpDialog(data=None)
|
|
HtmlHelpDialog(parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE, data=None)
|
|
|
|
This class is used by wxHtmlHelpController to display help.
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
HtmlHelpDialog(data=None)
|
|
HtmlHelpDialog(parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE, data=None)
|
|
|
|
This class is used by wxHtmlHelpController to display help.
|
|
"""
|
|
|
|
def AddToolbarButtons(self, toolBar, style):
|
|
"""
|
|
AddToolbarButtons(toolBar, style)
|
|
|
|
You may override this virtual method to add more buttons to the help
|
|
window's toolbar.
|
|
"""
|
|
|
|
def Create(self, parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE):
|
|
"""
|
|
Create(parent, id=wx.ID_ANY, title=wx.EmptyString, style=HF_DEFAULT_STYLE) -> bool
|
|
|
|
Creates the dialog.
|
|
"""
|
|
|
|
def GetController(self):
|
|
"""
|
|
GetController() -> HtmlHelpController
|
|
|
|
Returns the help controller associated with the dialog.
|
|
"""
|
|
|
|
def SetController(self, controller):
|
|
"""
|
|
SetController(controller)
|
|
|
|
Sets the help controller associated with the dialog.
|
|
"""
|
|
|
|
def SetTitleFormat(self, format):
|
|
"""
|
|
SetTitleFormat(format)
|
|
|
|
Sets the dialog's title format.
|
|
"""
|
|
Controller = property(None, None)
|
|
# end of class HtmlHelpDialog
|
|
|
|
#-- end-helpdlg --#
|
|
#-- begin-helpwnd --#
|
|
ID_HTML_PANEL = 0
|
|
ID_HTML_BACK = 0
|
|
ID_HTML_FORWARD = 0
|
|
ID_HTML_UPNODE = 0
|
|
ID_HTML_UP = 0
|
|
ID_HTML_DOWN = 0
|
|
ID_HTML_PRINT = 0
|
|
ID_HTML_OPENFILE = 0
|
|
ID_HTML_OPTIONS = 0
|
|
ID_HTML_BOOKMARKSLIST = 0
|
|
ID_HTML_BOOKMARKSADD = 0
|
|
ID_HTML_BOOKMARKSREMOVE = 0
|
|
ID_HTML_TREECTRL = 0
|
|
ID_HTML_INDEXPAGE = 0
|
|
ID_HTML_INDEXLIST = 0
|
|
ID_HTML_INDEXTEXT = 0
|
|
ID_HTML_INDEXBUTTON = 0
|
|
ID_HTML_INDEXBUTTONALL = 0
|
|
ID_HTML_NOTEBOOK = 0
|
|
ID_HTML_SEARCHPAGE = 0
|
|
ID_HTML_SEARCHTEXT = 0
|
|
ID_HTML_SEARCHLIST = 0
|
|
ID_HTML_SEARCHBUTTON = 0
|
|
ID_HTML_SEARCHCHOICE = 0
|
|
ID_HTML_COUNTINFO = 0
|
|
|
|
class HtmlHelpWindow(wx.Window):
|
|
"""
|
|
HtmlHelpWindow(data=None)
|
|
HtmlHelpWindow(parent, WindowID, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.TAB_TRAVERSAL|wx.BORDER_NONE, helpStyle=HF_DEFAULT_STYLE, data=None)
|
|
|
|
This class is used by wxHtmlHelpController to display help within a
|
|
frame or dialog, but you can use it yourself to create an embedded
|
|
HTML help window.
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
HtmlHelpWindow(data=None)
|
|
HtmlHelpWindow(parent, WindowID, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.TAB_TRAVERSAL|wx.BORDER_NONE, helpStyle=HF_DEFAULT_STYLE, data=None)
|
|
|
|
This class is used by wxHtmlHelpController to display help within a
|
|
frame or dialog, but you can use it yourself to create an embedded
|
|
HTML help window.
|
|
"""
|
|
|
|
def Create(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.TAB_TRAVERSAL|wx.BORDER_NONE, helpStyle=HF_DEFAULT_STYLE):
|
|
"""
|
|
Create(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.TAB_TRAVERSAL|wx.BORDER_NONE, helpStyle=HF_DEFAULT_STYLE) -> bool
|
|
|
|
Creates the help window.
|
|
"""
|
|
|
|
def Display(self, *args, **kw):
|
|
"""
|
|
Display(x) -> bool
|
|
Display(id) -> bool
|
|
|
|
Displays page x.
|
|
"""
|
|
|
|
def DisplayContents(self):
|
|
"""
|
|
DisplayContents() -> bool
|
|
|
|
Displays contents panel.
|
|
"""
|
|
|
|
def DisplayIndex(self):
|
|
"""
|
|
DisplayIndex() -> bool
|
|
|
|
Displays index panel.
|
|
"""
|
|
|
|
def GetData(self):
|
|
"""
|
|
GetData() -> HtmlHelpData
|
|
|
|
Returns the wxHtmlHelpData object, which is usually a pointer to the
|
|
controller's data.
|
|
"""
|
|
|
|
def KeywordSearch(self, keyword, mode=wx.HELP_SEARCH_ALL):
|
|
"""
|
|
KeywordSearch(keyword, mode=wx.HELP_SEARCH_ALL) -> bool
|
|
|
|
Search for given keyword.
|
|
"""
|
|
|
|
def ReadCustomization(self, cfg, path=wx.EmptyString):
|
|
"""
|
|
ReadCustomization(cfg, path=wx.EmptyString)
|
|
|
|
Reads the user's settings for this window.
|
|
"""
|
|
|
|
def UseConfig(self, config, rootpath=wx.EmptyString):
|
|
"""
|
|
UseConfig(config, rootpath=wx.EmptyString)
|
|
|
|
Associates a wxConfig object with the help window.
|
|
"""
|
|
|
|
def WriteCustomization(self, cfg, path=wx.EmptyString):
|
|
"""
|
|
WriteCustomization(cfg, path=wx.EmptyString)
|
|
|
|
Saves the user's settings for this window.
|
|
"""
|
|
|
|
def RefreshLists(self):
|
|
"""
|
|
RefreshLists()
|
|
|
|
Refresh all panels.
|
|
"""
|
|
|
|
def GetController(self):
|
|
"""
|
|
GetController() -> HtmlHelpController
|
|
"""
|
|
|
|
def SetController(self, controller):
|
|
"""
|
|
SetController(controller)
|
|
"""
|
|
Controller = property(None, None)
|
|
Data = property(None, None)
|
|
|
|
def CreateSearch(self):
|
|
"""
|
|
CreateSearch()
|
|
|
|
Creates search panel.
|
|
"""
|
|
|
|
def AddToolbarButtons(self, toolBar, style):
|
|
"""
|
|
AddToolbarButtons(toolBar, style)
|
|
|
|
You may override this virtual method to add more buttons to the help
|
|
window's toolbar.
|
|
"""
|
|
|
|
def CreateContents(self):
|
|
"""
|
|
CreateContents()
|
|
|
|
Creates contents panel.
|
|
"""
|
|
|
|
def CreateIndex(self):
|
|
"""
|
|
CreateIndex()
|
|
|
|
Creates index panel.
|
|
"""
|
|
# end of class HtmlHelpWindow
|
|
|
|
#-- end-helpwnd --#
|
|
#-- begin-helpctrl --#
|
|
ID_HTML_HELPFRAME = 0
|
|
HF_EMBEDDED = 0
|
|
HF_DIALOG = 0
|
|
HF_FRAME = 0
|
|
HF_MODAL = 0
|
|
|
|
class HtmlHelpController(wx.HelpControllerBase):
|
|
"""
|
|
HtmlHelpController(style=HF_DEFAULT_STYLE, parentWindow=None)
|
|
HtmlHelpController(parentWindow, style=HF_DEFAULT_STYLE)
|
|
|
|
This help controller provides an easy way of displaying HTML help in
|
|
your application (see HTML Sample, test example).
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
HtmlHelpController(style=HF_DEFAULT_STYLE, parentWindow=None)
|
|
HtmlHelpController(parentWindow, style=HF_DEFAULT_STYLE)
|
|
|
|
This help controller provides an easy way of displaying HTML help in
|
|
your application (see HTML Sample, test example).
|
|
"""
|
|
|
|
def AddBook(self, *args, **kw):
|
|
"""
|
|
AddBook(bookFile, showWaitMsg=False) -> bool
|
|
AddBook(bookUrl, showWaitMsg=False) -> bool
|
|
|
|
Adds a book (i.e.
|
|
"""
|
|
|
|
def Display(self, *args, **kw):
|
|
"""
|
|
Display(x) -> bool
|
|
Display(id) -> bool
|
|
|
|
Displays page x.
|
|
"""
|
|
|
|
def DisplayContents(self):
|
|
"""
|
|
DisplayContents() -> bool
|
|
|
|
Displays help window and focuses contents panel.
|
|
"""
|
|
|
|
def DisplayIndex(self):
|
|
"""
|
|
DisplayIndex() -> bool
|
|
|
|
Displays help window and focuses index panel.
|
|
"""
|
|
|
|
def KeywordSearch(self, keyword, mode=wx.HELP_SEARCH_ALL):
|
|
"""
|
|
KeywordSearch(keyword, mode=wx.HELP_SEARCH_ALL) -> bool
|
|
|
|
Displays the help window, focuses search panel and starts searching.
|
|
"""
|
|
|
|
def ReadCustomization(self, cfg, path=wx.EmptyString):
|
|
"""
|
|
ReadCustomization(cfg, path=wx.EmptyString)
|
|
|
|
Reads the controller's setting (position of window, etc.)
|
|
"""
|
|
|
|
def SetShouldPreventAppExit(self, enable):
|
|
"""
|
|
SetShouldPreventAppExit(enable)
|
|
|
|
Sets whether the help frame should prevent application from exiting if
|
|
it's the only remaining top level window.
|
|
"""
|
|
|
|
def SetTempDir(self, path):
|
|
"""
|
|
SetTempDir(path)
|
|
|
|
Sets the path for storing temporary files - cached binary versions of
|
|
index and contents files.
|
|
"""
|
|
|
|
def SetTitleFormat(self, format):
|
|
"""
|
|
SetTitleFormat(format)
|
|
|
|
Sets format of title of the frame.
|
|
"""
|
|
|
|
def UseConfig(self, config, rootpath=wx.EmptyString):
|
|
"""
|
|
UseConfig(config, rootpath=wx.EmptyString)
|
|
|
|
Associates the config object with the controller.
|
|
"""
|
|
|
|
def WriteCustomization(self, cfg, path=wx.EmptyString):
|
|
"""
|
|
WriteCustomization(cfg, path=wx.EmptyString)
|
|
|
|
Stores controllers setting (position of window etc.)
|
|
"""
|
|
|
|
def GetHelpWindow(self):
|
|
"""
|
|
GetHelpWindow() -> HtmlHelpWindow
|
|
|
|
Get the current help window.
|
|
"""
|
|
|
|
def SetHelpWindow(self, helpWindow):
|
|
"""
|
|
SetHelpWindow(helpWindow)
|
|
|
|
Set the help window to be managed by this controller.
|
|
"""
|
|
|
|
def GetFrame(self):
|
|
"""
|
|
GetFrame() -> HtmlHelpFrame
|
|
|
|
Returns the current help frame.
|
|
"""
|
|
|
|
def GetDialog(self):
|
|
"""
|
|
GetDialog() -> HtmlHelpDialog
|
|
|
|
Returns the current help dialog.
|
|
"""
|
|
Dialog = property(None, None)
|
|
Frame = property(None, None)
|
|
HelpWindow = property(None, None)
|
|
|
|
def CreateHelpDialog(self, data):
|
|
"""
|
|
CreateHelpDialog(data) -> HtmlHelpDialog
|
|
|
|
This protected virtual method may be overridden so that when
|
|
specifying the wxHF_DIALOG style, the controller uses a different
|
|
dialog.
|
|
"""
|
|
|
|
def CreateHelpFrame(self, data):
|
|
"""
|
|
CreateHelpFrame(data) -> HtmlHelpFrame
|
|
|
|
This protected virtual method may be overridden so that the controller
|
|
uses a different frame.
|
|
"""
|
|
# end of class HtmlHelpController
|
|
|
|
|
|
class HtmlModalHelp(object):
|
|
"""
|
|
HtmlModalHelp(parent, helpFile, topic=wx.EmptyString, style=HF_DEFAULT_STYLE|HF_DIALOG|HF_MODAL)
|
|
|
|
This class uses wxHtmlHelpController to display help in a modal
|
|
dialog.
|
|
"""
|
|
|
|
def __init__(self, parent, helpFile, topic=wx.EmptyString, style=HF_DEFAULT_STYLE|HF_DIALOG|HF_MODAL):
|
|
"""
|
|
HtmlModalHelp(parent, helpFile, topic=wx.EmptyString, style=HF_DEFAULT_STYLE|HF_DIALOG|HF_MODAL)
|
|
|
|
This class uses wxHtmlHelpController to display help in a modal
|
|
dialog.
|
|
"""
|
|
# end of class HtmlModalHelp
|
|
|
|
#-- end-helpctrl --#
|
|
#-- begin-htmllbox --#
|
|
HtmlListBoxNameStr = ""
|
|
|
|
class HtmlListBox(wx.VListBox):
|
|
"""
|
|
HtmlListBox(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name=HtmlListBoxNameStr)
|
|
HtmlListBox()
|
|
|
|
wxHtmlListBox is an implementation of wxVListBox which shows HTML
|
|
content in the listbox rows.
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
HtmlListBox(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name=HtmlListBoxNameStr)
|
|
HtmlListBox()
|
|
|
|
wxHtmlListBox is an implementation of wxVListBox which shows HTML
|
|
content in the listbox rows.
|
|
"""
|
|
|
|
def GetFileSystem(self, *args, **kw):
|
|
"""
|
|
GetFileSystem() -> wx.FileSystem
|
|
|
|
Returns the wxFileSystem used by the HTML parser of this object.
|
|
"""
|
|
|
|
def Create(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name=HtmlListBoxNameStr):
|
|
"""
|
|
Create(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name=HtmlListBoxNameStr) -> bool
|
|
|
|
Creates the control and optionally sets the initial number of items in
|
|
it (it may also be set or changed later with
|
|
wxVListBox::SetItemCount).
|
|
"""
|
|
FileSystem = property(None, None)
|
|
|
|
def OnLinkClicked(self, n, link):
|
|
"""
|
|
OnLinkClicked(n, link)
|
|
|
|
Called when the user clicks on hypertext link.
|
|
"""
|
|
|
|
def GetSelectedTextBgColour(self, colBg):
|
|
"""
|
|
GetSelectedTextBgColour(colBg) -> wx.Colour
|
|
|
|
This virtual function may be overridden to change the appearance of
|
|
the background of the selected cells in the same way as
|
|
GetSelectedTextColour().
|
|
"""
|
|
|
|
def GetSelectedTextColour(self, colFg):
|
|
"""
|
|
GetSelectedTextColour(colFg) -> wx.Colour
|
|
|
|
This virtual function may be overridden to customize the appearance of
|
|
the selected cells.
|
|
"""
|
|
|
|
def OnGetItemMarkup(self, n):
|
|
"""
|
|
OnGetItemMarkup(n) -> String
|
|
|
|
This function may be overridden to decorate HTML returned by
|
|
OnGetItem().
|
|
"""
|
|
|
|
def OnGetItem(self, n):
|
|
"""
|
|
OnGetItem(n) -> String
|
|
|
|
This method must be implemented in the derived class and should return
|
|
the body (i.e.
|
|
"""
|
|
# end of class HtmlListBox
|
|
|
|
|
|
class SimpleHtmlListBox(HtmlListBox, wx.ItemContainer):
|
|
"""
|
|
SimpleHtmlListBox(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, choices=[], style=HLB_DEFAULT_STYLE, validator=wx.DefaultValidator, name=SimpleHtmlListBoxNameStr)
|
|
SimpleHtmlListBox()
|
|
|
|
wxSimpleHtmlListBox is an implementation of wxHtmlListBox which shows
|
|
HTML content in the listbox rows.
|
|
"""
|
|
|
|
def __init__(self, *args, **kw):
|
|
"""
|
|
SimpleHtmlListBox(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, choices=[], style=HLB_DEFAULT_STYLE, validator=wx.DefaultValidator, name=SimpleHtmlListBoxNameStr)
|
|
SimpleHtmlListBox()
|
|
|
|
wxSimpleHtmlListBox is an implementation of wxHtmlListBox which shows
|
|
HTML content in the listbox rows.
|
|
"""
|
|
|
|
def Create(self, *args, **kw):
|
|
"""
|
|
Create(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, choices=[], style=HLB_DEFAULT_STYLE, validator=wx.DefaultValidator, name=SimpleHtmlListBoxNameStr) -> bool
|
|
|
|
Creates the HTML listbox for two-step construction.
|
|
"""
|
|
# end of class SimpleHtmlListBox
|
|
|
|
#-- end-htmllbox --#
|