# -*- coding: utf-8 -*-
#---------------------------------------------------------------------------
# This file is generated by wxPython's PI generator.  Do not edit by hand.
#
# The *.pyi files are used by PyCharm and other development tools to provide
# more information, such as PEP 484 type hints, than it is able to glean from
# introspection of extension types and methods.  They are not intended to be
# imported, executed or used for any other purpose other than providing info
# to the tools. If you don't use use a tool that makes use of .pyi files then
# you can safely ignore this file.
#
# See: https://www.python.org/dev/peps/pep-0484/
#      https://www.jetbrains.com/help/pycharm/2016.1/type-hinting-in-pycharm.html
#
# Copyright: (c) 2020 by Total Control Software
# License:   wxWindows License
#---------------------------------------------------------------------------


"""
The Grid and related classes in this module provide functionality similar to a
spreadsheet, where the application can display rows and columns of data of
various types, which the user can edit and otherwise interact with.
"""
#-- begin-_grid --#

import wx
#-- end-_grid --#
#-- begin-grid --#
GridNameStr = ""
GRID_AUTOSIZE = 0
GRID_FLOAT_FORMAT_FIXED = 0
GRID_FLOAT_FORMAT_SCIENTIFIC = 0
GRID_FLOAT_FORMAT_COMPACT = 0
GRID_FLOAT_FORMAT_UPPER = 0
GRID_FLOAT_FORMAT_DEFAULT = 0
GRIDTABLE_NOTIFY_ROWS_INSERTED = 0
GRIDTABLE_NOTIFY_ROWS_APPENDED = 0
GRIDTABLE_NOTIFY_ROWS_DELETED = 0
GRIDTABLE_NOTIFY_COLS_INSERTED = 0
GRIDTABLE_NOTIFY_COLS_APPENDED = 0
GRIDTABLE_NOTIFY_COLS_DELETED = 0
GRID_DRAW_ROWS_HEADER = 0
GRID_DRAW_COLS_HEADER = 0
GRID_DRAW_CELL_LINES = 0
GRID_DRAW_BOX_RECT = 0
GRID_DRAW_SELECTION = 0
GRID_DRAW_DEFAULT = 0
wxEVT_GRID_CELL_LEFT_CLICK = 0
wxEVT_GRID_CELL_RIGHT_CLICK = 0
wxEVT_GRID_CELL_LEFT_DCLICK = 0
wxEVT_GRID_CELL_RIGHT_DCLICK = 0
wxEVT_GRID_LABEL_LEFT_CLICK = 0
wxEVT_GRID_LABEL_RIGHT_CLICK = 0
wxEVT_GRID_LABEL_LEFT_DCLICK = 0
wxEVT_GRID_LABEL_RIGHT_DCLICK = 0
wxEVT_GRID_ROW_SIZE = 0
wxEVT_GRID_ROW_AUTO_SIZE = 0
wxEVT_GRID_COL_SIZE = 0
wxEVT_GRID_COL_AUTO_SIZE = 0
wxEVT_GRID_RANGE_SELECTING = 0
wxEVT_GRID_RANGE_SELECTED = 0
wxEVT_GRID_CELL_CHANGING = 0
wxEVT_GRID_CELL_CHANGED = 0
wxEVT_GRID_SELECT_CELL = 0
wxEVT_GRID_EDITOR_SHOWN = 0
wxEVT_GRID_EDITOR_HIDDEN = 0
wxEVT_GRID_EDITOR_CREATED = 0
wxEVT_GRID_CELL_BEGIN_DRAG = 0
wxEVT_GRID_ROW_MOVE = 0
wxEVT_GRID_COL_MOVE = 0
wxEVT_GRID_COL_SORT = 0
wxEVT_GRID_TABBING = 0

class GridCellCoords(object):
    """
    GridCellCoords()
    GridCellCoords(row, col)
    
    Represents coordinates of a grid cell.
    """

    def __init__(self, *args, **kw):
        """
        GridCellCoords()
        GridCellCoords(row, col)
        
        Represents coordinates of a grid cell.
        """

    def GetRow(self):
        """
        GetRow() -> int
        
        Return the row of the coordinate.
        """

    def SetRow(self, n):
        """
        SetRow(n)
        
        Set the row of the coordinate.
        """

    def GetCol(self):
        """
        GetCol() -> int
        
        Return the column of the coordinate.
        """

    def SetCol(self, n):
        """
        SetCol(n)
        
        Set the column of the coordinate.
        """

    def Set(self, row, col):
        """
        Set(row, col)
        
        Set the row and column of the coordinate.
        """

    def __eq__(self):
        """
        """

    def __ne__(self):
        """
        """
    Col = property(None, None)
    Row = property(None, None)

    def Get(self):
        """
        Get() -> (row,col)
        
        Return the row and col properties as a tuple.
        """

    def GetIM(self):
        """
        Returns an immutable representation of the ``wx.GridCellCoords`` object, based on ``namedtuple``.
        
        This new object is hashable and can be used as a dictionary key,
        be added to sets, etc.  It can be converted back into a real ``wx.GridCellCoords``
        with a simple statement like this: ``obj = wx.GridCellCoords(imObj)``.
        """

    def __str__(self):
        """
        
        """

    def __repr__(self):
        """
        
        """

    def __len__(self):
        """
        
        """

    def __nonzero__(self):
        """
        
        """

    def __bool__(self):
        """
        
        """

    def __reduce__(self):
        """
        
        """

    def __getitem__(self, idx):
        """
        
        """

    def __setitem__(self, idx, val):
        """
        
        """

    __safe_for_unpickling__ = True
# end of class GridCellCoords


class GridBlockCoords(object):
    """
    GridBlockCoords()
    GridBlockCoords(topRow, leftCol, bottomRow, rightCol)
    
    Represents coordinates of a block of cells in the grid.
    """

    def __init__(self, *args, **kw):
        """
        GridBlockCoords()
        GridBlockCoords(topRow, leftCol, bottomRow, rightCol)
        
        Represents coordinates of a block of cells in the grid.
        """

    def GetTopRow(self):
        """
        GetTopRow() -> int
        
        Return the row of the left top corner.
        """

    def SetTopRow(self, row):
        """
        SetTopRow(row)
        
        Set the row of the left top corner.
        """

    def GetLeftCol(self):
        """
        GetLeftCol() -> int
        
        Return the column of the left top corner.
        """

    def SetLeftCol(self, col):
        """
        SetLeftCol(col)
        
        Set the column of the left top corner.
        """

    def GetBottomRow(self):
        """
        GetBottomRow() -> int
        
        Return the row of the bottom right corner.
        """

    def SetBottomRow(self, row):
        """
        SetBottomRow(row)
        
        Set the row of the bottom right corner.
        """

    def GetRightCol(self):
        """
        GetRightCol() -> int
        
        Return the column of the bottom right corner.
        """

    def SetRightCol(self, col):
        """
        SetRightCol(col)
        
        Set the column of the bottom right corner.
        """

    def GetTopLeft(self):
        """
        GetTopLeft() -> GridCellCoords
        
        Return the coordinates of the top left corner.
        """

    def GetBottomRight(self):
        """
        GetBottomRight() -> GridCellCoords
        
        Return the coordinates of the bottom right corner.
        """

    def Canonicalize(self):
        """
        Canonicalize() -> GridBlockCoords
        
        Return the canonicalized block where top left coordinates is less then
        bottom right coordinates.
        """

    def Intersects(self, other):
        """
        Intersects(other) -> bool
        
        Whether the blocks intersect.
        """

    def Contains(self, *args, **kw):
        """
        Contains(cell) -> bool
        Contains(other) -> bool
        
        Check whether this block contains the given cell.
        """

    def Difference(self, other, splitOrientation):
        """
        Difference(other, splitOrientation) -> GridBlockDiffResult
        
        Calculates the result blocks by subtracting the other block from this
        block.
        """

    def SymDifference(self, other):
        """
        SymDifference(other) -> GridBlockDiffResult
        
        Calculates the symmetric difference of the blocks.
        """

    def __eq__(self):
        """
        """

    def __ne__(self):
        """
        """
    BottomRight = property(None, None)
    BottomRow = property(None, None)
    LeftCol = property(None, None)
    RightCol = property(None, None)
    TopLeft = property(None, None)
    TopRow = property(None, None)

    def __bool__(self):
        """
        __bool__() -> int
        """

    def Get(self):
        """
        Get() -> (topRow, leftCol, bottomRow, rightCol)
        
        Return the block coordinants as a tuple.
        """

    def __str__(self):
        """
        
        """

    def __repr__(self):
        """
        
        """
# end of class GridBlockCoords


class GridBlockDiffResult(object):
    """
    The helper struct uses as a result type for difference functions of
    wxGridBlockCoords class.
    """

    def _getParts(self):
        """
        _getParts() -> PyObject
        """
    m_parts = property(None, None)
# end of class GridBlockDiffResult


class GridBlocks(object):
    """
    Represents a collection of grid blocks that can be iterated over.
    """

    class iterator(object):
        """
        Read-only forward iterator type.
        """
    # end of class iterator


    def begin(self):
        """
        begin() -> iterator
        
        Return iterator corresponding to the beginning of the range.
        """

    def end(self):
        """
        end() -> iterator
        
        Return iterator corresponding to the end of the range.
        """

    def __iter__(self):
        """
        Returns a Python iterator for accessing the collection of grid blocks.
        """

    class PyGridBlocksIterator(object):
        "A Python iterator for GridBlocks objects"
        def __init__(self, blocks):
            self._blocks = blocks
            self._iterator = self._blocks.begin()
    
        def __next__(self):
            if self._iterator == self._blocks.end():
                raise StopIteration
            obj = self._iterator._get()
            self._iterator = self._iterator._next()
            return obj
# end of class GridBlocks


class GridCellRenderer(wx.SharedClientDataContainer, wx.RefCounter):
    """
    GridCellRenderer()
    
    This class is responsible for actually drawing the cell in the grid.
    """

    def __init__(self):
        """
        GridCellRenderer()
        
        This class is responsible for actually drawing the cell in the grid.
        """

    def Clone(self):
        """
        Clone() -> GridCellRenderer
        
        This function must be implemented in derived classes to return a copy
        of itself.
        """

    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
        """
        Draw(grid, attr, dc, rect, row, col, isSelected)
        
        Draw the given cell on the provided DC inside the given rectangle
        using the style specified by the attribute and the default or selected
        state corresponding to the isSelected value.
        """

    def GetBestSize(self, grid, attr, dc, row, col):
        """
        GetBestSize(grid, attr, dc, row, col) -> wx.Size
        
        Get the preferred size of the cell for its contents.
        """

    def GetBestHeight(self, grid, attr, dc, row, col, width):
        """
        GetBestHeight(grid, attr, dc, row, col, width) -> int
        
        Get the preferred height of the cell at the given width.
        """

    def GetBestWidth(self, grid, attr, dc, row, col, height):
        """
        GetBestWidth(grid, attr, dc, row, col, height) -> int
        
        Get the preferred width of the cell at the given height.
        """

    def GetMaxBestSize(self, grid, attr, dc):
        """
        GetMaxBestSize(grid, attr, dc) -> wx.Size
        
        Get the maximum possible size for a cell using this renderer, if
        possible.
        """
# end of class GridCellRenderer


class GridCellStringRenderer(GridCellRenderer):
    """
    GridCellStringRenderer()
    
    This class may be used to format string data in a cell; it is the
    default for string cells.
    """

    def __init__(self):
        """
        GridCellStringRenderer()
        
        This class may be used to format string data in a cell; it is the
        default for string cells.
        """
# end of class GridCellStringRenderer


class GridCellAutoWrapStringRenderer(GridCellStringRenderer):
    """
    GridCellAutoWrapStringRenderer()
    
    This class may be used to format string data in a cell.
    """

    def __init__(self):
        """
        GridCellAutoWrapStringRenderer()
        
        This class may be used to format string data in a cell.
        """
# end of class GridCellAutoWrapStringRenderer


class GridCellBoolRenderer(GridCellRenderer):
    """
    GridCellBoolRenderer()
    
    This class may be used to format boolean data in a cell.
    """

    def __init__(self):
        """
        GridCellBoolRenderer()
        
        This class may be used to format boolean data in a cell.
        """
# end of class GridCellBoolRenderer


class GridCellDateRenderer(GridCellStringRenderer):
    """
    GridCellDateRenderer(outformat="")
    
    This class may be used to show a date, without time, in a cell.
    """

    def __init__(self, outformat=""):
        """
        GridCellDateRenderer(outformat="")
        
        This class may be used to show a date, without time, in a cell.
        """

    def SetParameters(self, params):
        """
        SetParameters(params)
        
        Sets the strftime()-like format string which will be used to render
        the date.
        """
# end of class GridCellDateRenderer


class GridCellDateTimeRenderer(GridCellDateRenderer):
    """
    GridCellDateTimeRenderer(outformat=wx.DefaultDateTimeFormat, informat=wx.DefaultDateTimeFormat)
    
    This class may be used to format a date/time data in a cell.
    """

    def __init__(self, outformat=wx.DefaultDateTimeFormat, informat=wx.DefaultDateTimeFormat):
        """
        GridCellDateTimeRenderer(outformat=wx.DefaultDateTimeFormat, informat=wx.DefaultDateTimeFormat)
        
        This class may be used to format a date/time data in a cell.
        """
# end of class GridCellDateTimeRenderer


class GridCellEnumRenderer(GridCellStringRenderer):
    """
    GridCellEnumRenderer(choices=wx.EmptyString)
    
    This class may be used to render in a cell a number as a textual
    equivalent.
    """

    def __init__(self, choices=wx.EmptyString):
        """
        GridCellEnumRenderer(choices=wx.EmptyString)
        
        This class may be used to render in a cell a number as a textual
        equivalent.
        """

    def SetParameters(self, params):
        """
        SetParameters(params)
        
        Sets the comma separated string content of the enum.
        """
# end of class GridCellEnumRenderer


