sip/gen/sizer.sip

//---------------------------------------------------------------------------
// This file is generated by wxPython's SIP generator.  Do not edit by hand.
//
// Copyright: (c) 2018 by Total Control Software
// License:   wxWindows License
//
// This file will be included by _core.sip
//
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

enum wxFlexSizerGrowMode
{
    wxFLEX_GROWMODE_NONE,
    wxFLEX_GROWMODE_SPECIFIED,
    wxFLEX_GROWMODE_ALL
};

class wxSizerItem : wxObject
{
    %Docstring
        SizerItem(window, flags)
        SizerItem(window, proportion=0, flag=0, border=0, userData=None)
        SizerItem(sizer, flags)
        SizerItem(sizer, proportion=0, flag=0, border=0, userData=None)
        SizerItem(width, height, proportion=0, flag=0, border=0, userData=None)

        The wxSizerItem class is used to track the position, size and other
        attributes of each item managed by a wxSizer.
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxSizerItem(
        wxWindow * window,
        const wxSizerFlags & flags
    );

    wxSizerItem(
        wxWindow * window,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem(
        wxSizer * sizer   /Transfer/,
        const wxSizerFlags & flags
    );

    wxSizerItem(
        wxSizer * sizer   /Transfer/,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem(
        int width,
        int height,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    ~wxSizerItem();

    void AssignSpacer(
        const wxSize & size
    );
    %Docstring
        AssignSpacer(size)
        AssignSpacer(w, h)

        Set the size of the spacer tracked by this item.
    %End

    void AssignSpacer(
        int w,
        int h
    );

    void SetRatio(
        int width,
        int height
    );
    %Docstring
        SetRatio(width, height)
        SetRatio(size)
        SetRatio(ratio)

        Set the ratio item attribute.
    %End

    void SetRatio(
        wxSize size
    );

    void SetRatio(
        float ratio
    );

    void AssignWindow(
        wxWindow * window
    );
    %Docstring
        AssignWindow(window)

        Set the window to be tracked by this item.
    %End

    void AssignSizer(
        wxSizer * sizer   /Transfer/
    );
    %Docstring
        AssignSizer(sizer)

        Set the sizer tracked by this item.
    %End

    wxSize CalcMin();
    %Docstring
        CalcMin() -> Size

        Calculates the minimum desired size for the item, including any space
        needed by borders.
    %End

    void DeleteWindows();
    %Docstring
        DeleteWindows()

        Destroy the window or the windows in a subsizer, depending on the type
        of item.
    %End

    void DetachSizer();
    %Docstring
        DetachSizer()

        Enable deleting the SizerItem without destroying the contained sizer.
    %End

    int GetBorder() const;
    %Docstring
        GetBorder() -> int

        Return the border attribute.
    %End

    int GetFlag() const;
    %Docstring
        GetFlag() -> int

        Return the flags attribute.
    %End

    int GetId() const;
    %Docstring
        GetId() -> int

        Return the numeric id of wxSizerItem, or wxID_NONE if the id has not
        been set.
    %End

    wxSize GetMinSize() const;
    %Docstring
        GetMinSize() -> Size

        Get the minimum size needed for the item.
    %End

    void SetMinSize(
        const wxSize & size
    );
    %Docstring
        SetMinSize(size)
        SetMinSize(x, y)

        Sets the minimum size to be allocated for this item.
    %End

    void SetMinSize(
        int x,
        int y
    );

    wxPoint GetPosition() const;
    %Docstring
        GetPosition() -> Point

        What is the current position of the item, as set in the last Layout.
    %End

    int GetProportion() const;
    %Docstring
        GetProportion() -> int

        Get the proportion item attribute.
    %End

    float GetRatio() const;
    %Docstring
        GetRatio() -> float

        Get the ration item attribute.
    %End

    wxRect GetRect();
    %Docstring
        GetRect() -> Rect

        Get the rectangle of the item on the parent window, excluding borders.
    %End

    wxSize GetSize() const;
    %Docstring
        GetSize() -> Size

        Get the current size of the item, as set in the last Layout.
    %End

    wxSizer * GetSizer() const;
    %Docstring
        GetSizer() -> Sizer

        If this item is tracking a sizer, return it.
    %End

    wxSize GetSpacer() const;
    %Docstring
        GetSpacer() -> Size

        If this item is tracking a spacer, return its size.
    %End

    wxPyUserData* GetUserData() const;
    %Docstring
        GetUserData() -> PyUserData

        Get the userData item attribute.
    %End
    %MethodCode
        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxSizerItem_GetUserData(sipCpp);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;
    %End
    %TypeCode
    wxPyUserData* _wxSizerItem_GetUserData(const wxSizerItem* self)
    {
        return dynamic_cast<wxPyUserData*>(self->GetUserData());
    }
    %End

    wxWindow * GetWindow() const;
    %Docstring
        GetWindow() -> Window

        If this item is tracking a window then return it.
    %End

    bool IsShown() const;
    %Docstring
        IsShown() -> bool

        Returns true if this item is a window or a spacer and it is shown or
        if this item is a sizer and not all of its elements are hidden.
    %End

    bool IsSizer() const;
    %Docstring
        IsSizer() -> bool

        Is this item a sizer?
    %End

    bool IsSpacer() const;
    %Docstring
        IsSpacer() -> bool

        Is this item a spacer?
    %End

    bool IsWindow() const;
    %Docstring
        IsWindow() -> bool

        Is this item a window?
    %End

    void SetBorder(
        int border
    );
    %Docstring
        SetBorder(border)

        Set the border item attribute.
    %End

    void SetDimension(
        const wxPoint & pos,
        const wxSize & size
    );
    %Docstring
        SetDimension(pos, size)

        Set the position and size of the space allocated to the sizer, and
        adjust the position and size of the item to be within that space
        taking alignment and borders into account.
    %End

    void SetFlag(
        int flag
    );
    %Docstring
        SetFlag(flag)

        Set the flag item attribute.
    %End

    void SetId(
        int id
    );
    %Docstring
        SetId(id)

        Sets the numeric id of the wxSizerItem to id.
    %End

    void SetInitSize(
        int x,
        int y
    );
    %Docstring
        SetInitSize(x, y)
    %End

    void SetProportion(
        int proportion
    );
    %Docstring
        SetProportion(proportion)

        Set the proportion item attribute.
    %End

    void SetUserData(
        wxPyUserData* userData   /Transfer/
    );
    %Docstring
        SetUserData(userData)
    %End

    void Show(
        bool show
    );
    %Docstring
        Show(show)

        Set the show item attribute, which sizers use to determine if the item
        is to be made part of the layout or not.
    %End

    private:
        wxSizerItem(const wxSizerItem&);


    public:


    %Property(name=Border, get=GetBorder, set=SetBorder)
    %Property(name=Flag, get=GetFlag, set=SetFlag)
    %Property(name=Id, get=GetId, set=SetId)
    %Property(name=MinSize, get=GetMinSize, set=SetMinSize)
    %Property(name=Position, get=GetPosition)
    %Property(name=Proportion, get=GetProportion, set=SetProportion)
    %Property(name=Ratio, get=GetRatio, set=SetRatio)
    %Property(name=Rect, get=GetRect)
    %Property(name=Size, get=GetSize)
    %Property(name=Sizer, get=GetSizer)
    %Property(name=Spacer, get=GetSpacer)
    %Property(name=UserData, get=GetUserData, set=SetUserData)
    %Property(name=Window, get=GetWindow)
};  // end of class wxSizerItem


class wxSizerFlags
{
    %Docstring
        SizerFlags(proportion=0)

        Container for sizer items flags providing readable names for them.
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxSizerFlags(
        int proportion = 0
    );

    wxSizerFlags & Align(
        int alignment
    );
    %Docstring
        Align(alignment) -> SizerFlags

        Sets the alignment of this wxSizerFlags to align.
    %End

    wxSizerFlags & Border(
        int direction,
        int borderinpixels
    );
    %Docstring
        Border(direction, borderinpixels) -> SizerFlags
        Border(direction=ALL) -> SizerFlags

        Sets the wxSizerFlags to have a border of a number of pixels specified
        by borderinpixels with the directions specified by direction.
    %End

    wxSizerFlags & Border(
        int direction = wxALL
    );

    wxSizerFlags & Bottom();
    %Docstring
        Bottom() -> SizerFlags

        Aligns the object to the bottom, similar for Align(wxALIGN_BOTTOM).
    %End

    wxSizerFlags & Center();
    %Docstring
        Center() -> SizerFlags

        Sets the object of the wxSizerFlags to center itself in the area it is
        given.
    %End

    wxSizerFlags & Centre();
    %Docstring
        Centre() -> SizerFlags

        Center() for people with the other dialect of English.
    %End

    wxSizerFlags & DoubleBorder(
        int direction = wxALL
    );
    %Docstring
        DoubleBorder(direction=ALL) -> SizerFlags

        Sets the border in the given direction having twice the default border
        size.
    %End

    wxSizerFlags & DoubleHorzBorder();
    %Docstring
        DoubleHorzBorder() -> SizerFlags

        Sets the border in left and right directions having twice the default
        border size.
    %End

    wxSizerFlags & Expand();
    %Docstring
        Expand() -> SizerFlags

        Sets the object of the wxSizerFlags to expand to fill as much area as
        it can.
    %End

    wxSizerFlags & FixedMinSize();
    %Docstring
        FixedMinSize() -> SizerFlags

        Set the wxFIXED_MINSIZE flag which indicates that the initial size of
        the window should be also set as its minimal size.
    %End

    wxSizerFlags & ReserveSpaceEvenIfHidden();
    %Docstring
        ReserveSpaceEvenIfHidden() -> SizerFlags

        Set the wxRESERVE_SPACE_EVEN_IF_HIDDEN flag.
    %End

    wxSizerFlags & Left();
    %Docstring
        Left() -> SizerFlags

        Aligns the object to the left, similar for Align(wxALIGN_LEFT).
    %End

    wxSizerFlags & Proportion(
        int proportion
    );
    %Docstring
        Proportion(proportion) -> SizerFlags

        Sets the proportion of this wxSizerFlags to proportion.
    %End

    wxSizerFlags & Right();
    %Docstring
        Right() -> SizerFlags

        Aligns the object to the right, similar for Align(wxALIGN_RIGHT).
    %End

    wxSizerFlags & Shaped();
    %Docstring
        Shaped() -> SizerFlags

        Set the wx_SHAPED flag which indicates that the elements should always
        keep the fixed width to height ratio equal to its original value.
    %End

    wxSizerFlags & Top();
    %Docstring
        Top() -> SizerFlags

        Aligns the object to the top, similar for Align(wxALIGN_TOP).
    %End

    wxSizerFlags & TripleBorder(
        int direction = wxALL
    );
    %Docstring
        TripleBorder(direction=ALL) -> SizerFlags

        Sets the border in the given direction having thrice the default
        border size.
    %End

    static
    int GetDefaultBorder();
    %Docstring
        GetDefaultBorder() -> int

        Returns the border used by default in Border() method.
    %End

};  // end of class wxSizerFlags


class wxSizer : wxObject
{
    %Docstring
        Sizer()

        wxSizer is the abstract base class used for laying out subwindows in a
        window.
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxSizer();

    ~wxSizer();

    wxSizerItemList & GetChildren()   /NoCopy/;
    %Docstring
        GetChildren() -> SizerItemList

        Returns the list of the items in this sizer.
    %End

    bool SetItemMinSize(
        wxWindow * window,
        int width,
        int height
    );
    %Docstring
        SetItemMinSize(window, width, height) -> bool
        SetItemMinSize(window, size) -> bool
        SetItemMinSize(sizer, width, height) -> bool
        SetItemMinSize(sizer, size) -> bool
        SetItemMinSize(index, width, height) -> bool
        SetItemMinSize(index, size) -> bool

        Set an item's minimum size by window, sizer, or position.
    %End

    bool SetItemMinSize(
        wxWindow * window,
        const wxSize & size
    );

    bool SetItemMinSize(
        wxSizer * sizer,
        int width,
        int height
    );

    bool SetItemMinSize(
        wxSizer * sizer,
        const wxSize & size
    );

    bool SetItemMinSize(
        size_t index,
        int width,
        int height
    );

    bool SetItemMinSize(
        size_t index,
        const wxSize & size
    );

    wxSizerItem * Add(
        wxWindow * window,
        const wxSizerFlags & flags
    );
    %Docstring
        Add(window, flags) -> SizerItem
        Add(window, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Add(sizer, flags) -> SizerItem
        Add(sizer, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Add(width, height, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Add(width, height, flags) -> SizerItem
        Add(item) -> SizerItem
        Add(size, proportion=0, flag=0, border=0, /Transfer/=None) -> SizerItem
        Add(size, flags) -> SizerItem

        Appends a child to the sizer.
    %End

    wxSizerItem * Add(
        wxWindow * window,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Add(
        wxSizer * sizer   /Transfer/,
        const wxSizerFlags & flags
    );

    wxSizerItem * Add(
        wxSizer * sizer   /Transfer/,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Add(
        int width,
        int height,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Add(
        int width,
        int height,
        const wxSizerFlags & flags
    );

    wxSizerItem * Add(
        wxSizerItem * item   /Transfer/
    );

    wxSizerItem* Add(const wxSize& size,  int proportion=0,  int flag=0,  int border=0,  wxPyUserData* userData /Transfer/ = NULL);
    %MethodCode
        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxSizer_Add(sipCpp, size, proportion, flag, border, userData);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;
    %End
    %TypeCode
    wxSizerItem* _wxSizer_Add(wxSizer* self, const wxSize* size, int proportion, int flag, int border, wxPyUserData* userData )
    {
        return self->Add(size->x, size->y, proportion, flag, border, userData);
    }
    %End

    wxSizerItem* Add(const wxSize& size,  const wxSizerFlags& flags);
    %MethodCode
        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxSizer_Add(sipCpp, size, flags);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;
    %End
    %TypeCode
    wxSizerItem* _wxSizer_Add(wxSizer* self, const wxSize* size, const wxSizerFlags* flags)
    {
        return self->Add(size->x, size->y, *flags);
    }
    %End

    wxSizerItem * AddSpacer(
        int size
    );
    %Docstring
        AddSpacer(size) -> SizerItem

        This base function adds non-stretchable space to both the horizontal
        and vertical orientation of the sizer.
    %End

    wxSizerItem * AddStretchSpacer(
        int prop = 1
    );
    %Docstring
        AddStretchSpacer(prop=1) -> SizerItem

        Adds stretchable space to the sizer.
    %End

    virtual
    wxSize CalcMin() = 0;
    %Docstring
        CalcMin() -> Size

        This method is abstract and has to be overwritten by any derived
        class.
    %End

    void Clear(
        bool delete_windows = false
    );
    %Docstring
        Clear(delete_windows=False)

        Detaches all children from the sizer.
    %End

    wxSize ComputeFittingClientSize(
        wxWindow * window
    );
    %Docstring
        ComputeFittingClientSize(window) -> Size

        Computes client area size for window so that it matches the sizer's
        minimal size.
    %End

    wxSize ComputeFittingWindowSize(
        wxWindow * window
    );
    %Docstring
        ComputeFittingWindowSize(window) -> Size

        Like ComputeFittingClientSize(), but converts the result into window
        size.
    %End

    bool Detach(
        wxWindow * window
    );
    %Docstring
        Detach(window) -> bool
        Detach(sizer) -> bool
        Detach(index) -> bool

        Detach the child window from the sizer without destroying it.
    %End

    bool Detach(
        wxSizer * sizer
    );

    bool Detach(
        int index
    );

    wxSize Fit(
        wxWindow * window
    );
    %Docstring
        Fit(window) -> Size

        Tell the sizer to resize the window so that its client area matches
        the sizer's minimal size (ComputeFittingClientSize() is called to
        determine it).
    %End

    void FitInside(
        wxWindow * window
    );
    %Docstring
        FitInside(window)

        Tell the sizer to resize the virtual size of the window to match the
        sizer's minimal size.
    %End

    bool InformFirstDirection(
        int direction,
        int size,
        int availableOtherDir
    );
    %Docstring
        InformFirstDirection(direction, size, availableOtherDir) -> bool

        Inform sizer about the first direction that has been decided (by
        parent item).
    %End

    wxWindow * GetContainingWindow() const;
    %Docstring
        GetContainingWindow() -> Window

        Returns the window this sizer is used in or NULL if none.
    %End

    void SetContainingWindow(
        wxWindow * window
    );
    %Docstring
        SetContainingWindow(window)

        Set the window this sizer is used in.
    %End

    size_t GetItemCount() const;
    %Docstring
        GetItemCount() -> size_t

        Returns the number of items in the sizer.
    %End

    wxSizerItem * GetItem(
        wxWindow * window,
        bool recursive = false
    );
    %Docstring
        GetItem(window, recursive=False) -> SizerItem
        GetItem(sizer, recursive=False) -> SizerItem
        GetItem(index) -> SizerItem

        Finds wxSizerItem which holds the given window.
    %End

    wxSizerItem * GetItem(
        wxSizer * sizer,
        bool recursive = false
    );

    wxSizerItem * GetItem(
        size_t index
    );

    wxSizerItem * GetItemById(
        int id,
        bool recursive = false
    );
    %Docstring
        GetItemById(id, recursive=False) -> SizerItem

        Finds item of the sizer which has the given id.
    %End

    wxSize GetMinSize();
    %Docstring
        GetMinSize() -> Size

        Returns the minimal size of the sizer.
    %End

    wxPoint GetPosition() const;
    %Docstring
        GetPosition() -> Point

        Returns the current position of the sizer.
    %End

    wxSize GetSize() const;
    %Docstring
        GetSize() -> Size

        Returns the current size of the sizer.
    %End

    bool Hide(
        wxWindow * window,
        bool recursive = false
    );
    %Docstring
        Hide(window, recursive=False) -> bool
        Hide(sizer, recursive=False) -> bool
        Hide(index) -> bool

        Hides the child window.
    %End

    bool Hide(
        wxSizer * sizer,
        bool recursive = false
    );

    bool Hide(
        size_t index
    );

    wxSizerItem * Insert(
        size_t index,
        wxWindow * window,
        const wxSizerFlags & flags
    );
    %Docstring
        Insert(index, window, flags) -> SizerItem
        Insert(index, window, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Insert(index, sizer, flags) -> SizerItem
        Insert(index, sizer, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Insert(index, width, height, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Insert(index, width, height, flags) -> SizerItem
        Insert(index, item) -> SizerItem
        Insert(index, size, proportion=0, flag=0, border=0, /Transfer/=None) -> SizerItem
        Insert(index, size, flags) -> SizerItem

        Insert a child into the sizer before any existing item at index.
    %End

    wxSizerItem * Insert(
        size_t index,
        wxWindow * window,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Insert(
        size_t index,
        wxSizer * sizer   /Transfer/,
        const wxSizerFlags & flags
    );

    wxSizerItem * Insert(
        size_t index,
        wxSizer * sizer   /Transfer/,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Insert(
        size_t index,
        int width,
        int height,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Insert(
        size_t index,
        int width,
        int height,
        const wxSizerFlags & flags
    );

    wxSizerItem * Insert(
        size_t index,
        wxSizerItem * item   /Transfer/
    );

    wxSizerItem* Insert(ulong index,  const wxSize& size,  int proportion=0,  int flag=0,  int border=0,  wxPyUserData* userData /Transfer/ = NULL);
    %MethodCode
        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxSizer_Insert(sipCpp, index, size, proportion, flag, border, userData);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;
    %End
    %TypeCode
    wxSizerItem* _wxSizer_Insert(wxSizer* self, ulong index, const wxSize* size, int proportion, int flag, int border, wxPyUserData* userData )
    {
        return self->Insert(index, size->x, size->y, proportion, flag, border, userData);
    }
    %End

    wxSizerItem* Insert(ulong index,  const wxSize& size,  const wxSizerFlags& flags);
    %MethodCode
        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxSizer_Insert(sipCpp, index, size, flags);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;
    %End
    %TypeCode
    wxSizerItem* _wxSizer_Insert(wxSizer* self, ulong index, const wxSize* size, const wxSizerFlags* flags)
    {
        return self->Insert(index, size->x, size->y, *flags);
    }
    %End

    wxSizerItem * InsertSpacer(
        size_t index,
        int size
    );
    %Docstring
        InsertSpacer(index, size) -> SizerItem

        Inserts non-stretchable space to the sizer.
    %End

    wxSizerItem * InsertStretchSpacer(
        size_t index,
        int prop = 1
    );
    %Docstring
        InsertStretchSpacer(index, prop=1) -> SizerItem

        Inserts stretchable space to the sizer.
    %End

    bool IsEmpty() const;
    %Docstring
        IsEmpty() -> bool

        Return true if the sizer has no elements.
    %End

    bool IsShown(
        wxWindow * window
    ) const;
    %Docstring
        IsShown(window) -> bool
        IsShown(sizer) -> bool
        IsShown(index) -> bool

        Returns true if the window is shown.
    %End

    bool IsShown(
        wxSizer * sizer
    ) const;

    bool IsShown(
        size_t index
    ) const;

    void Layout();
    %Docstring
        Layout()

        Call this to force layout of the children anew, e.g. after having
        added a child to or removed a child (window, other sizer or space)
        from the sizer while keeping the current dimension.
    %End

    wxSizerItem * Prepend(
        wxWindow * window,
        const wxSizerFlags & flags
    );
    %Docstring
        Prepend(window, flags) -> SizerItem
        Prepend(window, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Prepend(sizer, flags) -> SizerItem
        Prepend(sizer, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Prepend(width, height, proportion=0, flag=0, border=0, userData=None) -> SizerItem
        Prepend(width, height, flags) -> SizerItem
        Prepend(item) -> SizerItem
        Prepend(size, proportion=0, flag=0, border=0, /Transfer/=None) -> SizerItem
        Prepend(size, flags) -> SizerItem

        Same as Add(), but prepends the items to the beginning of the list of
        items (windows, subsizers or spaces) owned by this sizer.
    %End

    wxSizerItem * Prepend(
        wxWindow * window,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Prepend(
        wxSizer * sizer   /Transfer/,
        const wxSizerFlags & flags
    );

    wxSizerItem * Prepend(
        wxSizer * sizer   /Transfer/,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Prepend(
        int width,
        int height,
        int proportion = 0,
        int flag = 0,
        int border = 0,
        wxPyUserData* userData   /Transfer/ = NULL
    );

    wxSizerItem * Prepend(
        int width,
        int height,
        const wxSizerFlags & flags
    );

    wxSizerItem * Prepend(
        wxSizerItem * item   /Transfer/
    );

    wxSizerItem* Prepend(const wxSize& size,  int proportion=0,  int flag=0,  int border=0,  wxPyUserData* userData /Transfer/ = NULL);
    %MethodCode
        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxSizer_Prepend(sipCpp, size, proportion, flag, border, userData);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;
    %End
    %TypeCode
    wxSizerItem* _wxSizer_Prepend(wxSizer* self, const wxSize* size, int proportion, int flag, int border, wxPyUserData* userData )
    {
        return self->Prepend(size->x, size->y, proportion, flag, border, userData);
    }
    %End

    wxSizerItem* Prepend(const wxSize& size,  const wxSizerFlags& flags);
    %MethodCode
        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxSizer_Prepend(sipCpp, size, flags);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;
    %End
    %TypeCode
    wxSizerItem* _wxSizer_Prepend(wxSizer* self, const wxSize* size, const wxSizerFlags* flags)
    {
        return self->Prepend(size->x, size->y, *flags);
    }
    %End

    wxSizerItem * PrependSpacer(
        int size
    );
    %Docstring
        PrependSpacer(size) -> SizerItem

        Prepends non-stretchable space to the sizer.
    %End

    wxSizerItem * PrependStretchSpacer(
        int prop = 1
    );
    %Docstring
        PrependStretchSpacer(prop=1) -> SizerItem

        Prepends stretchable space to the sizer.
    %End

    virtual
    void RecalcSizes() = 0;
    %Docstring
        RecalcSizes()

        This method is abstract and has to be overwritten by any derived
        class.
    %End

    bool Remove(
        wxSizer * sizer
    );
    %Docstring
        Remove(sizer) -> bool
        Remove(index) -> bool

        Removes a sizer child from the sizer and destroys it.
    %End

    bool Remove(
        int index
    );

    bool Replace(
        wxWindow * oldwin,
        wxWindow * newwin,
        bool recursive = false
    );
    %Docstring
        Replace(oldwin, newwin, recursive=False) -> bool
        Replace(oldsz, newsz, recursive=False) -> bool
        Replace(index, newitem) -> bool

        Detaches the given oldwin from the sizer and replaces it with the
        given newwin.
    %End

    bool Replace(
        wxSizer * oldsz,
        wxSizer * newsz,
        bool recursive = false
    );

    bool Replace(
        size_t index,
        wxSizerItem * newitem
    );

    void SetDimension(
        int x,
        int y,
        int width,
        int height
    );
    %Docstring
        SetDimension(x, y, width, height)
        SetDimension(pos, size)

        Call this to force the sizer to take the given dimension and thus
        force the items owned by the sizer to resize themselves according to
        the rules defined by the parameter in the Add() and Prepend() methods.
    %End

    void SetDimension(
        const wxPoint & pos,
        const wxSize & size
    );

    void SetMinSize(
        const wxSize & size
    );
    %Docstring
        SetMinSize(size)
        SetMinSize(width, height)

        Call this to give the sizer a minimal size.
    %End

    void SetMinSize(
        int width,
        int height
    );

    void SetSizeHints(
        wxWindow * window
    );
    %Docstring
        SetSizeHints(window)

        This method first calls Fit() and then
        wxTopLevelWindow::SetSizeHints() on the window passed to it.
    %End

    void SetVirtualSizeHints(
        wxWindow * window
    )   /Deprecated/;
    %Docstring
        SetVirtualSizeHints(window)

        Tell the sizer to set the minimal size of the window virtual area to
        match the sizer's minimal size.
    %End

    bool Show(
        wxWindow * window,
        bool show = true,
        bool recursive = false
    );
    %Docstring
        Show(window, show=True, recursive=False) -> bool
        Show(sizer, show=True, recursive=False) -> bool
        Show(index, show=True) -> bool

        Shows or hides the window.
    %End

    bool Show(
        wxSizer * sizer,
        bool show = true,
        bool recursive = false
    );

    bool Show(
        size_t index,
        bool show = true
    );

    void ShowItems(
        bool show
    );
    %Docstring
        ShowItems(show)

        Show or hide all items managed by the sizer.
    %End

    private:
        wxSizer(const wxSizer&);


    private:
        wxSizer& operator=(const wxSizer&);


    public:


    %Property(name=Children, get=GetChildren)
    %Property(name=ContainingWindow, get=GetContainingWindow, set=SetContainingWindow)
    %Property(name=ItemCount, get=GetItemCount)
    %Property(name=MinSize, get=GetMinSize, set=SetMinSize)
    %Property(name=Position, get=GetPosition)
    %Property(name=Size, get=GetSize)
};  // end of class wxSizer


%Extract(id=pycode_core)
def _Sizer_AddMany(self, items):
    """
    :meth:`AddMany` is a convenience method for adding several items to a sizer
    at one time. Simply pass it a list of tuples, where each tuple
    consists of the parameters that you would normally pass to the :meth:`Add`
    method.
    """
    for item in items:
        if not isinstance(item, (tuple, list)):
            item = (item, )
        self.Add(*item)
Sizer.AddMany = _Sizer_AddMany
del _Sizer_AddMany
%End

%Extract(id=pycode_core)
def _Sizer___nonzero__(self):
    """
    Can be used to test if the C++ part of the sizer still exists, with
    code like this::

        if theSizer:
            doSomething()
    """
    import wx.siplib
    return not wx.siplib.isdeleted(self)
Sizer.__nonzero__ = _Sizer___nonzero__
del _Sizer___nonzero__
%End

%Extract(id=pycode_core)
def _Sizer___iter__(self):
    """
    A Py convenience method that allows Sizers to act as iterables that will yield their wx.SizerItems.
    """
    for item in self.GetChildren(): yield item
Sizer.__iter__ = _Sizer___iter__
del _Sizer___iter__
%End

%Extract(id=pycode_core)
Sizer.__bool__ = Sizer.__nonzero__

%End

class wxBoxSizer : wxSizer
{
    %Docstring
        BoxSizer(orient=HORIZONTAL)

        The basic idea behind a box sizer is that windows will most often be
        laid out in rather simple basic geometry, typically in a row or a
        column or several hierarchies of either.
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxBoxSizer(
        int orient = wxHORIZONTAL
    );

    wxSizerItem * AddSpacer(
        int size
    );
    %Docstring
        AddSpacer(size) -> SizerItem

        Adds non-stretchable space to the main orientation of the sizer only.
    %End

    virtual
    wxSize CalcMin();
    %Docstring
        CalcMin() -> Size

        Implements the calculation of a box sizer's minimal.
    %End

    int GetOrientation() const;
    %Docstring
        GetOrientation() -> int

        Returns the orientation of the box sizer, either wxVERTICAL or
        wxHORIZONTAL.
    %End

    void SetOrientation(
        int orient
    );
    %Docstring
        SetOrientation(orient)

        Sets the orientation of the box sizer, either wxVERTICAL or
        wxHORIZONTAL.
    %End

    virtual
    void RecalcSizes();
    %Docstring
        RecalcSizes()

        Implements the calculation of a box sizer's dimensions and then sets
        the size of its children (calling wxWindow::SetSize if the child is a
        window).
    %End

    public:


    %Property(name=Orientation, get=GetOrientation, set=SetOrientation)
};  // end of class wxBoxSizer


class wxStaticBoxSizer : wxBoxSizer
{
    %Docstring
        StaticBoxSizer(box, orient=HORIZONTAL)
        StaticBoxSizer(orient, parent, label=EmptyString)

        wxStaticBoxSizer is a sizer derived from wxBoxSizer but adds a static
        box around the sizer.
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxStaticBoxSizer(
        wxStaticBox * box,
        int orient = wxHORIZONTAL
    );

    wxStaticBoxSizer(
        int orient,
        wxWindow * parent,
        const wxString & label = wxEmptyString
    );

    wxStaticBox * GetStaticBox() const;
    %Docstring
        GetStaticBox() -> StaticBox

        Returns the static box associated with the sizer.
    %End

    virtual
    wxSize CalcMin();
    %Docstring
        CalcMin() -> Size

        Implements the calculation of a box sizer's minimal.
    %End

    virtual
    void RecalcSizes();
    %Docstring
        RecalcSizes()

        Implements the calculation of a box sizer's dimensions and then sets
        the size of its children (calling wxWindow::SetSize if the child is a
        window).
    %End

    public:


    %Property(name=StaticBox, get=GetStaticBox)
};  // end of class wxStaticBoxSizer


class wxGridSizer : wxSizer
{
    %Docstring
        GridSizer(cols, vgap, hgap)
        GridSizer(cols, gap=Size(0,0))
        GridSizer(rows, cols, vgap, hgap)
        GridSizer(rows, cols, gap)

        A grid sizer is a sizer which lays out its children in a two-
        dimensional table with all table fields having the same size, i.e.
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxGridSizer(
        int cols,
        int vgap,
        int hgap
    );

    wxGridSizer(
        int cols,
        const wxSize & gap = wxSize(0, 0)
    );

    wxGridSizer(
        int rows,
        int cols,
        int vgap,
        int hgap
    );

    wxGridSizer(
        int rows,
        int cols,
        const wxSize & gap
    );

    int GetCols() const;
    %Docstring
        GetCols() -> int

        Returns the number of columns that has been specified for the sizer.
    %End

    int GetRows() const;
    %Docstring
        GetRows() -> int

        Returns the number of rows that has been specified for the sizer.
    %End

    int GetEffectiveColsCount() const;
    %Docstring
        GetEffectiveColsCount() -> int

        Returns the number of columns currently used by the sizer.
    %End

    int GetEffectiveRowsCount() const;
    %Docstring
        GetEffectiveRowsCount() -> int

        Returns the number of rows currently used by the sizer.
    %End

    int GetHGap() const;
    %Docstring
        GetHGap() -> int

        Returns the horizontal gap (in pixels) between cells in the sizer.
    %End

    int GetVGap() const;
    %Docstring
        GetVGap() -> int

        Returns the vertical gap (in pixels) between the cells in the sizer.
    %End

    void SetCols(
        int cols
    );
    %Docstring
        SetCols(cols)

        Sets the number of columns in the sizer.
    %End

    void SetHGap(
        int gap
    );
    %Docstring
        SetHGap(gap)

        Sets the horizontal gap (in pixels) between cells in the sizer.
    %End

    void SetRows(
        int rows
    );
    %Docstring
        SetRows(rows)

        Sets the number of rows in the sizer.
    %End

    void SetVGap(
        int gap
    );
    %Docstring
        SetVGap(gap)

        Sets the vertical gap (in pixels) between the cells in the sizer.
    %End

    virtual
    wxSize CalcMin();
    %Docstring
        CalcMin() -> Size

        This method is abstract and has to be overwritten by any derived
        class.
    %End

    virtual
    void RecalcSizes();
    %Docstring
        RecalcSizes()

        This method is abstract and has to be overwritten by any derived
        class.
    %End

    public:


    %Property(name=Cols, get=GetCols, set=SetCols)
    %Property(name=EffectiveColsCount, get=GetEffectiveColsCount)
    %Property(name=EffectiveRowsCount, get=GetEffectiveRowsCount)
    %Property(name=HGap, get=GetHGap, set=SetHGap)
    %Property(name=Rows, get=GetRows, set=SetRows)
    %Property(name=VGap, get=GetVGap, set=SetVGap)
};  // end of class wxGridSizer


%Extract(id=pycode_core)
def _GridSizer_CalcRowsCols(self):
    """
    CalcRowsCols() -> (rows, cols)

    Calculates how many rows and columns will be in the sizer based
    on the current number of items and also the rows, cols specified
    in the constructor.
    """
    nitems = len(self.GetChildren())
    rows = self.GetRows()
    cols = self.GetCols()
    assert rows != 0 or cols != 0, "Grid sizer must have either rows or columns fixed"
    if cols != 0:
        rows = (nitems + cols - 1) / cols
    elif rows != 0:
        cols = (nitems + rows - 1) / rows
    return (rows, cols)
GridSizer.CalcRowsCols = _GridSizer_CalcRowsCols
del _GridSizer_CalcRowsCols
%End

class wxFlexGridSizer : wxGridSizer
{
    %Docstring
        FlexGridSizer(cols, vgap, hgap)
        FlexGridSizer(cols, gap=Size(0,0))
        FlexGridSizer(rows, cols, vgap, hgap)
        FlexGridSizer(rows, cols, gap)

        A flex grid sizer is a sizer which lays out its children in a two-
        dimensional table with all table fields in one row having the same
        height and all fields in one column having the same width, but all
        rows or all columns are not necessarily the same height or width as in
        the wxGridSizer.
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxFlexGridSizer(
        int cols,
        int vgap,
        int hgap
    );

    wxFlexGridSizer(
        int cols,
        const wxSize & gap = wxSize(0, 0)
    );

    wxFlexGridSizer(
        int rows,
        int cols,
        int vgap,
        int hgap
    );

    wxFlexGridSizer(
        int rows,
        int cols,
        const wxSize & gap
    );

    void AddGrowableCol(
        size_t idx,
        int proportion = 0
    );
    %Docstring
        AddGrowableCol(idx, proportion=0)

        Specifies that column idx (starting from zero) should be grown if
        there is extra space available to the sizer.
    %End

    void AddGrowableRow(
        size_t idx,
        int proportion = 0
    );
    %Docstring
        AddGrowableRow(idx, proportion=0)

        Specifies that row idx (starting from zero) should be grown if there
        is extra space available to the sizer.
    %End

    int GetFlexibleDirection() const;
    %Docstring
        GetFlexibleDirection() -> int

        Returns a wxOrientation value that specifies whether the sizer
        flexibly resizes its columns, rows, or both (default).
    %End

    wxFlexSizerGrowMode GetNonFlexibleGrowMode() const;
    %Docstring
        GetNonFlexibleGrowMode() -> FlexSizerGrowMode

        Returns the value that specifies how the sizer grows in the "non-
        flexible" direction if there is one.
    %End

    bool IsColGrowable(
        size_t idx
    );
    %Docstring
        IsColGrowable(idx) -> bool

        Returns true if column idx is growable.
    %End

    bool IsRowGrowable(
        size_t idx
    );
    %Docstring
        IsRowGrowable(idx) -> bool

        Returns true if row idx is growable.
    %End

    void RemoveGrowableCol(
        size_t idx
    );
    %Docstring
        RemoveGrowableCol(idx)

        Specifies that the idx column index is no longer growable.
    %End

    void RemoveGrowableRow(
        size_t idx
    );
    %Docstring
        RemoveGrowableRow(idx)

        Specifies that the idx row index is no longer growable.
    %End

    void SetFlexibleDirection(
        int direction
    );
    %Docstring
        SetFlexibleDirection(direction)

        Specifies whether the sizer should flexibly resize its columns, rows,
        or both.
    %End

    void SetNonFlexibleGrowMode(
        wxFlexSizerGrowMode mode
    );
    %Docstring
        SetNonFlexibleGrowMode(mode)

        Specifies how the sizer should grow in the non-flexible direction if
        there is one (so SetFlexibleDirection() must have been called
        previously).
    %End

    const wxArrayInt & GetRowHeights() const;
    %Docstring
        GetRowHeights() -> ArrayInt

        Returns a read-only array containing the heights of the rows in the
        sizer.
    %End

    const wxArrayInt & GetColWidths() const;
    %Docstring
        GetColWidths() -> ArrayInt

        Returns a read-only array containing the widths of the columns in the
        sizer.
    %End

    virtual
    void RecalcSizes();
    %Docstring
        RecalcSizes()

        This method is abstract and has to be overwritten by any derived
        class.
    %End

    virtual
    wxSize CalcMin();
    %Docstring
        CalcMin() -> Size

        This method is abstract and has to be overwritten by any derived
        class.
    %End

    public:


    %Property(name=ColWidths, get=GetColWidths)
    %Property(name=FlexibleDirection, get=GetFlexibleDirection, set=SetFlexibleDirection)
    %Property(name=NonFlexibleGrowMode, get=GetNonFlexibleGrowMode, set=SetNonFlexibleGrowMode)
    %Property(name=RowHeights, get=GetRowHeights)
};  // end of class wxFlexGridSizer


class wxStdDialogButtonSizer : wxBoxSizer
{
    %Docstring
        StdDialogButtonSizer()

        This class creates button layouts which conform to the standard button
        spacing and ordering defined by the platform or toolkit's user
        interface guidelines (if such things exist).
    %End
    %TypeHeaderCode
        #include <wx/sizer.h>
    %End

public:
    wxStdDialogButtonSizer();

    void AddButton(
        wxButton * button
    );
    %Docstring
        AddButton(button)

        Adds a button to the wxStdDialogButtonSizer.
    %End

    void Realize();
    %Docstring
        Realize()

        Rearranges the buttons and applies proper spacing between buttons to
        make them match the platform or toolkit's interface guidelines.
    %End

    void SetAffirmativeButton(
        wxButton * button
    );
    %Docstring
        SetAffirmativeButton(button)

        Sets the affirmative button for the sizer.
    %End

    void SetCancelButton(
        wxButton * button
    );
    %Docstring
        SetCancelButton(button)

        Sets the cancel button for the sizer.
    %End

    void SetNegativeButton(
        wxButton * button
    );
    %Docstring
        SetNegativeButton(button)

        Sets the negative button for the sizer.
    %End

    virtual
    void RecalcSizes();
    %Docstring
        RecalcSizes()

        Implements the calculation of a box sizer's dimensions and then sets
        the size of its children (calling wxWindow::SetSize if the child is a
        window).
    %End

    virtual
    wxSize CalcMin();
    %Docstring
        CalcMin() -> Size

        Implements the calculation of a box sizer's minimal.
    %End

    public:


};  // end of class wxStdDialogButtonSizer


%Extract(id=pycode_core)
PySizer = wx.deprecated(Sizer, 'Use Sizer instead.')

%End

class wxSizerItemList_iterator /Abstract/
{
    // the C++ implementation of this class
    %TypeHeaderCode

        class wxSizerItemList_iterator {
        public:
            wxSizerItemList_iterator(wxSizerItemList::compatibility_iterator start)
                : m_node(start) {}

            wxSizerItem* __next__() {
                wxSizerItem* obj = NULL;
                if (m_node) {
                    obj = (wxSizerItem*) m_node->GetData();
                    m_node = m_node->GetNext();
                }
                else {
                    PyErr_SetString(PyExc_StopIteration, "");
                }
                return (wxSizerItem*)obj;
            }
        private:
            wxSizerItemList::compatibility_iterator m_node;
        };
    %End
public:
    wxSizerItem* __next__();
    %MethodCode
        sipRes = sipCpp->__next__();
        if (PyErr_Occurred())
            return NULL;
    %End
};

class wxSizerItemList
{
    %TypeHeaderCode

    %End
public:
    SIP_SSIZE_T __len__();
    %MethodCode
        sipRes = sipCpp->size();
    %End

    wxSizerItem* __getitem__(long index);
    %MethodCode
        if (0 > index)
            index += sipCpp->size();

        if (index < sipCpp->size() && (0 <= index)) {
            wxSizerItemList::compatibility_iterator node = sipCpp->Item(index);
            if (node)
                sipRes = (wxSizerItem*)node->GetData();
        }
        else {
            wxPyErr_SetString(PyExc_IndexError, "sequence index out of range");
            sipError = sipErrorFail;
        }
    %End

    int __contains__(const wxSizerItem* obj);
    %MethodCode
        wxSizerItemList::compatibility_iterator node;
        node = sipCpp->Find((wxSizerItem*)obj);
        sipRes = node != NULL;
    %End

    wxSizerItemList_iterator* __iter__() /Factory/;
    %MethodCode
        sipRes =  new wxSizerItemList_iterator(sipCpp->GetFirst());
    %End

    // TODO:  add support for index(value, [start, [stop]])
    int index(wxSizerItem* obj);
    %MethodCode
        int idx = sipCpp->IndexOf((wxSizerItem*)obj);
        if (idx == wxNOT_FOUND) {
            sipError = sipErrorFail;
            wxPyErr_SetString(PyExc_ValueError,
                              "sequence.index(x): x not in sequence");
        }
        sipRes = idx;
    %End


};

%Extract(id=pycode_core)
def _SizerItemList___repr__(self):
    return "SizerItemList: " + repr(list(self))
SizerItemList.__repr__ = _SizerItemList___repr__
del _SizerItemList___repr__
%End


//---------------------------------------------------------------------------