X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/66c033b4a6ee95a2392b7f3c5a629256b661c456..2693507fda7617b7cd16197f92e9abacf1ce75f9:/wxPython/src/gtk/_controls.py diff --git a/wxPython/src/gtk/_controls.py b/wxPython/src/gtk/_controls.py index 677b38e205..8d9f184b8a 100644 --- a/wxPython/src/gtk/_controls.py +++ b/wxPython/src/gtk/_controls.py @@ -85,6 +85,23 @@ class Button(_core.Control): return _controls_.Button_GetDefaultSize(*args, **kwargs) GetDefaultSize = staticmethod(GetDefaultSize) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Button_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class ButtonPtr(Button): def __init__(self, this): @@ -113,6 +130,22 @@ def Button_GetDefaultSize(*args, **kwargs): """ return _controls_.Button_GetDefaultSize(*args, **kwargs) +def Button_GetClassDefaultAttributes(*args, **kwargs): + """ + Button_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Button_GetClassDefaultAttributes(*args, **kwargs) + class BitmapButton(Button): """ A Button that contains a bitmap. A bitmap button can be supplied with a @@ -406,6 +439,23 @@ class CheckBox(_core.Control): """ return _controls_.CheckBox_Is3rdStateAllowedForUser(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.CheckBox_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class CheckBoxPtr(CheckBox): def __init__(self, this): @@ -425,6 +475,22 @@ def PreCheckBox(*args, **kwargs): val.thisown = 1 return val +def CheckBox_GetClassDefaultAttributes(*args, **kwargs): + """ + CheckBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.CheckBox_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class Choice(_core.ControlWithItems): @@ -491,6 +557,23 @@ class Choice(_core.ControlWithItems): return _controls_.Choice_SetString(*args, **kwargs) Select = SetSelection + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Choice_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class ChoicePtr(Choice): def __init__(self, this): @@ -510,6 +593,22 @@ def PreChoice(*args, **kwargs): val.thisown = 1 return val +def Choice_GetClassDefaultAttributes(*args, **kwargs): + """ + Choice_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Choice_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class ComboBox(_core.Control,_core.ItemContainer): @@ -667,6 +766,23 @@ class ComboBox(_core.Control,_core.ItemContainer): """ return _controls_.ComboBox_Remove(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ComboBox_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class ComboBoxPtr(ComboBox): def __init__(self, this): @@ -686,6 +802,22 @@ def PreComboBox(*args, **kwargs): val.thisown = 1 return val +def ComboBox_GetClassDefaultAttributes(*args, **kwargs): + """ + ComboBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ComboBox_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- GA_HORIZONTAL = _controls_.GA_HORIZONTAL @@ -753,6 +885,23 @@ class Gauge(_core.Control): """GetBezelFace(self) -> int""" return _controls_.Gauge_GetBezelFace(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Gauge_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class GaugePtr(Gauge): def __init__(self, this): @@ -768,6 +917,22 @@ def PreGauge(*args, **kwargs): val.thisown = 1 return val +def Gauge_GetClassDefaultAttributes(*args, **kwargs): + """ + Gauge_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Gauge_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class StaticBox(_core.Control): @@ -793,6 +958,23 @@ class StaticBox(_core.Control): """ return _controls_.StaticBox_Create(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticBox_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class StaticBoxPtr(StaticBox): def __init__(self, this): @@ -810,6 +992,22 @@ def PreStaticBox(*args, **kwargs): val.thisown = 1 return val +def StaticBox_GetClassDefaultAttributes(*args, **kwargs): + """ + StaticBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticBox_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class StaticLine(_core.Control): @@ -844,6 +1042,23 @@ class StaticLine(_core.Control): return _controls_.StaticLine_GetDefaultSize(*args, **kwargs) GetDefaultSize = staticmethod(GetDefaultSize) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticLine_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class StaticLinePtr(StaticLine): def __init__(self, this): @@ -862,6 +1077,22 @@ def StaticLine_GetDefaultSize(*args, **kwargs): """StaticLine_GetDefaultSize() -> int""" return _controls_.StaticLine_GetDefaultSize(*args, **kwargs) +def StaticLine_GetClassDefaultAttributes(*args, **kwargs): + """ + StaticLine_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticLine_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class StaticText(_core.Control): @@ -887,6 +1118,23 @@ class StaticText(_core.Control): """ return _controls_.StaticText_Create(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticText_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class StaticTextPtr(StaticText): def __init__(self, this): @@ -901,6 +1149,22 @@ def PreStaticText(*args, **kwargs): val.thisown = 1 return val +def StaticText_GetClassDefaultAttributes(*args, **kwargs): + """ + StaticText_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticText_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class StaticBitmap(_core.Control): @@ -938,6 +1202,23 @@ class StaticBitmap(_core.Control): """SetIcon(self, Icon icon)""" return _controls_.StaticBitmap_SetIcon(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticBitmap_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class StaticBitmapPtr(StaticBitmap): def __init__(self, this): @@ -952,6 +1233,22 @@ def PreStaticBitmap(*args, **kwargs): val.thisown = 1 return val +def StaticBitmap_GetClassDefaultAttributes(*args, **kwargs): + """ + StaticBitmap_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.StaticBitmap_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class ListBox(_core.ControlWithItems): @@ -1596,6 +1893,23 @@ class TextCtrl(_core.Control): """GetString(self, long from, long to) -> String""" return _controls_.TextCtrl_GetString(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.TextCtrl_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class TextCtrlPtr(TextCtrl): def __init__(self, this): @@ -1610,6 +1924,22 @@ def PreTextCtrl(*args, **kwargs): val.thisown = 1 return val +def TextCtrl_GetClassDefaultAttributes(*args, **kwargs): + """ + TextCtrl_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.TextCtrl_GetClassDefaultAttributes(*args, **kwargs) + wxEVT_COMMAND_TEXT_UPDATED = _controls_.wxEVT_COMMAND_TEXT_UPDATED wxEVT_COMMAND_TEXT_ENTER = _controls_.wxEVT_COMMAND_TEXT_ENTER wxEVT_COMMAND_TEXT_URL = _controls_.wxEVT_COMMAND_TEXT_URL @@ -1721,6 +2051,23 @@ class ScrollBar(_core.Control): """ return _controls_.ScrollBar_SetScrollbar(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ScrollBar_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class ScrollBarPtr(ScrollBar): def __init__(self, this): @@ -1736,6 +2083,22 @@ def PreScrollBar(*args, **kwargs): val.thisown = 1 return val +def ScrollBar_GetClassDefaultAttributes(*args, **kwargs): + """ + ScrollBar_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ScrollBar_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- SP_HORIZONTAL = _controls_.SP_HORIZONTAL @@ -1793,10 +2156,27 @@ class SpinButton(_core.Control): """SetRange(self, int minVal, int maxVal)""" return _controls_.SpinButton_SetRange(*args, **kwargs) - def IsVertical(*args, **kwargs): - """IsVertical(self) -> bool""" - return _controls_.SpinButton_IsVertical(*args, **kwargs) + def IsVertical(*args, **kwargs): + """IsVertical(self) -> bool""" + return _controls_.SpinButton_IsVertical(*args, **kwargs) + + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.SpinButton_GetClassDefaultAttributes(*args, **kwargs) + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class SpinButtonPtr(SpinButton): def __init__(self, this): @@ -1813,6 +2193,22 @@ def PreSpinButton(*args, **kwargs): val.thisown = 1 return val +def SpinButton_GetClassDefaultAttributes(*args, **kwargs): + """ + SpinButton_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.SpinButton_GetClassDefaultAttributes(*args, **kwargs) + class SpinCtrl(_core.Control): def __repr__(self): return "<%s.%s; proxy of C++ wxSpinCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -1866,6 +2262,23 @@ class SpinCtrl(_core.Control): """SetSelection(self, long from, long to)""" return _controls_.SpinCtrl_SetSelection(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.SpinCtrl_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class SpinCtrlPtr(SpinCtrl): def __init__(self, this): @@ -1880,6 +2293,22 @@ def PreSpinCtrl(*args, **kwargs): val.thisown = 1 return val +def SpinCtrl_GetClassDefaultAttributes(*args, **kwargs): + """ + SpinCtrl_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.SpinCtrl_GetClassDefaultAttributes(*args, **kwargs) + class SpinEvent(_core.NotifyEvent): def __repr__(self): return "<%s.%s; proxy of C++ wxSpinEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -1995,6 +2424,23 @@ class RadioBox(_core.Control): """GetNextItem(self, int item, int dir, long style) -> int""" return _controls_.RadioBox_GetNextItem(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.RadioBox_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class RadioBoxPtr(RadioBox): def __init__(self, this): @@ -2011,6 +2457,22 @@ def PreRadioBox(*args, **kwargs): val.thisown = 1 return val +def RadioBox_GetClassDefaultAttributes(*args, **kwargs): + """ + RadioBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.RadioBox_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class RadioButton(_core.Control): @@ -2044,6 +2506,23 @@ class RadioButton(_core.Control): """SetValue(self, bool value)""" return _controls_.RadioButton_SetValue(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.RadioButton_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class RadioButtonPtr(RadioButton): def __init__(self, this): @@ -2058,6 +2537,22 @@ def PreRadioButton(*args, **kwargs): val.thisown = 1 return val +def RadioButton_GetClassDefaultAttributes(*args, **kwargs): + """ + RadioButton_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.RadioButton_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class Slider(_core.Control): @@ -2170,6 +2665,23 @@ class Slider(_core.Control): """SetSelection(self, int min, int max)""" return _controls_.Slider_SetSelection(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Slider_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class SliderPtr(Slider): def __init__(self, this): @@ -2185,6 +2697,22 @@ def PreSlider(*args, **kwargs): val.thisown = 1 return val +def Slider_GetClassDefaultAttributes(*args, **kwargs): + """ + Slider_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Slider_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- wxEVT_COMMAND_TOGGLEBUTTON_CLICKED = _controls_.wxEVT_COMMAND_TOGGLEBUTTON_CLICKED @@ -2229,6 +2757,23 @@ class ToggleButton(_core.Control): """ return _controls_.ToggleButton_SetLabel(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ToggleButton_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class ToggleButtonPtr(ToggleButton): def __init__(self, this): @@ -2244,6 +2789,22 @@ def PreToggleButton(*args, **kwargs): val.thisown = 1 return val +def ToggleButton_GetClassDefaultAttributes(*args, **kwargs): + """ + ToggleButton_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ToggleButton_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- class BookCtrl(_core.Control): @@ -2329,6 +2890,23 @@ class BookCtrl(_core.Control): """AdvanceSelection(self, bool forward=True)""" return _controls_.BookCtrl_AdvanceSelection(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.BookCtrl_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class BookCtrlPtr(BookCtrl): def __init__(self, this): @@ -2338,6 +2916,22 @@ class BookCtrlPtr(BookCtrl): _controls_.BookCtrl_swigregister(BookCtrlPtr) NOTEBOOK_NAME = cvar.NOTEBOOK_NAME +def BookCtrl_GetClassDefaultAttributes(*args, **kwargs): + """ + BookCtrl_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.BookCtrl_GetClassDefaultAttributes(*args, **kwargs) + class BookCtrlEvent(_core.NotifyEvent): def __repr__(self): return "<%s.%s; proxy of C++ wxBookCtrlEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -2431,6 +3025,23 @@ class Notebook(BookCtrl): """CalcSizeFromPage(self, Size sizePage) -> Size""" return _controls_.Notebook_CalcSizeFromPage(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Notebook_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class NotebookPtr(Notebook): def __init__(self, this): @@ -2445,6 +3056,22 @@ def PreNotebook(*args, **kwargs): val.thisown = 1 return val +def Notebook_GetClassDefaultAttributes(*args, **kwargs): + """ + Notebook_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.Notebook_GetClassDefaultAttributes(*args, **kwargs) + class NotebookEvent(BookCtrlEvent): def __repr__(self): return "<%s.%s; proxy of C++ wxNotebookEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,) @@ -3134,6 +3761,23 @@ class ToolBar(ToolBarBase): """FindToolForPosition(self, int x, int y) -> ToolBarToolBase""" return _controls_.ToolBar_FindToolForPosition(*args, **kwargs) + def GetClassDefaultAttributes(*args, **kwargs): + """ + GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ToolBar_GetClassDefaultAttributes(*args, **kwargs) + + GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes) class ToolBarPtr(ToolBar): def __init__(self, this): @@ -3148,6 +3792,22 @@ def PreToolBar(*args, **kwargs): val.thisown = 1 return val +def ToolBar_GetClassDefaultAttributes(*args, **kwargs): + """ + ToolBar_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes + + Get the default attributes for this class. This is useful if + you want to use the same font or colour in your own control as + in a standard control -- which is a much better idea than hard + coding specific colours or fonts which might look completely out + of place on the users system, especially if it uses themes. + + The variant parameter is only relevant under Mac currently and is + ignore under other platforms. Under Mac, it will change the size of the + returned font. See SetWindowVariant for more about this. + """ + return _controls_.ToolBar_GetClassDefaultAttributes(*args, **kwargs) + #--------------------------------------------------------------------------- LC_VRULES = _controls_.LC_VRULES