class GridCellFloatRenderer(GridCellStringRenderer):
    """
    GridCellFloatRenderer(width=-1, precision=-1, format=GRID_FLOAT_FORMAT_DEFAULT)
    
    This class may be used to format floating point data in a cell.
    """

    def __init__(self, width=-1, precision=-1, format=GRID_FLOAT_FORMAT_DEFAULT):
        """
        GridCellFloatRenderer(width=-1, precision=-1, format=GRID_FLOAT_FORMAT_DEFAULT)
        
        This class may be used to format floating point data in a cell.
        """

    def GetFormat(self):
        """
        GetFormat() -> int
        
        Returns the specifier used to format the data to string.
        """

    def GetPrecision(self):
        """
        GetPrecision() -> int
        
        Returns the precision.
        """

    def GetWidth(self):
        """
        GetWidth() -> int
        
        Returns the width.
        """

    def SetFormat(self, format):
        """
        SetFormat(format)
        
        Set the format to use for display the number.
        """

    def SetParameters(self, params):
        """
        SetParameters(params)
        
        The parameters string format is "width[,precision[,format]]" where
        format should be chosen between f|e|g|E|G (f is used by default)
        """

    def SetPrecision(self, precision):
        """
        SetPrecision(precision)
        
        Sets the precision.
        """

    def SetWidth(self, width):
        """
        SetWidth(width)
        
        Sets the width.
        """
    Format = property(None, None)
    Precision = property(None, None)
    Width = property(None, None)
# end of class GridCellFloatRenderer


class GridCellNumberRenderer(GridCellStringRenderer):
    """
    GridCellNumberRenderer()
    
    This class may be used to format integer data in a cell.
    """

    def __init__(self):
        """
        GridCellNumberRenderer()
        
        This class may be used to format integer data in a cell.
        """
# end of class GridCellNumberRenderer


class GridActivationResult(object):
    """
    Represents the result of wxGridCellEditor::TryActivate().
    """

    @staticmethod
    def DoNothing():
        """
        DoNothing() -> GridActivationResult
        
        Indicate that nothing should be done and the cell shouldn't be edited
        at all.
        """

    @staticmethod
    def DoChange(newval):
        """
        DoChange(newval) -> GridActivationResult
        
        Indicate that activating the cell is possible and would change its
        value to the given one.
        """

    @staticmethod
    def DoEdit():
        """
        DoEdit() -> GridActivationResult
        
        Indicate that the editor control should be shown and the cell should
        be edited normally.
        """
# end of class GridActivationResult


class GridActivationSource(object):
    """
    Represents a source of cell activation, which may be either a user
    event (mouse or keyboard) or the program itself.
    """
    Program = 0
    Key = 0
    Mouse = 0

    def GetOrigin(self):
        """
        GetOrigin() -> Origin
        
        Get the origin of the activation.
        """

    def GetKeyEvent(self):
        """
        GetKeyEvent() -> wx.KeyEvent
        
        Get the key event corresponding to the key press activating the cell.
        """

    def GetMouseEvent(self):
        """
        GetMouseEvent() -> wx.MouseEvent
        
        Get the mouse event corresponding to the click activating the cell.
        """
    KeyEvent = property(None, None)
    MouseEvent = property(None, None)
# end of class GridActivationSource


class GridCellEditor(wx.SharedClientDataContainer, wx.RefCounter):
    """
    GridCellEditor()
    
    This class is responsible for providing and manipulating the in-place
    edit controls for the grid.
    """

    def __init__(self):
        """
        GridCellEditor()
        
        This class is responsible for providing and manipulating the in-place
        edit controls for the grid.
        """

    def BeginEdit(self, row, col, grid):
        """
        BeginEdit(row, col, grid)
        
        Fetch the value from the table and prepare the edit control to begin
        editing.
        """

    def Clone(self):
        """
        Clone() -> GridCellEditor
        
        Create a new object which is the copy of this one.
        """

    def Create(self, parent, id, evtHandler):
        """
        Create(parent, id, evtHandler)
        
        Creates the actual edit control.
        """

    def Destroy(self):
        """
        Destroy()
        
        Final cleanup.
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """

    def ApplyEdit(self, row, col, grid):
        """
        ApplyEdit(row, col, grid)
        
        Effectively save the changes in the grid.
        """

    def HandleReturn(self, event):
        """
        HandleReturn(event)
        
        Some types of controls on some platforms may need some help with the
        Return key.
        """

    def IsCreated(self):
        """
        IsCreated() -> bool
        
        Returns true if the edit control has been created.
        """

    def PaintBackground(self, dc, rectCell, attr):
        """
        PaintBackground(dc, rectCell, attr)
        
        Draws the part of the cell not occupied by the control: the base class
        version just fills it with background colour from the attribute.
        """

    def Reset(self):
        """
        Reset()
        
        Reset the value in the control back to its starting value.
        """

    def SetSize(self, rect):
        """
        SetSize(rect)
        
        Size and position the edit control.
        """

    def Show(self, show, attr=None):
        """
        Show(show, attr=None)
        
        Show or hide the edit control, use the specified attributes to set
        colours/fonts for it.
        """

    def StartingClick(self):
        """
        StartingClick()
        
        If the editor is enabled by clicking on the cell, this method will be
        called.
        """

    def StartingKey(self, event):
        """
        StartingKey(event)
        
        If the editor is enabled by pressing keys on the grid, this will be
        called to let the editor do something about that first key if desired.
        """

    def IsAcceptedKey(self, event):
        """
        IsAcceptedKey(event) -> bool
        
        Return true to allow the given key to start editing: the base class
        version only checks that the event has no modifiers.
        """

    def GetValue(self):
        """
        GetValue() -> String
        
        Returns the value currently in the editor control.
        """

    def GetWindow(self):
        """
        GetWindow() -> wx.Window
        
        Get the edit window used by this editor.
        """

    def SetWindow(self, window):
        """
        SetWindow(window)
        
        Set the wxWindow that will be used by this cell editor for editing the
        value.
        """

    def GetControl(self):
        """
        GetControl() -> wx.Control
        
        Get the wxControl used by this editor.
        """

    def SetControl(self, control):
        """
        SetControl(control)
        
        Set the wxControl that will be used by this cell editor for editing
        the value.
        """

    def TryActivate(self, row, col, grid, actSource):
        """
        TryActivate(row, col, grid, actSource) -> GridActivationResult
        
        Function allowing to create an "activatable" editor.
        """

    def DoActivate(self, row, col, grid):
        """
        DoActivate(row, col, grid)
        
        Function which must be overridden for "activatable" editors.
        """
    Control = property(None, None)
    Value = property(None, None)
    Window = property(None, None)
# end of class GridCellEditor


class GridCellActivatableEditor(GridCellEditor):
    """
    Base class for activatable editors.
    """

    def TryActivate(self, row, col, grid, actSource):
        """
        TryActivate(row, col, grid, actSource) -> GridActivationResult
        
        Same method as in wxGridCellEditor, but pure virtual.
        """

    def DoActivate(self, row, col, grid):
        """
        DoActivate(row, col, grid)
        
        Same method as in wxGridCellEditor, but pure virtual.
        """
# end of class GridCellActivatableEditor


class GridCellTextEditor(GridCellEditor):
    """
    GridCellTextEditor(maxChars=0)
    
    Grid cell editor for string/text data.
    """

    def __init__(self, maxChars=0):
        """
        GridCellTextEditor(maxChars=0)
        
        Grid cell editor for string/text data.
        """

    def SetParameters(self, params):
        """
        SetParameters(params)
        
        The parameters string format is "n" where n is a number representing
        the maximum width.
        """

    def SetValidator(self, validator):
        """
        SetValidator(validator)
        
        Set validator to validate user input.
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellTextEditor


class GridCellDateEditor(GridCellEditor):
    """
    GridCellDateEditor(format="")
    
    Grid cell editor for dates.
    """

    def __init__(self, format=""):
        """
        GridCellDateEditor(format="")
        
        Grid cell editor for dates.
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellDateEditor


class GridCellAutoWrapStringEditor(GridCellTextEditor):
    """
    GridCellAutoWrapStringEditor()
    
    Grid cell editor for wrappable string/text data.
    """

    def __init__(self):
        """
        GridCellAutoWrapStringEditor()
        
        Grid cell editor for wrappable string/text data.
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellAutoWrapStringEditor


class GridCellBoolEditor(GridCellEditor):
    """
    GridCellBoolEditor()
    
    Grid cell editor for boolean data.
    """

    def __init__(self):
        """
        GridCellBoolEditor()
        
        Grid cell editor for boolean data.
        """

    @staticmethod
    def IsTrueValue(value):
        """
        IsTrueValue(value) -> bool
        
        Returns true if the given value is equal to the string representation
        of the truth value we currently use (see UseStringValues()).
        """

    @staticmethod
    def UseStringValues(valueTrue="1", valueFalse=wx.EmptyString):
        """
        UseStringValues(valueTrue="1", valueFalse=wx.EmptyString)
        
        This method allows you to customize the values returned by GetValue()
        for the cell using this editor.
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellBoolEditor


class GridCellChoiceEditor(GridCellEditor):
    """
    GridCellChoiceEditor(choices, allowOthers=False)
    
    Grid cell editor for string data providing the user a choice from a
    list of strings.
    """

    def __init__(self, choices, allowOthers=False):
        """
        GridCellChoiceEditor(choices, allowOthers=False)
        
        Grid cell editor for string data providing the user a choice from a
        list of strings.
        """

    def SetParameters(self, params):
        """
        SetParameters(params)
        
        Parameters string format is "item1[,item2[...,itemN]]".
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellChoiceEditor


class GridCellEnumEditor(GridCellChoiceEditor):
    """
    GridCellEnumEditor(choices=wx.EmptyString)
    
    Grid cell editor which displays an enum number as a textual equivalent
    (e.g.
    """

    def __init__(self, choices=wx.EmptyString):
        """
        GridCellEnumEditor(choices=wx.EmptyString)
        
        Grid cell editor which displays an enum number as a textual equivalent
        (e.g.
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellEnumEditor


class GridCellFloatEditor(GridCellTextEditor):
    """
    GridCellFloatEditor(width=-1, precision=-1, format=GRID_FLOAT_FORMAT_DEFAULT)
    
    The editor for floating point numbers data.
    """

    def __init__(self, width=-1, precision=-1, format=GRID_FLOAT_FORMAT_DEFAULT):
        """
        GridCellFloatEditor(width=-1, precision=-1, format=GRID_FLOAT_FORMAT_DEFAULT)
        
        The editor for floating point numbers data.
        """

    def SetParameters(self, params):
        """
        SetParameters(params)
        
        The parameters string format is "width[,precision[,format]]" where
        format should be chosen between f|e|g|E|G (f is used by default)
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellFloatEditor


class GridCellNumberEditor(GridCellTextEditor):
    """
    GridCellNumberEditor(min=-1, max=-1)
    
    Grid cell editor for numeric integer data.
    """

    def __init__(self, min=-1, max=-1):
        """
        GridCellNumberEditor(min=-1, max=-1)
        
        Grid cell editor for numeric integer data.
        """

    def SetParameters(self, params):
        """
        SetParameters(params)
        
        Parameters string format is "min,max".
        """

    def EndEdit(self, row, col, grid, oldval):
        """
        EndEdit(row, col, grid, oldval)
        
        End editing the cell.
        
        This function must check if the current value of the editing cell
        is valid and different from the original value in its string
        form. If not then simply return None.  If it has changed then
        this method should save the new value so that ApplyEdit can
        apply it later and the string representation of the new value
        should be returned.
        
        Notice that this method shoiuld not modify the grid as the
        change could still be vetoed.
        """
# end of class GridCellNumberEditor


class GridFitMode(object):
    """
    GridFitMode()
    
    Allows to specify the behaviour when the cell contents doesn't fit
    into its allotted space.
    """

    def __init__(self):
        """
        GridFitMode()
        
        Allows to specify the behaviour when the cell contents doesn't fit
        into its allotted space.
        """

    def IsSpecified(self):
        """
        IsSpecified() -> bool
        
        Return true if the object specifies some particular behaviour.
        """

    def IsClip(self):
        """
        IsClip() -> bool
        
        Return true if the object specifies clipping behaviour.
        """

    def IsOverflow(self):
        """
        IsOverflow() -> bool
        
        Return true if the object specifies overflow behaviour.
        """

    def GetEllipsizeMode(self):
        """
        GetEllipsizeMode() -> EllipsizeMode
        
        Return ellipsize mode, possibly wxELLIPSIZE_NONE.
        """

    @staticmethod
    def Clip():
        """
        Clip() -> GridFitMode
        
        Pseudo-constructor for object specifying clipping behaviour.
        """

    @staticmethod
    def Overflow():
        """
        Overflow() -> GridFitMode
        
        Pseudo-constructor for object specifying overflow behaviour.
        """

    @staticmethod
    def Ellipsize(ellipsize=wx.ELLIPSIZE_END):
        """
        Ellipsize(ellipsize=wx.ELLIPSIZE_END) -> GridFitMode
        
        Pseudo-constructor for object specifying ellipsize behaviour.
        """
    EllipsizeMode = property(None, None)
# end of class GridFitMode


class GridCellAttr(wx.SharedClientDataContainer, wx.RefCounter):
    """
    GridCellAttr(attrDefault=None)
    GridCellAttr(colText, colBack, font, hAlign, vAlign)
    
    This class can be used to alter the cells' appearance in the grid by
    changing their attributes from the defaults.
    """
    Any = 0
    Cell = 0
    Row = 0
    Col = 0
    Default = 0
    Merged = 0

    def __init__(self, *args, **kw):
        """
        GridCellAttr(attrDefault=None)
        GridCellAttr(colText, colBack, font, hAlign, vAlign)
        
        This class can be used to alter the cells' appearance in the grid by
        changing their attributes from the defaults.
        """

    def Clone(self):
        """
        Clone() -> GridCellAttr
        
        Creates a new copy of this object.
        """

    def DecRef(self):
        """
        DecRef()
        
        This class is reference counted: it is created with ref count of 1, so
        calling DecRef() once will delete it.
        """

    def GetAlignment(self):
        """
        GetAlignment() -> (hAlign, vAlign)
        
        Get the alignment to use for the cell with the given attribute.
        """

    def GetBackgroundColour(self):
        """
        GetBackgroundColour() -> wx.Colour
        
        Returns the background colour.
        """

    def GetEditor(self, grid, row, col):
        """
        GetEditor(grid, row, col) -> GridCellEditor
        
        Returns the cell editor.
        """

    def GetEditorPtr(self, grid, row, col):
        """
        GetEditorPtr(grid, row, col) -> GridCellEditorPtr
        
        Returns the cell editor.
        """

    def GetFont(self):
        """
        GetFont() -> wx.Font
        
        Returns the font.
        """

    def GetNonDefaultAlignment(self):
        """
        GetNonDefaultAlignment() -> (hAlign, vAlign)
        
        Get the alignment defined by this attribute.
        """

    def GetRenderer(self, grid, row, col):
        """
        GetRenderer(grid, row, col) -> GridCellRenderer
        
        Returns the cell renderer.
        """

    def GetTextColour(self):
        """
        GetTextColour() -> wx.Colour
        
        Returns the text colour.
        """

    def HasAlignment(self):
        """
        HasAlignment() -> bool
        
        Returns true if this attribute has a valid alignment set.
        """

    def HasBackgroundColour(self):
        """
        HasBackgroundColour() -> bool
        
        Returns true if this attribute has a valid background colour set.
        """

    def HasEditor(self):
        """
        HasEditor() -> bool
        
        Returns true if this attribute has a valid cell editor set.
        """

    def HasFont(self):
        """
        HasFont() -> bool
        
        Returns true if this attribute has a valid font set.
        """

    def HasRenderer(self):
        """
        HasRenderer() -> bool
        
        Returns true if this attribute has a valid cell renderer set.
        """

    def HasTextColour(self):
        """
        HasTextColour() -> bool
        
        Returns true if this attribute has a valid text colour set.
        """

    def IncRef(self):
        """
        IncRef()
        
        This class is reference counted: it is created with ref count of 1, so
        calling DecRef() once will delete it.
        """

    def IsReadOnly(self):
        """
        IsReadOnly() -> bool
        
        Returns true if this cell is set as read-only.
        """

    def SetAlignment(self, hAlign, vAlign):
        """
        SetAlignment(hAlign, vAlign)
        
        Sets the alignment.
        """

    def SetBackgroundColour(self, colBack):
        """
        SetBackgroundColour(colBack)
        
        Sets the background colour.
        """

    def SetDefAttr(self, defAttr):
        """
        SetDefAttr(defAttr)
        """

    def SetEditor(self, editor):
        """
        SetEditor(editor)
        
        Sets the editor to be used with the cells with this attribute.
        """

    def SetFont(self, font):
        """
        SetFont(font)
        
        Sets the font.
        """

    def SetReadOnly(self, isReadOnly=True):
        """
        SetReadOnly(isReadOnly=True)
        
        Sets the cell as read-only.
        """

    def SetRenderer(self, renderer):
        """
        SetRenderer(renderer)
        
        Sets the renderer to be used for cells with this attribute.
        """

    def SetTextColour(self, colText):
        """
        SetTextColour(colText)
        
        Sets the text colour.
        """

    def MergeWith(self, mergefrom):
        """
        MergeWith(mergefrom)
        """

    def SetSize(self, num_rows, num_cols):
        """
        SetSize(num_rows, num_cols)
        """

    def SetFitMode(self, fitMode):
        """
        SetFitMode(fitMode)
        
        Specifies the behaviour of the cell contents if it doesn't fit into
        the available space.
        """

    def SetOverflow(self, allow=True):
        """
        SetOverflow(allow=True)
        
        Specifies if cells using this attribute should overflow or clip their
        contents.
        """

    def SetKind(self, kind):
        """
        SetKind(kind)
        """

    def HasReadWriteMode(self):
        """
        HasReadWriteMode() -> bool
        """

    def HasOverflowMode(self):
        """
        HasOverflowMode() -> bool
        """

    def HasSize(self):
        """
        HasSize() -> bool
        """

    def GetSize(self):
        """
        GetSize() -> (num_rows, num_cols)
        """

    def GetFitMode(self):
        """
        GetFitMode() -> GridFitMode
        
        Returns the fitting mode for the cells using this attribute.
        """

    def GetOverflow(self):
        """
        GetOverflow() -> bool
        
        Returns true if the cells using this attribute overflow into the
        neighbouring cells.
        """

    def CanOverflow(self):
        """
        CanOverflow() -> bool
        
        Returns true if the cell will draw an overflowed text into the
        neighbouring cells.
        """

    def GetKind(self):
        """
        GetKind() -> AttrKind
        """
    BackgroundColour = property(None, None)
    FitMode = property(None, None)
    Font = property(None, None)
    Kind = property(None, None)
    Overflow = property(None, None)
    TextColour = property(None, None)
# end of class GridCellAttr


class GridCornerHeaderRenderer(GridHeaderLabelsRenderer):
    """
    Base class for corner header renderer.
    """
# end of class GridCornerHeaderRenderer


class GridHeaderLabelsRenderer(object):
    """
    Base class for header cells renderers.
    """

    def DrawBorder(self, grid, dc, rect):
        """
        DrawBorder(grid, dc, rect)
        
        Called by the grid to draw the border around the cell header.
        """

    def DrawLabel(self, grid, dc, value, rect, horizAlign, vertAlign, textOrientation):
        """
        DrawLabel(grid, dc, value, rect, horizAlign, vertAlign, textOrientation)
        
        Called by the grid to draw the specified label.
        """
# end of class GridHeaderLabelsRenderer


class GridRowHeaderRenderer(GridHeaderLabelsRenderer):
    """
    Base class for row headers renderer.
    """
# end of class GridRowHeaderRenderer


class GridColumnHeaderRenderer(GridHeaderLabelsRenderer):
    """
    Base class for column headers renderer.
    """
# end of class GridColumnHeaderRenderer


class GridRowHeaderRendererDefault(GridRowHeaderRenderer):
    """
    Default row header renderer.
    """

    def DrawBorder(self, grid, dc, rect):
        """
        DrawBorder(grid, dc, rect)
        
        Implement border drawing for the row labels.
        """
# end of class GridRowHeaderRendererDefault


class GridColumnHeaderRendererDefault(GridColumnHeaderRenderer):
    """
    Default column header renderer.
    """

    def DrawBorder(self, grid, dc, rect):
        """
        DrawBorder(grid, dc, rect)
        
        Implement border drawing for the column labels.
        """
# end of class GridColumnHeaderRendererDefault


class GridCornerHeaderRendererDefault(GridCornerHeaderRenderer):
    """
    Default corner window renderer.
    """

    def DrawBorder(self, grid, dc, rect):
        """
        DrawBorder(grid, dc, rect)
        
        Implement border drawing for the corner window.
        """
# end of class GridCornerHeaderRendererDefault


class GridCellAttrProvider(wx.ClientDataContainer):
    """
    GridCellAttrProvider()
    
    Class providing attributes to be used for the grid cells.
    """

    def __init__(self):
        """
        GridCellAttrProvider()
        
        Class providing attributes to be used for the grid cells.
        """

    def SetAttr(self, attr, row, col):
        """
        SetAttr(attr, row, col)
        
        Set attribute for the specified cell.
        """

    def SetRowAttr(self, attr, row):
        """
        SetRowAttr(attr, row)
        
        Set attribute for the specified row.
        """

    def SetColAttr(self, attr, col):
        """
        SetColAttr(attr, col)
        
        Set attribute for the specified column.
        """

    def GetColumnHeaderRenderer(self, col):
        """
        GetColumnHeaderRenderer(col) -> GridColumnHeaderRenderer
        
        Return the renderer used for drawing column headers.
        """

    def GetRowHeaderRenderer(self, row):
        """
        GetRowHeaderRenderer(row) -> GridRowHeaderRenderer
        
        Return the renderer used for drawing row headers.
        """

    def GetCornerRenderer(self):
        """
        GetCornerRenderer() -> GridCornerHeaderRenderer
        
        Return the renderer used for drawing the corner window.
        """

    def GetAttr(self, row, col, kind):
        """
        GetAttr(row, col, kind) -> GridCellAttr
        
        Get the attribute to use for the specified cell.
        """

    def GetAttrPtr(self, row, col, kind):
        """
        GetAttrPtr(row, col, kind) -> GridCellAttrPtr
        
        Get the attribute to use for the specified cell.
        """
    CornerRenderer = property(None, None)
# end of class GridCellAttrProvider


class GridTableBase(wx.Object):
    """
    GridTableBase()
    
    The almost abstract base class for grid tables.
    """

    def __init__(self):
        """
        GridTableBase()
        
        The almost abstract base class for grid tables.
        """

    def IsEmptyCell(self, row, col):
        """
        IsEmptyCell(row, col) -> bool
        
        May be overridden to implement testing for empty cells.
        """

    def IsEmpty(self, coords):
        """
        IsEmpty(coords) -> bool
        
        Same as IsEmptyCell() but taking wxGridCellCoords.
        """

    def GetValue(self, row, col):
        """
        GetValue(row, col) -> PyObject
        
        Must be overridden to implement accessing the table values as text.
        """

    def SetValue(self, row, col, value):
        """
        SetValue(row, col, value)
        
        Must be overridden to implement setting the table values as text.
        """

    def GetTypeName(self, row, col):
        """
        GetTypeName(row, col) -> String
        
        Returns the type of the value in the given cell.
        """

    def CanGetValueAs(self, row, col, typeName):
        """
        CanGetValueAs(row, col, typeName) -> bool
        
        Returns true if the value of the given cell can be accessed as if it
        were of the specified type.
        """

    def CanSetValueAs(self, row, col, typeName):
        """
        CanSetValueAs(row, col, typeName) -> bool
        
        Returns true if the value of the given cell can be set as if it were
        of the specified type.
        """

    def GetValueAsLong(self, row, col):
        """
        GetValueAsLong(row, col) -> long
        
        Returns the value of the given cell as a long.
        """

    def GetValueAsDouble(self, row, col):
        """
        GetValueAsDouble(row, col) -> double
        
        Returns the value of the given cell as a double.
        """

    def GetValueAsBool(self, row, col):
        """
        GetValueAsBool(row, col) -> bool
        
        Returns the value of the given cell as a boolean.
        """

    def SetValueAsLong(self, row, col, value):
        """
        SetValueAsLong(row, col, value)
        
        Sets the value of the given cell as a long.
        """

    def SetValueAsDouble(self, row, col, value):
        """
        SetValueAsDouble(row, col, value)
        
        Sets the value of the given cell as a double.
        """

    def SetValueAsBool(self, row, col, value):
        """
        SetValueAsBool(row, col, value)
        
        Sets the value of the given cell as a boolean.
        """

    def Clear(self):
        """
        Clear()
        
        Clear the table contents.
        """

    def InsertRows(self, pos=0, numRows=1):
        """
        InsertRows(pos=0, numRows=1) -> bool
        
        Insert additional rows into the table.
        """

    def AppendRows(self, numRows=1):
        """
        AppendRows(numRows=1) -> bool
        
        Append additional rows at the end of the table.
        """

    def DeleteRows(self, pos=0, numRows=1):
        """
        DeleteRows(pos=0, numRows=1) -> bool
        
        Delete rows from the table.
        """

    def InsertCols(self, pos=0, numCols=1):
        """
        InsertCols(pos=0, numCols=1) -> bool
        
        Exactly the same as InsertRows() but for columns.
        """

    def AppendCols(self, numCols=1):
        """
        AppendCols(numCols=1) -> bool
        
        Exactly the same as AppendRows() but for columns.
        """

    def DeleteCols(self, pos=0, numCols=1):
        """
        DeleteCols(pos=0, numCols=1) -> bool
        
        Exactly the same as DeleteRows() but for columns.
        """

    def GetRowLabelValue(self, row):
        """
        GetRowLabelValue(row) -> String
        
        Return the label of the specified row.
        """

    def GetColLabelValue(self, col):
        """
        GetColLabelValue(col) -> String
        
        Return the label of the specified column.
        """

    def GetCornerLabelValue(self):
        """
        GetCornerLabelValue() -> String
        
        Return the label of the grid's corner.
        """

    def SetRowLabelValue(self, row, label):
        """
        SetRowLabelValue(row, label)
        
        Set the given label for the specified row.
        """

    def SetColLabelValue(self, col, label):
        """
        SetColLabelValue(col, label)
        
        Exactly the same as SetRowLabelValue() but for columns.
        """

    def SetCornerLabelValue(self):
        """
        SetCornerLabelValue()
        
        Set the given label for the grid's corner.
        """

    def SetAttrProvider(self, attrProvider):
        """
        SetAttrProvider(attrProvider)
        
        Associate this attributes provider with the table.
        """

    def GetAttrProvider(self):
        """
        GetAttrProvider() -> GridCellAttrProvider
        
        Returns the attribute provider currently being used.
        """

    def GetAttr(self, row, col, kind):
        """
        GetAttr(row, col, kind) -> GridCellAttr
        
        Return the attribute for the given cell.
        """

    def GetAttrPtr(self, row, col, kind):
        """
        GetAttrPtr(row, col, kind) -> GridCellAttrPtr
        
        Return the attribute for the given cell.
        """

    def SetAttr(self, attr, row, col):
        """
        SetAttr(attr, row, col)
        
        Set attribute of the specified cell.
        """

    def SetRowAttr(self, attr, row):
        """
        SetRowAttr(attr, row)
        
        Set attribute of the specified row.
        """

    def SetColAttr(self, attr, col):
        """
        SetColAttr(attr, col)
        
        Set attribute of the specified column.
        """

    def GetNumberRows(self):
        """
        GetNumberRows() -> int
        
        Must be overridden to return the number of rows in the table.
        """

    def GetNumberCols(self):
        """
        GetNumberCols() -> int
        
        Must be overridden to return the number of columns in the table.
        """

    def GetRowsCount(self):
        """
        GetRowsCount() -> int
        
        Return the number of rows in the table.
        """

    def GetColsCount(self):
        """
        GetColsCount() -> int
        
        Return the number of columns in the table.
        """

    def SetView(self, grid):
        """
        SetView(grid)
        
        Called by the grid when the table is associated with it.
        """

    def GetView(self):
        """
        GetView() -> Grid
        
        Returns the last grid passed to SetView().
        """

    def CanHaveAttributes(self):
        """
        CanHaveAttributes() -> bool
        
        Returns true if this table supports attributes or false otherwise.
        """

    def CanMeasureColUsingSameAttr(self, col):
        """
        CanMeasureColUsingSameAttr(col) -> bool
        
        Override to return true if the same attribute can be used for
        measuring all cells in the given column.
        """

    def GetValueAsLong(self, row, col):
        """
        
        """

    def GetValueAsDouble(self, row, col):
        """
        
        """

    def GetValueAsBool(self, row, col):
        """
        
        """

    def SetValueAsLong(self, row, col, value):
        """
        
        """

    def SetValueAsDouble(self, row, col, value):
        """
        
        """

    def SetValueAsBool(self, row, col, value):
        """
        
        """
    AttrProvider = property(None, None)
    ColsCount = property(None, None)
    CornerLabelValue = property(None, None)
    NumberCols = property(None, None)
    NumberRows = property(None, None)
    RowsCount = property(None, None)
    View = property(None, None)
# end of class GridTableBase


class GridTableMessage(object):
    """
    GridTableMessage()
    GridTableMessage(table, id, comInt1=-1, comInt2=-1)
    
    Message class used by the grid table to send requests and
    notifications to the grid view.
    """

    def __init__(self, *args, **kw):
        """
        GridTableMessage()
        GridTableMessage(table, id, comInt1=-1, comInt2=-1)
        
        Message class used by the grid table to send requests and
        notifications to the grid view.
        """

    def SetTableObject(self, table):
        """
        SetTableObject(table)
        
        Sets the table object.
        """

    def GetTableObject(self):
        """
        GetTableObject() -> GridTableBase
        
        Gets the table object.
        """

    def SetId(self, id):
        """
        SetId(id)
        
        Sets an id.
        """

    def GetId(self):
        """
        GetId() -> int
        
        Gets an id.
        """

    def SetCommandInt(self, comInt1):
        """
        SetCommandInt(comInt1)
        
        Set the position after which the insertion/deletion occur.
        """

    def GetCommandInt(self):
        """
        GetCommandInt() -> int
        
        Get the position after which the insertion/deletion occur.
        """

    def SetCommandInt2(self, comInt2):
        """
        SetCommandInt2(comInt2)
        
        Set the number of rows to be inserted/deleted.
        """

    def GetCommandInt2(self):
        """
        GetCommandInt2() -> int
        
        Get the number of rows to be inserted/deleted.
        """
    CommandInt = property(None, None)
    CommandInt2 = property(None, None)
    Id = property(None, None)
    TableObject = property(None, None)
# end of class GridTableMessage


class GridStringTable(GridTableBase):
    """
    GridStringTable()
    GridStringTable(numRows, numCols)
    
    Simplest type of data table for a grid for small tables of strings
    that are stored in memory.
    """

    def __init__(self, *args, **kw):
        """
        GridStringTable()
        GridStringTable(numRows, numCols)
        
        Simplest type of data table for a grid for small tables of strings
        that are stored in memory.
        """

    def GetNumberRows(self):
        """
        GetNumberRows() -> int
        
        Must be overridden to return the number of rows in the table.
        """

    def GetNumberCols(self):
        """
        GetNumberCols() -> int
        
        Must be overridden to return the number of columns in the table.
        """

    def GetValue(self, row, col):
        """
        GetValue(row, col) -> String
        
        Must be overridden to implement accessing the table values as text.
        """

    def SetValue(self, row, col, value):
        """
        SetValue(row, col, value)
        
        Must be overridden to implement setting the table values as text.
        """

    def Clear(self):
        """
        Clear()
        
        Clear the table contents.
        """

    def InsertRows(self, pos=0, numRows=1):
        """
        InsertRows(pos=0, numRows=1) -> bool
        
        Insert additional rows into the table.
        """

    def AppendRows(self, numRows=1):
        """
        AppendRows(numRows=1) -> bool
        
        Append additional rows at the end of the table.
        """

    def DeleteRows(self, pos=0, numRows=1):
        """
        DeleteRows(pos=0, numRows=1) -> bool
        
        Delete rows from the table.
        """

    def InsertCols(self, pos=0, numCols=1):
        """
        InsertCols(pos=0, numCols=1) -> bool
        
        Exactly the same as InsertRows() but for columns.
        """

    def AppendCols(self, numCols=1):
        """
        AppendCols(numCols=1) -> bool
        
        Exactly the same as AppendRows() but for columns.
        """

    def DeleteCols(self, pos=0, numCols=1):
        """
        DeleteCols(pos=0, numCols=1) -> bool
        
        Exactly the same as DeleteRows() but for columns.
        """

    def SetRowLabelValue(self, row, label):
        """
        SetRowLabelValue(row, label)
        
        Set the given label for the specified row.
        """

    def SetColLabelValue(self, col, label):
        """
        SetColLabelValue(col, label)
        
        Exactly the same as SetRowLabelValue() but for columns.
        """

    def SetCornerLabelValue(self):
        """
        SetCornerLabelValue()
        
        Set the given label for the grid's corner.
        """

    def GetRowLabelValue(self, row):
        """
        GetRowLabelValue(row) -> String
        
        Return the label of the specified row.
        """

    def GetColLabelValue(self, col):
        """
        GetColLabelValue(col) -> String
        
        Return the label of the specified column.
        """

    def GetCornerLabelValue(self):
        """
        GetCornerLabelValue() -> String
        
        Return the label of the grid's corner.
        """
    CornerLabelValue = property(None, None)
    NumberCols = property(None, None)
    NumberRows = property(None, None)
# end of class GridStringTable


class GridSizesInfo(object):
    """
    GridSizesInfo()
    GridSizesInfo(defSize, allSizes)
    
    wxGridSizesInfo stores information about sizes of all wxGrid rows or
    columns.
    """

    def __init__(self, *args, **kw):
        """
        GridSizesInfo()
        GridSizesInfo(defSize, allSizes)
        
        wxGridSizesInfo stores information about sizes of all wxGrid rows or
        columns.
        """
    m_sizeDefault = property(None, None)

    def GetSize(self, pos):
        """
        GetSize(pos) -> int
        
        Get the element size.
        """
# end of class GridSizesInfo


class Grid(wx.ScrolledCanvas):
    """
    Grid()
    Grid(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.WANTS_CHARS, name=GridNameStr)
    
    wxGrid and its related classes are used for displaying and editing
    tabular data.
    """
    GridSelectCells = 0
    GridSelectRows = 0
    GridSelectColumns = 0
    GridSelectRowsOrColumns = 0
    GridSelectNone = 0
    CellSpan_Inside = 0
    CellSpan_None = 0
    CellSpan_Main = 0
    Tab_Stop = 0
    Tab_Wrap = 0
    Tab_Leave = 0

    def __init__(self, *args, **kw):
        """
        Grid()
        Grid(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.WANTS_CHARS, name=GridNameStr)
        
        wxGrid and its related classes are used for displaying and editing
        tabular data.
        """

    def Create(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.WANTS_CHARS, name=GridNameStr):
        """
        Create(parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.WANTS_CHARS, name=GridNameStr) -> bool
        
        Creates the grid window for an object initialized using the default
        constructor.
        """

    def CreateGrid(self, numRows, numCols, selmode=GridSelectCells):
        """
        CreateGrid(numRows, numCols, selmode=GridSelectCells) -> bool
        
        Creates a grid with the specified initial number of rows and columns.
        """

    def _SetTable(self, table, takeOwnership=False, selmode=GridSelectCells):
        """
        _SetTable(table, takeOwnership=False, selmode=GridSelectCells) -> bool
        
        Passes a pointer to a custom grid table to be used by the grid.
        """

    def AssignTable(self, table, selmode=GridSelectCells):
        """
        AssignTable(table, selmode=GridSelectCells)
        
        Assigns a pointer to a custom grid table to be used by the grid.
        """

    def ProcessTableMessage(self, msg):
        """
        ProcessTableMessage(msg) -> bool
        
        Receive and handle a message from the table.
        """

    def EnableGridLines(self, enable=True):
        """
        EnableGridLines(enable=True)
        
        Turns the drawing of grid lines on or off.
        """

    def GetColGridLinePen(self, col):
        """
        GetColGridLinePen(col) -> wx.Pen
        
        Returns the pen used for vertical grid lines.
        """

    def GetDefaultGridLinePen(self):
        """
        GetDefaultGridLinePen() -> wx.Pen
        
        Returns the pen used for grid lines.
        """

    def GetGridLineColour(self):
        """
        GetGridLineColour() -> wx.Colour
        
        Returns the colour used for grid lines.
        """

    def GetRowGridLinePen(self, row):
        """
        GetRowGridLinePen(row) -> wx.Pen
        
        Returns the pen used for horizontal grid lines.
        """

    def GridLinesEnabled(self):
        """
        GridLinesEnabled() -> bool
        
        Returns true if drawing of grid lines is turned on, false otherwise.
        """

    def SetGridLineColour(self, colour):
        """
        SetGridLineColour(colour)
        
        Sets the colour used to draw grid lines.
        """

    def GetColLabelAlignment(self):
        """
        GetColLabelAlignment() -> (horiz, vert)
        
        Sets the arguments to the current column label alignment values.
        """

    def GetColLabelTextOrientation(self):
        """
        GetColLabelTextOrientation() -> int
        
        Returns the orientation of the column labels (either wxHORIZONTAL or
        wxVERTICAL).
        """

    def GetColLabelValue(self, col):
        """
        GetColLabelValue(col) -> String
        
        Returns the specified column label.
        """

    def GetCornerLabelAlignment(self, horiz, vert):
        """
        GetCornerLabelAlignment(horiz, vert)
        
        Sets the arguments to the current corner label alignment values.
        """

    def GetCornerLabelTextOrientation(self):
        """
        GetCornerLabelTextOrientation() -> int
        
        Returns the orientation of the corner label (either wxHORIZONTAL or
        wxVERTICAL).
        """

    def GetCornerLabelValue(self):
        """
        GetCornerLabelValue() -> String
        
        Returns the (top-left) corner label.
        """

    def GetLabelBackgroundColour(self):
        """
        GetLabelBackgroundColour() -> wx.Colour
        
        Returns the colour used for the background of row and column labels.
        """

    def GetLabelFont(self):
        """
        GetLabelFont() -> wx.Font
        
        Returns the font used for row and column labels.
        """

    def GetLabelTextColour(self):
        """
        GetLabelTextColour() -> wx.Colour
        
        Returns the colour used for row and column label text.
        """

    def GetRowLabelAlignment(self):
        """
        GetRowLabelAlignment() -> (horiz, vert)
        
        Returns the alignment used for row labels.
        """

    def GetRowLabelValue(self, row):
        """
        GetRowLabelValue(row) -> String
        
        Returns the specified row label.
        """

    def HideColLabels(self):
        """
        HideColLabels()
        
        Hides the column labels by calling SetColLabelSize() with a size of 0.
        """

    def HideRowLabels(self):
        """
        HideRowLabels()
        
        Hides the row labels by calling SetRowLabelSize() with a size of 0.
        """

    def SetColLabelAlignment(self, horiz, vert):
        """
        SetColLabelAlignment(horiz, vert)
        
        Sets the horizontal and vertical alignment of column label text.
        """

    def SetColLabelTextOrientation(self, textOrientation):
        """
        SetColLabelTextOrientation(textOrientation)
        
        Sets the orientation of the column labels (either wxHORIZONTAL or
        wxVERTICAL).
        """

    def SetColLabelValue(self, col, value):
        """
        SetColLabelValue(col, value)
        
        Set the value for the given column label.
        """

    def SetCornerLabelAlignment(self, horiz, vert):
        """
        SetCornerLabelAlignment(horiz, vert)
        
        Sets the horizontal and vertical alignment of the (top-left) corner
        label text.
        """

    def SetCornerLabelTextOrientation(self, textOrientation):
        """
        SetCornerLabelTextOrientation(textOrientation)
        
        Sets the orientation of the (top-left) corner label (either
        wxHORIZONTAL or wxVERTICAL).
        """

    def SetCornerLabelValue(self):
        """
        SetCornerLabelValue()
        
        Set the value for the (top-left) corner label.
        """

    def SetLabelBackgroundColour(self, colour):
        """
        SetLabelBackgroundColour(colour)
        
        Sets the background colour for row and column labels.
        """

    def SetLabelFont(self, font):
        """
        SetLabelFont(font)
        
        Sets the font for row and column labels.
        """

    def SetLabelTextColour(self, colour):
        """
        SetLabelTextColour(colour)
        
        Sets the colour for row and column label text.
        """

    def SetRowLabelAlignment(self, horiz, vert):
        """
        SetRowLabelAlignment(horiz, vert)
        
        Sets the horizontal and vertical alignment of row label text.
        """

    def SetRowLabelValue(self, row, value):
        """
        SetRowLabelValue(row, value)
        
        Sets the value for the given row label.
        """

    def SetUseNativeColLabels(self, native=True):
        """
        SetUseNativeColLabels(native=True)
        
        Call this in order to make the column labels use a native look by
        using wxRendererNative::DrawHeaderButton() internally.
        """

    def UseNativeColHeader(self, native=True):
        """
        UseNativeColHeader(native=True) -> bool
        
        Enable the use of native header window for column labels.
        """

    def GetCellAlignment(self, row, col):
        """
        GetCellAlignment(row, col) -> (horiz, vert)
        
        Sets the arguments to the horizontal and vertical text alignment
        values for the grid cell at the specified location.
        """

    def GetCellBackgroundColour(self, row, col):
        """
        GetCellBackgroundColour(row, col) -> wx.Colour
        
        Returns the background colour of the cell at the specified location.
        """

    def GetCellFont(self, row, col):
        """
        GetCellFont(row, col) -> wx.Font
        
        Returns the font for text in the grid cell at the specified location.
        """

    def GetCellTextColour(self, row, col):
        """
        GetCellTextColour(row, col) -> wx.Colour
        
        Returns the text colour for the grid cell at the specified location.
        """

    def GetDefaultCellAlignment(self):
        """
        GetDefaultCellAlignment() -> (horiz, vert)
        
        Returns the default cell alignment.
        """

    def GetDefaultCellBackgroundColour(self):
        """
        GetDefaultCellBackgroundColour() -> wx.Colour
        
        Returns the current default background colour for grid cells.
        """

    def GetDefaultCellFont(self):
        """
        GetDefaultCellFont() -> wx.Font
        
        Returns the current default font for grid cell text.
        """

    def GetDefaultCellTextColour(self):
        """
        GetDefaultCellTextColour() -> wx.Colour
        
        Returns the current default colour for grid cell text.
        """

    def SetCellAlignment(self, row, col, horiz, vert):
        """
        SetCellAlignment(row, col, horiz, vert)
        
        Sets the horizontal and vertical alignment for grid cell text at the
        specified location.
        """

    def SetCellBackgroundColour(self, row, col, colour):
        """
        SetCellBackgroundColour(row, col, colour)
        
        Set the background colour for the given cell or all cells by default.
        """

    def SetCellFont(self, row, col, font):
        """
        SetCellFont(row, col, font)
        
        Sets the font for text in the grid cell at the specified location.
        """

    def SetCellTextColour(self, row, col, colour):
        """
        SetCellTextColour(row, col, colour)
        
        Sets the text colour for the given cell.
        """

    def SetDefaultCellAlignment(self, horiz, vert):
        """
        SetDefaultCellAlignment(horiz, vert)
        
        Sets the default horizontal and vertical alignment for grid cell text.
        """

    def SetDefaultCellBackgroundColour(self, colour):
        """
        SetDefaultCellBackgroundColour(colour)
        
        Sets the default background colour for grid cells.
        """

    def SetDefaultCellFont(self, font):
        """
        SetDefaultCellFont(font)
        
        Sets the default font to be used for grid cell text.
        """

    def SetDefaultCellTextColour(self, colour):
        """
        SetDefaultCellTextColour(colour)
        
        Sets the current default colour for grid cell text.
        """

    def CanEnableCellControl(self):
        """
        CanEnableCellControl() -> bool
        
        Returns true if the in-place edit control for the current grid cell
        can be used and false otherwise.
        """

    def DisableCellEditControl(self):
        """
        DisableCellEditControl()
        
        Disables in-place editing of grid cells.
        """

    def EnableCellEditControl(self, enable=True):
        """
        EnableCellEditControl(enable=True)
        
        Enables or disables in-place editing of grid cell data.
        """

    def EnableEditing(self, edit):
        """
        EnableEditing(edit)
        
        Makes the grid globally editable or read-only.
        """

    def GetCellEditor(self, row, col):
        """
        GetCellEditor(row, col) -> GridCellEditor
        
        Returns a pointer to the editor for the cell at the specified
        location.
        """

    def GetCellRenderer(self, row, col):
        """
        GetCellRenderer(row, col) -> GridCellRenderer
        
        Returns a pointer to the renderer for the grid cell at the specified
        location.
        """

    def GetCellValue(self, *args, **kw):
        """
        GetCellValue(row, col) -> String
        GetCellValue(coords) -> String
        
        Returns the string contained in the cell at the specified location.
        """

    def GetDefaultEditor(self):
        """
        GetDefaultEditor() -> GridCellEditor
        
        Returns a pointer to the current default grid cell editor.
        """

    def GetDefaultEditorForCell(self, *args, **kw):
        """
        GetDefaultEditorForCell(row, col) -> GridCellEditor
        GetDefaultEditorForCell(c) -> GridCellEditor
        
        Returns the default editor for the specified cell.
        """

    def GetDefaultEditorForType(self, typeName):
        """
        GetDefaultEditorForType(typeName) -> GridCellEditor
        
        Returns the default editor for the cells containing values of the
        given type.
        """

    def GetDefaultRenderer(self):
        """
        GetDefaultRenderer() -> GridCellRenderer
        
        Returns a pointer to the current default grid cell renderer.
        """

    def GetDefaultRendererForCell(self, row, col):
        """
        GetDefaultRendererForCell(row, col) -> GridCellRenderer
        
        Returns the default renderer for the given cell.
        """

    def GetDefaultRendererForType(self, typeName):
        """
        GetDefaultRendererForType(typeName) -> GridCellRenderer
        
        Returns the default renderer for the cell containing values of the
        given type.
        """

    def HideCellEditControl(self):
        """
        HideCellEditControl()
        
        Hides the in-place cell edit control.
        """

    def IsCellEditControlEnabled(self):
        """
        IsCellEditControlEnabled() -> bool
        
        Returns true if the in-place edit control is currently enabled.
        """

    def IsCellEditControlShown(self):
        """
        IsCellEditControlShown() -> bool
        
        Returns true if the in-place edit control is currently shown.
        """

    def IsCurrentCellReadOnly(self):
        """
        IsCurrentCellReadOnly() -> bool
        
        Returns true if the current cell is read-only.
        """

    def IsEditable(self):
        """
        IsEditable() -> bool
        
        Returns false if the whole grid has been set as read-only or true
        otherwise.
        """

    def IsReadOnly(self, row, col):
        """
        IsReadOnly(row, col) -> bool
        
        Returns true if the cell at the specified location can't be edited.
        """

    def RegisterDataType(self, typeName, renderer, editor):
        """
        RegisterDataType(typeName, renderer, editor)
        
        Register a new data type.
        """

    def SaveEditControlValue(self):
        """
        SaveEditControlValue()
        
        Sets the value of the current grid cell to the current in-place edit
        control value.
        """

    def SetCellEditor(self, row, col, editor):
        """
        SetCellEditor(row, col, editor)
        
        Sets the editor for the grid cell at the specified location.
        """

    def SetCellRenderer(self, row, col, renderer):
        """
        SetCellRenderer(row, col, renderer)
        
        Sets the renderer for the grid cell at the specified location.
        """

    def SetCellValue(self, *args, **kw):
        """
        SetCellValue(row, col, s)
        SetCellValue(coords, s)
        
        Sets the string value for the cell at the specified location.
        """

    def SetColFormatBool(self, col):
        """
        SetColFormatBool(col)
        
        Sets the specified column to display boolean values.
        """

    def SetColFormatCustom(self, col, typeName):
        """
        SetColFormatCustom(col, typeName)
        
        Sets the specified column to display data in a custom format.
        """

    def SetColFormatFloat(self, col, width=-1, precision=-1):
        """
        SetColFormatFloat(col, width=-1, precision=-1)
        
        Sets the specified column to display floating point values with the
        given width and precision.
        """

    def SetColFormatNumber(self, col):
        """
        SetColFormatNumber(col)
        
        Sets the specified column to display integer values.
        """

    def SetColFormatDate(self, col, format=""):
        """
        SetColFormatDate(col, format="")
        
        Sets the specified column to display date values.
        """

    def SetDefaultEditor(self, editor):
        """
        SetDefaultEditor(editor)
        
        Sets the default editor for grid cells.
        """

    def SetDefaultRenderer(self, renderer):
        """
        SetDefaultRenderer(renderer)
        
        Sets the default renderer for grid cells.
        """

    def SetReadOnly(self, row, col, isReadOnly=True):
        """
        SetReadOnly(row, col, isReadOnly=True)
        
        Makes the cell at the specified location read-only or editable.
        """

    def ShowCellEditControl(self):
        """
        ShowCellEditControl()
        
        Displays the active in-place cell edit control for the current cell
        after it was hidden.
        """

    def AutoSize(self):
        """
        AutoSize()
        
        Automatically sets the height and width of all rows and columns to fit
        their contents.
        """

    def AutoSizeColLabelSize(self, col):
        """
        AutoSizeColLabelSize(col)
        
        Automatically adjusts width of the column to fit its label.
        """

    def AutoSizeColumn(self, col, setAsMin=True):
        """
        AutoSizeColumn(col, setAsMin=True)
        
        Automatically sizes the column to fit its contents.
        """

    def AutoSizeColumns(self, setAsMin=True):
        """
        AutoSizeColumns(setAsMin=True)
        
        Automatically sizes all columns to fit their contents.
        """

    def AutoSizeRow(self, row, setAsMin=True):
        """
        AutoSizeRow(row, setAsMin=True)
        
        Automatically sizes the row to fit its contents.
        """

    def AutoSizeRowLabelSize(self, col):
        """
        AutoSizeRowLabelSize(col)
        
        Automatically adjusts height of the row to fit its label.
        """

    def AutoSizeRows(self, setAsMin=True):
        """
        AutoSizeRows(setAsMin=True)
        
        Automatically sizes all rows to fit their contents.
        """

    def GetCellFitMode(self, row, col):
        """
        GetCellFitMode(row, col) -> GridFitMode
        
        Returns the cell fitting mode.
        """

    def GetCellOverflow(self, row, col):
        """
        GetCellOverflow(row, col) -> bool
        
        Returns true if the cell value can overflow.
        """

    def GetColLabelSize(self):
        """
        GetColLabelSize() -> int
        
        Returns the current height of the column labels.
        """

    def GetColMinimalAcceptableWidth(self):
        """
        GetColMinimalAcceptableWidth() -> int
        
        Returns the minimal width to which a column may be resized.
        """

    def GetColSize(self, col):
        """
        GetColSize(col) -> int
        
        Returns the width of the specified column.
        """

    def IsColShown(self, col):
        """
        IsColShown(col) -> bool
        
        Returns true if the specified column is not currently hidden.
        """

    def GetDefaultCellFitMode(self):
        """
        GetDefaultCellFitMode() -> GridFitMode
        
        Returns the default cell fitting mode.
        """

    def GetDefaultCellOverflow(self):
        """
        GetDefaultCellOverflow() -> bool
        
        Returns true if the cells can overflow by default.
        """

    def GetDefaultColLabelSize(self):
        """
        GetDefaultColLabelSize() -> int
        
        Returns the default height for column labels.
        """

    def GetDefaultColSize(self):
        """
        GetDefaultColSize() -> int
        
        Returns the current default width for grid columns.
        """

    def GetDefaultRowLabelSize(self):
        """
        GetDefaultRowLabelSize() -> int
        
        Returns the default width for the row labels.
        """

    def GetDefaultRowSize(self):
        """
        GetDefaultRowSize() -> int
        
        Returns the current default height for grid rows.
        """

    def GetRowMinimalAcceptableHeight(self):
        """
        GetRowMinimalAcceptableHeight() -> int
        
        Returns the minimal size to which rows can be resized.
        """

    def GetRowLabelSize(self):
        """
        GetRowLabelSize() -> int
        
        Returns the current width of the row labels.
        """

    def GetRowSize(self, row):
        """
        GetRowSize(row) -> int
        
        Returns the height of the specified row.
        """

    def IsRowShown(self, row):
        """
        IsRowShown(row) -> bool
        
        Returns true if the specified row is not currently hidden.
        """

    def SetCellFitMode(self, row, col, fitMode):
        """
        SetCellFitMode(row, col, fitMode)
        
        Specifies the behaviour of the cell contents if it doesn't fit into
        the available space.
        """

    def SetCellOverflow(self, row, col, allow):
        """
        SetCellOverflow(row, col, allow)
        
        Sets the overflow permission of the cell.
        """

    def SetColLabelSize(self, height):
        """
        SetColLabelSize(height)
        
        Sets the height of the column labels.
        """

    def SetColMinimalAcceptableWidth(self, width):
        """
        SetColMinimalAcceptableWidth(width)
        
        Sets the minimal width to which the user can resize columns.
        """

    def SetColMinimalWidth(self, col, width):
        """
        SetColMinimalWidth(col, width)
        
        Sets the minimal width for the specified column col.
        """

    def SetColSize(self, col, width):
        """
        SetColSize(col, width)
        
        Sets the width of the specified column.
        """

    def HideCol(self, col):
        """
        HideCol(col)
        
        Hides the specified column.
        """

    def ShowCol(self, col):
        """
        ShowCol(col)
        
        Shows the previously hidden column by resizing it to non-0 size.
        """

    def SetDefaultCellFitMode(self, fitMode):
        """
        SetDefaultCellFitMode(fitMode)
        
        Specifies the default behaviour of the cell contents if it doesn't fit
        into the available space.
        """

    def SetDefaultCellOverflow(self, allow):
        """
        SetDefaultCellOverflow(allow)
        
        Sets the default overflow permission of the cells.
        """

    def SetDefaultColSize(self, width, resizeExistingCols=False):
        """
        SetDefaultColSize(width, resizeExistingCols=False)
        
        Sets the default width for columns in the grid.
        """

    def SetDefaultRowSize(self, height, resizeExistingRows=False):
        """
        SetDefaultRowSize(height, resizeExistingRows=False)
        
        Sets the default height for rows in the grid.
        """

    def SetRowLabelSize(self, width):
        """
        SetRowLabelSize(width)
        
        Sets the width of the row labels.
        """

    def SetRowMinimalAcceptableHeight(self, height):
        """
        SetRowMinimalAcceptableHeight(height)
        
        Sets the minimal row height used by default.
        """

    def SetRowMinimalHeight(self, row, height):
        """
        SetRowMinimalHeight(row, height)
        
        Sets the minimal height for the specified row.
        """

    def SetRowSize(self, row, height):
        """
        SetRowSize(row, height)
        
        Sets the height of the specified row.
        """

    def HideRow(self, col):
        """
        HideRow(col)
        
        Hides the specified row.
        """

    def ShowRow(self, col):
        """
        ShowRow(col)
        
        Shows the previously hidden row.
        """

    def GetColSizes(self):
        """
        GetColSizes() -> GridSizesInfo
        
        Get size information for all columns at once.
        """

    def GetRowSizes(self):
        """
        GetRowSizes() -> GridSizesInfo
        
        Get size information for all row at once.
        """

    def SetColSizes(self, sizeInfo):
        """
        SetColSizes(sizeInfo)
        
        Restore all columns sizes.
        """

    def SetRowSizes(self, sizeInfo):
        """
        SetRowSizes(sizeInfo)
        
        Restore all rows sizes.
        """

    def SetCellSize(self, row, col, num_rows, num_cols):
        """
        SetCellSize(row, col, num_rows, num_cols)
        
        Set the size of the cell.
        """

    def GetCellSize(self, *args, **kw):
        """
        GetCellSize(row, col, num_rows, num_cols) -> CellSpan
        GetCellSize(coords) -> wx.Size
        
        Get the size of the cell in number of cells covered by it.
        """

    def CanDragCell(self):
        """
        CanDragCell() -> bool
        
        Return true if the dragging of cells is enabled or false otherwise.
        """

    def CanDragColMove(self):
        """
        CanDragColMove() -> bool
        
        Returns true if columns can be moved by dragging with the mouse.
        """

    def CanDragColSize(self, col):
        """
        CanDragColSize(col) -> bool
        
        Returns true if the given column can be resized by dragging with the
        mouse.
        """

    def CanDragGridColEdges(self):
        """
        CanDragGridColEdges() -> bool
        
        Return true if column edges inside the grid can be dragged to resize
        the rows.
        """

    def CanDragGridRowEdges(self):
        """
        CanDragGridRowEdges() -> bool
        
        Return true if row edges inside the grid can be dragged to resize the
        rows.
        """

    def CanDragGridSize(self):
        """
        CanDragGridSize() -> bool
        
        Return true if the dragging of grid lines to resize rows and columns
        is enabled or false otherwise.
        """

    def CanDragRowMove(self):
        """
        CanDragRowMove() -> bool
        
        Returns true if rows can be moved by dragging with the mouse.
        """

    def CanDragRowSize(self, row):
        """
        CanDragRowSize(row) -> bool
        
        Returns true if the given row can be resized by dragging with the
        mouse.
        """

    def CanHideColumns(self):
        """
        CanHideColumns() -> bool
        
        Returns true if columns can be hidden from the popup menu of the
        native header.
        """

    def DisableColResize(self, col):
        """
        DisableColResize(col)
        
        Disable interactive resizing of the specified column.
        """

    def DisableRowResize(self, row):
        """
        DisableRowResize(row)
        
        Disable interactive resizing of the specified row.
        """

    def DisableDragColMove(self):
        """
        DisableDragColMove()
        
        Disables column moving by dragging with the mouse.
        """

    def DisableDragRowMove(self):
        """
        DisableDragRowMove()
        
        Disables row moving by dragging with the mouse.
        """

    def DisableDragColSize(self):
        """
        DisableDragColSize()
        
        Disables column sizing by dragging with the mouse.
        """

    def DisableDragGridSize(self):
        """
        DisableDragGridSize()
        
        Disable mouse dragging of grid lines to resize rows and columns.
        """

    def DisableDragRowSize(self):
        """
        DisableDragRowSize()
        
        Disables row sizing by dragging with the mouse.
        """

    def DisableHidingColumns(self):
        """
        DisableHidingColumns()
        
        Disables column hiding from the header popup menu.
        """

    def EnableDragCell(self, enable=True):
        """
        EnableDragCell(enable=True)
        
        Enables or disables cell dragging with the mouse.
        """

    def EnableDragColMove(self, enable=True):
        """
        EnableDragColMove(enable=True) -> bool
        
        Enables or disables column moving by dragging with the mouse.
        """

    def EnableDragRowMove(self, enable=True):
        """
        EnableDragRowMove(enable=True) -> bool
        
        Enables or disables row moving by dragging with the mouse.
        """

    def EnableDragColSize(self, enable=True):
        """
        EnableDragColSize(enable=True)
        
        Enables or disables column sizing by dragging with the mouse.
        """

    def EnableDragGridSize(self, enable=True):
        """
        EnableDragGridSize(enable=True)
        
        Enables or disables row and column resizing by dragging gridlines with
        the mouse.
        """

    def EnableDragRowSize(self, enable=True):
        """
        EnableDragRowSize(enable=True)
        
        Enables or disables row sizing by dragging with the mouse.
        """

    def EnableHidingColumns(self, enable=True):
        """
        EnableHidingColumns(enable=True) -> bool
        
        Enables or disables column hiding from the header popup menu.
        """

    def GetColAt(self, colPos):
        """
        GetColAt(colPos) -> int
        
        Returns the column ID of the specified column position.
        """

    def GetColPos(self, colID):
        """
        GetColPos(colID) -> int
        
        Returns the position of the specified column.
        """

    def SetColPos(self, colID, newPos):
        """
        SetColPos(colID, newPos)
        
        Sets the position of the specified column.
        """

    def SetColumnsOrder(self, order):
        """
        SetColumnsOrder(order)
        
        Sets the positions of all columns at once.
        """

    def ResetColPos(self):
        """
        ResetColPos()
        
        Resets the position of the columns to the default.
        """

    def GetRowAt(self, rowPos):
        """
        GetRowAt(rowPos) -> int
        
        Returns the row ID of the specified row position.
        """

    def GetRowPos(self, rowID):
        """
        GetRowPos(rowID) -> int
        
        Returns the position of the specified row.
        """

    def SetRowPos(self, rowID, newPos):
        """
        SetRowPos(rowID, newPos)
        
        Sets the position of the specified row.
        """

    def SetRowsOrder(self, order):
        """
        SetRowsOrder(order)
        
        Sets the positions of all rows at once.
        """

    def ResetRowPos(self):
        """
        ResetRowPos()
        
        Resets the position of the rows to the default.
        """

    def GetGridCursorCoords(self):
        """
        GetGridCursorCoords() -> GridCellCoords
        
        Returns the current grid cursor position.
        """

    def GetGridCursorCol(self):
        """
        GetGridCursorCol() -> int
        
        Returns the current grid cell column position.
        """

    def GetGridCursorRow(self):
        """
        GetGridCursorRow() -> int
        
        Returns the current grid cell row position.
        """

    def GoToCell(self, *args, **kw):
        """
        GoToCell(row, col)
        GoToCell(coords)
        
        Make the given cell current and ensure it is visible.
        """

    def MoveCursorDown(self, expandSelection):
        """
        MoveCursorDown(expandSelection) -> bool
        
        Moves the grid cursor down by one row.
        """

    def MoveCursorDownBlock(self, expandSelection):
        """
        MoveCursorDownBlock(expandSelection) -> bool
        
        Moves the grid cursor down in the current column such that it skips to
        the beginning or end of a block of non-empty cells.
        """

    def MoveCursorLeft(self, expandSelection):
        """
        MoveCursorLeft(expandSelection) -> bool
        
        Moves the grid cursor left by one column.
        """

    def MoveCursorLeftBlock(self, expandSelection):
        """
        MoveCursorLeftBlock(expandSelection) -> bool
        
        Moves the grid cursor left in the current row such that it skips to
        the beginning or end of a block of non-empty cells.
        """

    def MoveCursorRight(self, expandSelection):
        """
        MoveCursorRight(expandSelection) -> bool
        
        Moves the grid cursor right by one column.
        """

    def MoveCursorRightBlock(self, expandSelection):
        """
        MoveCursorRightBlock(expandSelection) -> bool
        
        Moves the grid cursor right in the current row such that it skips to
        the beginning or end of a block of non-empty cells.
        """

    def MoveCursorUp(self, expandSelection):
        """
        MoveCursorUp(expandSelection) -> bool
        
        Moves the grid cursor up by one row.
        """

    def MoveCursorUpBlock(self, expandSelection):
        """
        MoveCursorUpBlock(expandSelection) -> bool
        
        Moves the grid cursor up in the current column such that it skips to
        the beginning or end of a block of non-empty cells.
        """

    def MovePageDown(self):
        """
        MovePageDown() -> bool
        
        Moves the grid cursor down by some number of rows so that the previous
        bottom visible row becomes the top visible row.
        """

    def MovePageUp(self):
        """
        MovePageUp() -> bool
        
        Moves the grid cursor up by some number of rows so that the previous
        top visible row becomes the bottom visible row.
        """

    def SetGridCursor(self, *args, **kw):
        """
        SetGridCursor(row, col)
        SetGridCursor(coords)
        
        Set the grid cursor to the specified cell.
        """

    def SetTabBehaviour(self, behaviour):
        """
        SetTabBehaviour(behaviour)
        
        Set the grid's behaviour when the user presses the TAB key.
        """

    def ClearSelection(self):
        """
        ClearSelection()
        
        Deselects all cells that are currently selected.
        """

    def DeselectRow(self, row):
        """
        DeselectRow(row)
        
        Deselects a row of cells.
        """

    def DeselectCol(self, col):
        """
        DeselectCol(col)
        
        Deselects a column of cells.
        """

    def DeselectCell(self, row, col):
        """
        DeselectCell(row, col)
        
        Deselects a cell.
        """

    def GetSelectedBlocks(self):
        """
        GetSelectedBlocks() -> GridBlocks
        
        Returns a range of grid selection blocks.
        """

    def GetSelectedRowBlocks(self):
        """
        GetSelectedRowBlocks() -> PyObject
        
        Returns an ordered range of non-overlapping selected rows.
        """

    def GetSelectedColBlocks(self):
        """
        GetSelectedColBlocks() -> PyObject
        
        Returns an ordered range of non-overlapping selected columns.
        """

    def GetSelectedCells(self):
        """
        GetSelectedCells() -> GridCellCoordsArray
        
        Returns an array of individually selected cells.
        """

    def GetSelectedCols(self):
        """
        GetSelectedCols() -> ArrayInt
        
        Returns an array of selected columns.
        """

    def GetSelectedRows(self):
        """
        GetSelectedRows() -> ArrayInt
        
        Returns an array of selected rows.
        """

    def GetSelectionBackground(self):
        """
        GetSelectionBackground() -> wx.Colour
        
        Returns the colour used for drawing the selection background.
        """

    def GetSelectionBlockBottomRight(self):
        """
        GetSelectionBlockBottomRight() -> GridCellCoordsArray
        
        Returns an array of the bottom right corners of blocks of selected
        cells.
        """

    def GetSelectionBlockTopLeft(self):
        """
        GetSelectionBlockTopLeft() -> GridCellCoordsArray
        
        Returns an array of the top left corners of blocks of selected cells.
        """

    def GetSelectionForeground(self):
        """
        GetSelectionForeground() -> wx.Colour
        
        Returns the colour used for drawing the selection foreground.
        """

    def GetSelectionMode(self):
        """
        GetSelectionMode() -> GridSelectionModes
        
        Returns the current selection mode.
        """

    def IsInSelection(self, *args, **kw):
        """
        IsInSelection(row, col) -> bool
        IsInSelection(coords) -> bool
        
        Returns true if the given cell is selected.
        """

    def IsSelection(self):
        """
        IsSelection() -> bool
        
        Returns true if there are currently any selected cells, rows, columns
        or blocks.
        """

    def SelectAll(self):
        """
        SelectAll()
        
        Selects all cells in the grid.
        """

    def SelectBlock(self, *args, **kw):
        """
        SelectBlock(topRow, leftCol, bottomRow, rightCol, addToSelected=False)
        SelectBlock(topLeft, bottomRight, addToSelected=False)
        
        Selects a rectangular block of cells.
        """

    def SelectCol(self, col, addToSelected=False):
        """
        SelectCol(col, addToSelected=False)
        
        Selects the specified column.
        """

    def SelectRow(self, row, addToSelected=False):
        """
        SelectRow(row, addToSelected=False)
        
        Selects the specified row.
        """

    def SetSelectionBackground(self, c):
        """
        SetSelectionBackground(c)
        
        Set the colour to be used for drawing the selection background.
        """

    def SetSelectionForeground(self, c):
        """
        SetSelectionForeground(c)
        
        Set the colour to be used for drawing the selection foreground.
        """

    def SetSelectionMode(self, selmode):
        """
        SetSelectionMode(selmode)
        
        Set the selection behaviour of the grid.
        """

    def GetScrollLineX(self):
        """
        GetScrollLineX() -> int
        
        Returns the number of pixels per horizontal scroll increment.
        """

    def GetScrollLineY(self):
        """
        GetScrollLineY() -> int
        
        Returns the number of pixels per vertical scroll increment.
        """

    def IsVisible(self, *args, **kw):
        """
        IsVisible(row, col, wholeCellVisible=True) -> bool
        IsVisible(coords, wholeCellVisible=True) -> bool
        
        Returns true if a cell is either entirely or at least partially
        visible in the grid window.
        """

    def MakeCellVisible(self, *args, **kw):
        """
        MakeCellVisible(row, col)
        MakeCellVisible(coords)
        
        Brings the specified cell into the visible grid cell area with minimal
        scrolling.
        """

    def GetFirstFullyVisibleRow(self):
        """
        GetFirstFullyVisibleRow() -> int
        
        Returns the topmost row of the current visible area.
        """

    def GetFirstFullyVisibleColumn(self):
        """
        GetFirstFullyVisibleColumn() -> int
        
        Returns the leftmost column of the current visible area.
        """

    def SetScrollLineX(self, x):
        """
        SetScrollLineX(x)
        
        Sets the number of pixels per horizontal scroll increment.
        """

    def SetScrollLineY(self, y):
        """
        SetScrollLineY(y)
        
        Sets the number of pixels per vertical scroll increment.
        """

    def BlockToDeviceRect(self, topLeft, bottomRight, gridWindow=None):
        """
        BlockToDeviceRect(topLeft, bottomRight, gridWindow=None) -> wx.Rect
        
        Convert grid cell coordinates to grid window pixel coordinates.
        """

    def CellToRect(self, *args, **kw):
        """
        CellToRect(row, col) -> wx.Rect
        CellToRect(coords) -> wx.Rect
        
        Return the rectangle corresponding to the grid cell's size and
        position in logical coordinates.
        """

    def CellToGridWindow(self, *args, **kw):
        """
        CellToGridWindow(row, col) -> GridWindow
        CellToGridWindow(coords) -> GridWindow
        
        Returns the grid window that contains the cell.
        """

    def DevicePosToGridWindow(self, *args, **kw):
        """
        DevicePosToGridWindow(pos) -> GridWindow
        DevicePosToGridWindow(x, y) -> GridWindow
        
        Returns the grid window that includes the input coordinates.
        """

    def GetGridWindowOffset(self, gridWindow):
        """
        GetGridWindowOffset(gridWindow) -> wx.Point
        """

    def CalcGridWindowUnscrolledPosition(self, *args, **kw):
        """
        CalcGridWindowUnscrolledPosition(x, y, xx, yy, gridWindow)
        CalcGridWindowUnscrolledPosition(pt, gridWindow) -> wx.Point
        
        Translates the device coordinates to the logical ones, taking into
        account the grid window type.
        """

    def CalcGridWindowScrolledPosition(self, *args, **kw):
        """
        CalcGridWindowScrolledPosition(x, y, xx, yy, gridWindow)
        CalcGridWindowScrolledPosition(pt, gridWindow) -> wx.Point
        
        Translates the logical coordinates to the device ones, taking into
        account the grid window type.
        """

    def XToCol(self, x, clipToMinMax=False, gridWindow=None):
        """
        XToCol(x, clipToMinMax=False, gridWindow=None) -> int
        
        Returns the column at the given pixel position depending on the
        window.
        """

    def XToEdgeOfCol(self, x):
        """
        XToEdgeOfCol(x) -> int
        
        Returns the column whose right hand edge is close to the given logical
        x position.
        """

    def XYToCell(self, *args, **kw):
        """
        XYToCell(x, y, gridWindow=None) -> GridCellCoords
        XYToCell(pos, gridWindow=None) -> GridCellCoords
        
        Translates logical pixel coordinates to the grid cell coordinates.
        """

    def YToEdgeOfRow(self, y):
        """
        YToEdgeOfRow(y) -> int
        
        Returns the row whose bottom edge is close to the given logical y
        position.
        """

    def YToRow(self, y, clipToMinMax=False, gridWindow=None):
        """
        YToRow(y, clipToMinMax=False, gridWindow=None) -> int
        
        Returns the grid row that corresponds to the logical y coordinate.
        """

    def AppendCols(self, numCols=1, updateLabels=True):
        """
        AppendCols(numCols=1, updateLabels=True) -> bool
        
        Appends one or more new columns to the right of the grid.
        """

    def AppendRows(self, numRows=1, updateLabels=True):
        """
        AppendRows(numRows=1, updateLabels=True) -> bool
        
        Appends one or more new rows to the bottom of the grid.
        """

    def AreHorzGridLinesClipped(self):
        """
        AreHorzGridLinesClipped() -> bool
        
        Return true if the horizontal grid lines stop at the last column
        boundary or false if they continue to the end of the window.
        """

    def AreVertGridLinesClipped(self):
        """
        AreVertGridLinesClipped() -> bool
        
        Return true if the vertical grid lines stop at the last row boundary
        or false if they continue to the end of the window.
        """

    def BeginBatch(self):
        """
        BeginBatch()
        
        Increments the grid's batch count.
        """

    def ClearGrid(self):
        """
        ClearGrid()
        
        Clears all data in the underlying grid table and repaints the grid.
        """

    def ClipHorzGridLines(self, clip):
        """
        ClipHorzGridLines(clip)
        
        Change whether the horizontal grid lines are clipped by the end of the
        last column.
        """

    def ClipVertGridLines(self, clip):
        """
        ClipVertGridLines(clip)
        
        Change whether the vertical grid lines are clipped by the end of the
        last row.
        """

    def DeleteCols(self, pos=0, numCols=1, updateLabels=True):
        """
        DeleteCols(pos=0, numCols=1, updateLabels=True) -> bool
        
        Deletes one or more columns from a grid starting at the specified
        position.
        """

    def DeleteRows(self, pos=0, numRows=1, updateLabels=True):
        """
        DeleteRows(pos=0, numRows=1, updateLabels=True) -> bool
        
        Deletes one or more rows from a grid starting at the specified
        position.
        """

    def FreezeTo(self, *args, **kw):
        """
        FreezeTo(row, col) -> bool
        FreezeTo(coords) -> bool
        
        Sets or resets the frozen columns and rows.
        """

    def EndBatch(self):
        """
        EndBatch()
        
        Decrements the grid's batch count.
        """

    def Fit(self):
        """
        Fit()
        
        Overridden wxWindow method.
        """

    def ForceRefresh(self):
        """
        ForceRefresh()
        
        Causes immediate repainting of the grid.
        """

    def GetBatchCount(self):
        """
        GetBatchCount() -> int
        
        Returns the number of times that BeginBatch() has been called without
        (yet) matching calls to EndBatch().
        """

    def GetNumberCols(self):
        """
        GetNumberCols() -> int
        
        Returns the total number of grid columns.
        """

    def GetNumberRows(self):
        """
        GetNumberRows() -> int
        
        Returns the total number of grid rows.
        """

    def GetNumberFrozenCols(self):
        """
        GetNumberFrozenCols() -> int
        
        Returns the number of frozen grid columns.
        """

    def GetNumberFrozenRows(self):
        """
        GetNumberFrozenRows() -> int
        
        Returns the number of frozen grid rows.
        """

    def GetOrCreateCellAttr(self, row, col):
        """
        GetOrCreateCellAttr(row, col) -> GridCellAttr
        
        Returns the attribute for the given cell creating one if necessary.
        """

    def GetOrCreateCellAttrPtr(self, row, col):
        """
        GetOrCreateCellAttrPtr(row, col) -> GridCellAttrPtr
        
        Returns the attribute for the given cell creating one if necessary.
        """

    def GetTable(self):
        """
        GetTable() -> GridTableBase
        
        Returns a base pointer to the current table object.
        """

    def InsertCols(self, pos=0, numCols=1, updateLabels=True):
        """
        InsertCols(pos=0, numCols=1, updateLabels=True) -> bool
        
        Inserts one or more new columns into a grid with the first new column
        at the specified position.
        """

    def InsertRows(self, pos=0, numRows=1, updateLabels=True):
        """
        InsertRows(pos=0, numRows=1, updateLabels=True) -> bool
        
        Inserts one or more new rows into a grid with the first new row at the
        specified position.
        """

    def RefreshAttr(self, row, col):
        """
        RefreshAttr(row, col)
        
        Invalidates the cached attribute for the given cell.
        """

    def RefreshBlock(self, *args, **kw):
        """
        RefreshBlock(topLeft, bottomRight)
        RefreshBlock(topRow, leftCol, bottomRow, rightCol)
        
        Redraw all the cells in the given block.
        """

    def Render(self, dc, pos=wx.DefaultPosition, size=wx.DefaultSize, topLeft=GridCellCoords(-1,-1), bottomRight=GridCellCoords(-1,-1), style=GRID_DRAW_DEFAULT):
        """
        Render(dc, pos=wx.DefaultPosition, size=wx.DefaultSize, topLeft=GridCellCoords(-1,-1), bottomRight=GridCellCoords(-1,-1), style=GRID_DRAW_DEFAULT)
        
        Draws part or all of a wxGrid on a wxDC for printing or display.
        """

    def SetAttr(self, row, col, attr):
        """
        SetAttr(row, col, attr)
        
        Sets the cell attributes for the specified cell.
        """

    def SetColAttr(self, col, attr):
        """
        SetColAttr(col, attr)
        
        Sets the cell attributes for all cells in the specified column.
        """

    def SetMargins(self, extraWidth, extraHeight):
        """
        SetMargins(extraWidth, extraHeight)
        
        Sets the extra margins used around the grid area.
        """

    def SetRowAttr(self, row, attr):
        """
        SetRowAttr(row, attr)
        
        Sets the cell attributes for all cells in the specified row.
        """

    def CalcRowLabelsExposed(self, reg, gridWindow=None):
        """
        CalcRowLabelsExposed(reg, gridWindow=None) -> ArrayInt
        
        Returns an array of row labels within the given region.
        """

    def CalcColLabelsExposed(self, reg, gridWindow=None):
        """
        CalcColLabelsExposed(reg, gridWindow=None) -> ArrayInt
        
        Returns an array of column labels within the given region.
        """

    def CalcCellsExposed(self, reg, gridWindow=None):
        """
        CalcCellsExposed(reg, gridWindow=None) -> GridCellCoordsArray
        
        Returns an array of (visible) cells within the given region.
        """

    def GetSortingColumn(self):
        """
        GetSortingColumn() -> int
        
        Return the column in which the sorting indicator is currently
        displayed.
        """

    def IsSortingBy(self, col):
        """
        IsSortingBy(col) -> bool
        
        Return true if this column is currently used for sorting.
        """

    def IsSortOrderAscending(self):
        """
        IsSortOrderAscending() -> bool
        
        Return true if the current sorting order is ascending or false if it
        is descending.
        """

    def SetSortingColumn(self, col, ascending=True):
        """
        SetSortingColumn(col, ascending=True)
        
        Set the column to display the sorting indicator in and its direction.
        """

    def UnsetSortingColumn(self):
        """
        UnsetSortingColumn()
        
        Remove any currently shown sorting indicator.
        """

    def GetGridWindow(self):
        """
        GetGridWindow() -> wx.Window
        
        Return the main grid window containing the grid cells.
        """

    def GetFrozenCornerGridWindow(self):
        """
        GetFrozenCornerGridWindow() -> wx.Window
        
        Return the corner grid window containing frozen cells.
        """

    def GetFrozenRowGridWindow(self):
        """
        GetFrozenRowGridWindow() -> wx.Window
        
        Return the rows grid window containing row frozen cells.
        """

    def GetFrozenColGridWindow(self):
        """
        GetFrozenColGridWindow() -> wx.Window
        
        Return the columns grid window containing column frozen cells.
        """

    def GetGridRowLabelWindow(self):
        """
        GetGridRowLabelWindow() -> wx.Window
        
        Return the row labels window.
        """

    def GetGridColLabelWindow(self):
        """
        GetGridColLabelWindow() -> wx.Window
        
        Return the column labels window.
        """

    def GetGridCornerLabelWindow(self):
        """
        GetGridCornerLabelWindow() -> wx.Window
        
        Return the window in the top left grid corner.
        """

    def GetGridColHeader(self):
        """
        GetGridColHeader() -> wx.HeaderCtrl
        
        Return the header control used for column labels display.
        """

    def IsUsingNativeHeader(self):
        """
        IsUsingNativeHeader() -> bool
        
        Return true if native header control is currently being used.
        """

    def DrawCellHighlight(self, dc, attr):
        """
        DrawCellHighlight(dc, attr)
        """

    def DrawRowLabels(self, dc, rows):
        """
        DrawRowLabels(dc, rows)
        """

    def DrawRowLabel(self, dc, row):
        """
        DrawRowLabel(dc, row)
        """

    def DrawColLabels(self, dc, cols):
        """
        DrawColLabels(dc, cols)
        """

    def DrawColLabel(self, dc, col):
        """
        DrawColLabel(dc, col)
        """

    def DrawCornerLabel(self, dc):
        """
        DrawCornerLabel(dc)
        """

    def DrawTextRectangle(self, *args, **kw):
        """
        DrawTextRectangle(dc, text, rect, horizontalAlignment=wx.ALIGN_LEFT, verticalAlignment=wx.ALIGN_TOP, textOrientation=wx.HORIZONTAL)
        DrawTextRectangle(dc, lines, rect, horizontalAlignment=wx.ALIGN_LEFT, verticalAlignment=wx.ALIGN_TOP, textOrientation=wx.HORIZONTAL)
        """

    def GetCellHighlightColour(self):
        """
        GetCellHighlightColour() -> wx.Colour
        """

    def GetCellHighlightPenWidth(self):
        """
        GetCellHighlightPenWidth() -> int
        """

    def GetCellHighlightROPenWidth(self):
        """
        GetCellHighlightROPenWidth() -> int
        """

    def SetCellHighlightColour(self):
        """
        SetCellHighlightColour()
        """

    def SetCellHighlightPenWidth(self, width):
        """
        SetCellHighlightPenWidth(width)
        """

    def SetCellHighlightROPenWidth(self, width):
        """
        SetCellHighlightROPenWidth(width)
        """

    def SetGridFrozenBorderColour(self):
        """
        SetGridFrozenBorderColour()
        """

    def SetGridFrozenBorderPenWidth(self, width):
        """
        SetGridFrozenBorderPenWidth(width)
        """

    @staticmethod
    def GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL):
        """
        GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL) -> wx.VisualAttributes
        """

    def SetTable(self, table, takeOwnership=False, selmode=GridSelectCells):
        """
        Set the Grid Table to be used by this grid.
        """

    SelectCells = GridSelectCells
    SelectRows = GridSelectRows
    SelectColumns = GridSelectColumns
    SelectRowsOrColumns = GridSelectRowsOrColumns
    BatchCount = property(None, None)
    CellHighlightColour = property(None, None)
    CellHighlightPenWidth = property(None, None)
    CellHighlightROPenWidth = property(None, None)
    ColLabelSize = property(None, None)
    ColLabelTextOrientation = property(None, None)
    ColMinimalAcceptableWidth = property(None, None)
    ColSizes = property(None, None)
    CornerLabelTextOrientation = property(None, None)
    CornerLabelValue = property(None, None)
    DefaultCellBackgroundColour = property(None, None)
    DefaultCellFitMode = property(None, None)
    DefaultCellFont = property(None, None)
    DefaultCellOverflow = property(None, None)
    DefaultCellTextColour = property(None, None)
    DefaultColLabelSize = property(None, None)
    DefaultColSize = property(None, None)
    DefaultEditor = property(None, None)
    DefaultGridLinePen = property(None, None)
    DefaultRenderer = property(None, None)
    DefaultRowLabelSize = property(None, None)
    DefaultRowSize = property(None, None)
    FirstFullyVisibleColumn = property(None, None)
    FirstFullyVisibleRow = property(None, None)
    FrozenColGridWindow = property(None, None)
    FrozenCornerGridWindow = property(None, None)
    FrozenRowGridWindow = property(None, None)
    GridColHeader = property(None, None)
    GridColLabelWindow = property(None, None)
    GridCornerLabelWindow = property(None, None)
    GridCursorCol = property(None, None)
    GridCursorCoords = property(None, None)
    GridCursorRow = property(None, None)
    GridLineColour = property(None, None)
    GridRowLabelWindow = property(None, None)
    GridWindow = property(None, None)
    LabelBackgroundColour = property(None, None)
    LabelFont = property(None, None)
    LabelTextColour = property(None, None)
    NumberCols = property(None, None)
    NumberFrozenCols = property(None, None)
    NumberFrozenRows = property(None, None)
    NumberRows = property(None, None)
    RowLabelSize = property(None, None)
    RowMinimalAcceptableHeight = property(None, None)
    RowSizes = property(None, None)
    ScrollLineX = property(None, None)
    ScrollLineY = property(None, None)
    SelectedBlocks = property(None, None)
    SelectedCells = property(None, None)
    SelectedColBlocks = property(None, None)
    SelectedCols = property(None, None)
    SelectedRowBlocks = property(None, None)
    SelectedRows = property(None, None)
    SelectionBackground = property(None, None)
    SelectionBlockBottomRight = property(None, None)
    SelectionBlockTopLeft = property(None, None)
    SelectionForeground = property(None, None)
    SelectionMode = property(None, None)
    SortingColumn = property(None, None)
    Table = property(None, None)

    def CanHaveAttributes(self):
        """
        CanHaveAttributes() -> bool
        
        Returns true if this grid has support for cell attributes.
        """

    def GetColMinimalWidth(self, col):
        """
        GetColMinimalWidth(col) -> int
        
        Get the minimal width of the given column/row.
        """

    def GetColRight(self, col):
        """
        GetColRight(col) -> int
        
        Returns the coordinate of the right border specified column.
        """

    def GetColLeft(self, col):
        """
        GetColLeft(col) -> int
        
        Returns the coordinate of the left border specified column.
        """

    def GetRowMinimalHeight(self, col):
        """
        GetRowMinimalHeight(col) -> int
        
        Returns the minimal size for the given column.
        """
# end of class Grid


class GridUpdateLocker(object):
    """
    GridUpdateLocker(grid=None)
    
    This small class can be used to prevent wxGrid from redrawing during
    its lifetime by calling wxGrid::BeginBatch() in its constructor and
    wxGrid::EndBatch() in its destructor.
    """

    def __init__(self, grid=None):
        """
        GridUpdateLocker(grid=None)
        
        This small class can be used to prevent wxGrid from redrawing during
        its lifetime by calling wxGrid::BeginBatch() in its constructor and
        wxGrid::EndBatch() in its destructor.
        """

    def Create(self, grid):
        """
        Create(grid)
        
        This method can be called if the object had been constructed using the
        default constructor.
        """

    def __enter__(self):
        """
        
        """

    def __exit__(self, exc_type, exc_val, exc_tb):
        """
        
        """
# end of class GridUpdateLocker


class GridEvent(wx.NotifyEvent):
    """
    GridEvent()
    GridEvent(id, type, obj, row=-1, col=-1, x=-1, y=-1, sel=True, kbd=wx.KeyboardState())
    
    This event class contains information about various grid events.
    """

    def __init__(self, *args, **kw):
        """
        GridEvent()
        GridEvent(id, type, obj, row=-1, col=-1, x=-1, y=-1, sel=True, kbd=wx.KeyboardState())
        
        This event class contains information about various grid events.
        """

    def AltDown(self):
        """
        AltDown() -> bool
        
        Returns true if the Alt key was down at the time of the event.
        """

    def ControlDown(self):
        """
        ControlDown() -> bool
        
        Returns true if the Control key was down at the time of the event.
        """

    def GetCol(self):
        """
        GetCol() -> int
        
        Column at which the event occurred.
        """

    def GetPosition(self):
        """
        GetPosition() -> wx.Point
        
        Position in pixels at which the event occurred.
        """

    def GetRow(self):
        """
        GetRow() -> int
        
        Row at which the event occurred.
        """

    def MetaDown(self):
        """
        MetaDown() -> bool
        
        Returns true if the Meta key was down at the time of the event.
        """

    def Selecting(self):
        """
        Selecting() -> bool
        
        Returns true if the user is selecting grid cells, or false if
        deselecting.
        """

    def ShiftDown(self):
        """
        ShiftDown() -> bool
        
        Returns true if the Shift key was down at the time of the event.
        """
    Col = property(None, None)
    Position = property(None, None)
    Row = property(None, None)
# end of class GridEvent


class GridSizeEvent(wx.NotifyEvent):
    """
    GridSizeEvent()
    GridSizeEvent(id, type, obj, rowOrCol=-1, x=-1, y=-1, kbd=wx.KeyboardState())
    
    This event class contains information about a row/column resize event.
    """

    def __init__(self, *args, **kw):
        """
        GridSizeEvent()
        GridSizeEvent(id, type, obj, rowOrCol=-1, x=-1, y=-1, kbd=wx.KeyboardState())
        
        This event class contains information about a row/column resize event.
        """

    def AltDown(self):
        """
        AltDown() -> bool
        
        Returns true if the Alt key was down at the time of the event.
        """

    def ControlDown(self):
        """
        ControlDown() -> bool
        
        Returns true if the Control key was down at the time of the event.
        """

    def GetPosition(self):
        """
        GetPosition() -> wx.Point
        
        Position in pixels at which the event occurred.
        """

    def GetRowOrCol(self):
        """
        GetRowOrCol() -> int
        
        Row or column at that was resized.
        """

    def MetaDown(self):
        """
        MetaDown() -> bool
        
        Returns true if the Meta key was down at the time of the event.
        """

    def ShiftDown(self):
        """
        ShiftDown() -> bool
        
        Returns true if the Shift key was down at the time of the event.
        """
    Position = property(None, None)
    RowOrCol = property(None, None)
# end of class GridSizeEvent


class GridRangeSelectEvent(wx.NotifyEvent):
    """
    GridRangeSelectEvent()
    GridRangeSelectEvent(id, type, obj, topLeft, bottomRight, sel=True, kbd=wx.KeyboardState())
    
    Events of this class notify about a range of cells being selected.
    """

    def __init__(self, *args, **kw):
        """
        GridRangeSelectEvent()
        GridRangeSelectEvent(id, type, obj, topLeft, bottomRight, sel=True, kbd=wx.KeyboardState())
        
        Events of this class notify about a range of cells being selected.
        """

    def AltDown(self):
        """
        AltDown() -> bool
        
        Returns true if the Alt key was down at the time of the event.
        """

    def ControlDown(self):
        """
        ControlDown() -> bool
        
        Returns true if the Control key was down at the time of the event.
        """

    def GetBottomRightCoords(self):
        """
        GetBottomRightCoords() -> GridCellCoords
        
        Top left corner of the rectangular area that was (de)selected.
        """

    def GetBottomRow(self):
        """
        GetBottomRow() -> int
        
        Bottom row of the rectangular area that was (de)selected.
        """

    def GetLeftCol(self):
        """
        GetLeftCol() -> int
        
        Left column of the rectangular area that was (de)selected.
        """

    def GetRightCol(self):
        """
        GetRightCol() -> int
        
        Right column of the rectangular area that was (de)selected.
        """

    def GetTopLeftCoords(self):
        """
        GetTopLeftCoords() -> GridCellCoords
        
        Top left corner of the rectangular area that was (de)selected.
        """

    def GetTopRow(self):
        """
        GetTopRow() -> int
        
        Top row of the rectangular area that was (de)selected.
        """

    def MetaDown(self):
        """
        MetaDown() -> bool
        
        Returns true if the Meta key was down at the time of the event.
        """

    def Selecting(self):
        """
        Selecting() -> bool
        
        Returns true if the area was selected, false otherwise.
        """

    def ShiftDown(self):
        """
        ShiftDown() -> bool
        
        Returns true if the Shift key was down at the time of the event.
        """
    BottomRightCoords = property(None, None)
    BottomRow = property(None, None)
    LeftCol = property(None, None)
    RightCol = property(None, None)
    TopLeftCoords = property(None, None)
    TopRow = property(None, None)
# end of class GridRangeSelectEvent


class GridEditorCreatedEvent(wx.CommandEvent):
    """
    GridEditorCreatedEvent()
    GridEditorCreatedEvent(id, type, obj, row, col, ctrl)
    
    ^^
    """

    def __init__(self, *args, **kw):
        """
        GridEditorCreatedEvent()
        GridEditorCreatedEvent(id, type, obj, row, col, ctrl)
        
        ^^
        """

    def GetCol(self):
        """
        GetCol() -> int
        
        Returns the column at which the event occurred.
        """

    def GetControl(self):
        """
        GetControl() -> wx.Control
        
        Returns the edit control.
        """

    def GetRow(self):
        """
        GetRow() -> int
        
        Returns the row at which the event occurred.
        """

    def GetWindow(self):
        """
        GetWindow() -> wx.Window
        
        Returns the edit window.
        """

    def SetCol(self, col):
        """
        SetCol(col)
        
        Sets the column at which the event occurred.
        """

    def SetControl(self, ctrl):
        """
        SetControl(ctrl)
        
        Sets the edit control.
        """

    def SetRow(self, row):
        """
        SetRow(row)
        
        Sets the row at which the event occurred.
        """

    def SetWindow(self, window):
        """
        SetWindow(window)
        
        Sets the edit window.
        """
    Col = property(None, None)
    Control = property(None, None)
    Row = property(None, None)
    Window = property(None, None)
# end of class GridEditorCreatedEvent


GRID_VALUE_STRING =    "string"
GRID_VALUE_BOOL =      "bool"
GRID_VALUE_NUMBER =    "long"
GRID_VALUE_FLOAT =     "double"
GRID_VALUE_CHOICE =    "choice"
GRID_VALUE_DATE =      "date"
GRID_VALUE_TEXT =      "string"
GRID_VALUE_LONG =      "long"
GRID_VALUE_CHOICEINT = "choiceint"
GRID_VALUE_DATETIME =  "datetime"

GRIDTABLE_REQUEST_VIEW_GET_VALUES = 2000
GRIDTABLE_REQUEST_VIEW_SEND_VALUES = 2001

from collections import namedtuple
_im_GridCellCoords = namedtuple('_im_GridCellCoords', ['Row', 'Col'])
del namedtuple

PyGridCellRenderer = wx.deprecated(GridCellRenderer, 'Use GridCellRenderer instead.')

PyGridCellEditor = wx.deprecated(GridCellEditor, 'Use GridCellEditor instead.')

PyGridCellAttrProvider = wx.deprecated(GridCellAttrProvider, 'Use GridCellAttrProvider instead.')

PyGridTableBase = wx.deprecated(GridTableBase, 'Use GridTableBase instead.')

EVT_GRID_CELL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK )
EVT_GRID_CELL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK )
EVT_GRID_CELL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK )
EVT_GRID_CELL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK )
EVT_GRID_LABEL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK )
EVT_GRID_LABEL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK )
EVT_GRID_LABEL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK )
EVT_GRID_LABEL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK )
EVT_GRID_ROW_SIZE = wx.PyEventBinder( wxEVT_GRID_ROW_SIZE )
EVT_GRID_COL_SIZE = wx.PyEventBinder( wxEVT_GRID_COL_SIZE )
EVT_GRID_COL_AUTO_SIZE = wx.PyEventBinder( wxEVT_GRID_COL_AUTO_SIZE )
EVT_GRID_RANGE_SELECTING = wx.PyEventBinder( wxEVT_GRID_RANGE_SELECTING )
EVT_GRID_RANGE_SELECTED = wx.PyEventBinder( wxEVT_GRID_RANGE_SELECTED )
EVT_GRID_CELL_CHANGING = wx.PyEventBinder( wxEVT_GRID_CELL_CHANGING )
EVT_GRID_CELL_CHANGED = wx.PyEventBinder( wxEVT_GRID_CELL_CHANGED )
EVT_GRID_SELECT_CELL = wx.PyEventBinder( wxEVT_GRID_SELECT_CELL )
EVT_GRID_EDITOR_SHOWN = wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN )
EVT_GRID_EDITOR_HIDDEN = wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN )
EVT_GRID_EDITOR_CREATED = wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED )
EVT_GRID_CELL_BEGIN_DRAG = wx.PyEventBinder( wxEVT_GRID_CELL_BEGIN_DRAG )
EVT_GRID_ROW_MOVE = wx.PyEventBinder( wxEVT_GRID_ROW_MOVE )
EVT_GRID_COL_MOVE = wx.PyEventBinder( wxEVT_GRID_COL_MOVE )
EVT_GRID_COL_SORT = wx.PyEventBinder( wxEVT_GRID_COL_SORT )
EVT_GRID_TABBING = wx.PyEventBinder( wxEVT_GRID_TABBING )

# The same as above but with the ability to specify an identifier
EVT_GRID_CMD_CELL_LEFT_CLICK =     wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK,    1 )
EVT_GRID_CMD_CELL_RIGHT_CLICK =    wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK,   1 )
EVT_GRID_CMD_CELL_LEFT_DCLICK =    wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK,   1 )
EVT_GRID_CMD_CELL_RIGHT_DCLICK =   wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK,  1 )
EVT_GRID_CMD_LABEL_LEFT_CLICK =    wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK,   1 )
EVT_GRID_CMD_LABEL_RIGHT_CLICK =   wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK,  1 )
EVT_GRID_CMD_LABEL_LEFT_DCLICK =   wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK,  1 )
EVT_GRID_CMD_LABEL_RIGHT_DCLICK =  wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK, 1 )
EVT_GRID_CMD_ROW_SIZE =            wx.PyEventBinder( wxEVT_GRID_ROW_SIZE,           1 )
EVT_GRID_CMD_COL_SIZE =            wx.PyEventBinder( wxEVT_GRID_COL_SIZE,           1 )
EVT_GRID_CMD_COL_AUTO_SIZE =       wx.PyEventBinder( wxEVT_GRID_COL_AUTO_SIZE,      1 )
EVT_GRID_CMD_RANGE_SELECTING =     wx.PyEventBinder( wxEVT_GRID_RANGE_SELECTING,    1 )
EVT_GRID_CMD_RANGE_SELECTED =      wx.PyEventBinder( wxEVT_GRID_RANGE_SELECTED,     1 )
EVT_GRID_CMD_CELL_CHANGING =       wx.PyEventBinder( wxEVT_GRID_CELL_CHANGING,      1 )
EVT_GRID_CMD_CELL_CHANGED =        wx.PyEventBinder( wxEVT_GRID_CELL_CHANGED,       1 )
EVT_GRID_CMD_SELECT_CELL =         wx.PyEventBinder( wxEVT_GRID_SELECT_CELL,        1 )
EVT_GRID_CMD_EDITOR_SHOWN =        wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN,       1 )
EVT_GRID_CMD_EDITOR_HIDDEN =       wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN,      1 )
EVT_GRID_CMD_EDITOR_CREATED =      wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED,     1 )
EVT_GRID_CMD_CELL_BEGIN_DRAG =     wx.PyEventBinder( wxEVT_GRID_CELL_BEGIN_DRAG,    1 )
EVT_GRID_CMD_ROW_MOVE =            wx.PyEventBinder( wxEVT_GRID_ROW_MOVE,           1 )
EVT_GRID_CMD_COL_MOVE =            wx.PyEventBinder( wxEVT_GRID_COL_MOVE,           1 )
EVT_GRID_CMD_COL_SORT =            wx.PyEventBinder( wxEVT_GRID_COL_SORT,           1 )
EVT_GRID_CMD_TABBING =             wx.PyEventBinder( wxEVT_GRID_TABBING,            1 )

# Just for compatibility, remove them in a future release
EVT_GRID_RANGE_SELECT =            EVT_GRID_RANGE_SELECTED
EVT_GRID_CMD_RANGE_SELECT =        EVT_GRID_CMD_RANGE_SELECTED
wxEVT_GRID_RANGE_SELECT =          wxEVT_GRID_RANGE_SELECTED
#-- end-grid --#
