X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/84bc0d49e411fd74ddac8b13318fc2edfba9258a..8fb6915941f155741ab282eb8fcffb480407a982:/wxPython/src/gtk/combo.py diff --git a/wxPython/src/gtk/combo.py b/wxPython/src/gtk/combo.py index 38b097c587..c9ed717e85 100644 --- a/wxPython/src/gtk/combo.py +++ b/wxPython/src/gtk/combo.py @@ -68,7 +68,10 @@ CC_NO_TEXT_AUTO_SELECT = _combo.CC_NO_TEXT_AUTO_SELECT CC_MF_ON_BUTTON = _combo.CC_MF_ON_BUTTON CC_MF_ON_CLICK_AREA = _combo.CC_MF_ON_CLICK_AREA class ComboCtrlFeatures(object): - """Proxy of C++ ComboCtrlFeatures class""" + """ + Namespace for `wx.combo.ComboCtrl` feature flags. See + `wx.combo.ComboCtrl.GetFeatures`. + """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self): raise AttributeError, "No constructor defined" __repr__ = _swig_repr @@ -83,7 +86,19 @@ class ComboCtrlFeatures(object): _combo.ComboCtrlFeatures_swigregister(ComboCtrlFeatures) class ComboCtrl(_core.Control): - """Proxy of C++ ComboCtrl class""" + """ + A combo control is a generic combobox that allows for a totally custom + popup. In addition it has other customization features. For instance, + position and size of the dropdown button can be changed. + + To specify what to use for the popup control you need to derive a + class from `wx.combo.ComboPopup` and pass it to the ComboCtrl with + `SetPopupControl`. It doesn't derive from any widget class so it can + be used either as a mixin class combined with some standard or custom + widget, or you can use the derived ComboPopup to create and hold an + independent reference to the widget to be used for the popup. + + """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): @@ -101,47 +116,100 @@ class ComboCtrl(_core.Control): return _combo.ComboCtrl__setCallbackInfo(*args, **kwargs) def ShowPopup(*args, **kwargs): - """ShowPopup(self)""" + """ + ShowPopup(self) + + Show the popup window. + """ return _combo.ComboCtrl_ShowPopup(*args, **kwargs) def HidePopup(*args, **kwargs): - """HidePopup(self)""" + """ + HidePopup(self) + + Dismisses the popup window. + """ return _combo.ComboCtrl_HidePopup(*args, **kwargs) def OnButtonClick(*args, **kwargs): - """OnButtonClick(self)""" + """ + OnButtonClick(self) + + Implement in a derived class to define what happens on dropdown button + click. Default action is to show the popup. + """ return _combo.ComboCtrl_OnButtonClick(*args, **kwargs) def IsPopupShown(*args, **kwargs): - """IsPopupShown(self) -> bool""" + """ + IsPopupShown(self) -> bool + + Returns true if the popup is currently shown. + """ return _combo.ComboCtrl_IsPopupShown(*args, **kwargs) def SetPopupControl(*args, **kwargs): - """SetPopupControl(self, ComboPopup popup)""" + """ + SetPopupControl(self, ComboPopup popup) + + Set popup interface class derived from `wx.combo.ComboPopup`. This + method should be called as soon as possible after the control has been + created, unless `OnButtonClick` has been overridden. + """ return _combo.ComboCtrl_SetPopupControl(*args, **kwargs) def GetPopupControl(*args, **kwargs): - """GetPopupControl(self) -> ComboPopup""" + """ + GetPopupControl(self) -> ComboPopup + + Returns the current popup interface that has been set with + `SetPopupControl`. + """ return _combo.ComboCtrl_GetPopupControl(*args, **kwargs) def GetPopupWindow(*args, **kwargs): - """GetPopupWindow(self) -> Window""" + """ + GetPopupWindow(self) -> Window + + Returns the popup window containing the popup control. + """ return _combo.ComboCtrl_GetPopupWindow(*args, **kwargs) def GetTextCtrl(*args, **kwargs): - """GetTextCtrl(self) -> wxTextCtrl""" + """ + GetTextCtrl(self) -> wxTextCtrl + + Get the text control which is part of the combo control. + """ return _combo.ComboCtrl_GetTextCtrl(*args, **kwargs) def GetButton(*args, **kwargs): - """GetButton(self) -> Window""" + """ + GetButton(self) -> Window + + Get the dropdown button which is part of the combobox. Note: it's not + necessarily a wx.Button or wx.BitmapButton. + """ return _combo.ComboCtrl_GetButton(*args, **kwargs) def GetValue(*args, **kwargs): - """GetValue(self) -> String""" + """ + GetValue(self) -> String + + Returns text representation of the current value. For writable combo + control it always returns the value in the text field. + """ return _combo.ComboCtrl_GetValue(*args, **kwargs) def SetValue(*args, **kwargs): - """SetValue(self, String value)""" + """ + SetValue(self, String value) + + Sets the text for the combo control text field. For a combo control + with wx.CB_READONLY style the string must be accepted by the popup (for + instance, exist in the dropdown list), otherwise the call to + SetValue is ignored. + """ return _combo.ComboCtrl_SetValue(*args, **kwargs) def Copy(*args, **kwargs): @@ -189,27 +257,60 @@ class ComboCtrl(_core.Control): return _combo.ComboCtrl_SetMark(*args, **kwargs) def SetText(*args, **kwargs): - """SetText(self, String value)""" + """ + SetText(self, String value) + + Sets the text for the text field without affecting the popup. Thus, + unlike `SetValue`, it works equally well with combo control using + wx.CB_READONLY style. + """ return _combo.ComboCtrl_SetText(*args, **kwargs) def SetValueWithEvent(*args, **kwargs): - """SetValueWithEvent(self, String value, bool withEvent=True)""" + """ + SetValueWithEvent(self, String value, bool withEvent=True) + + Same as `SetValue`, but also sends a EVT_TEXT event if withEvent is true. + """ return _combo.ComboCtrl_SetValueWithEvent(*args, **kwargs) def SetPopupMinWidth(*args, **kwargs): - """SetPopupMinWidth(self, int width)""" + """ + SetPopupMinWidth(self, int width) + + Sets minimum width of the popup. If wider than combo control, it will + extend to the left. A value of -1 indicates to use the default. The + popup implementation may choose to ignore this. + """ return _combo.ComboCtrl_SetPopupMinWidth(*args, **kwargs) def SetPopupMaxHeight(*args, **kwargs): - """SetPopupMaxHeight(self, int height)""" + """ + SetPopupMaxHeight(self, int height) + + Sets preferred maximum height of the popup. A value of -1 indicates to + use the default. The popup implementation may choose to ignore this. + """ return _combo.ComboCtrl_SetPopupMaxHeight(*args, **kwargs) def SetPopupExtents(*args, **kwargs): - """SetPopupExtents(self, int extLeft, int extRight)""" + """ + SetPopupExtents(self, int extLeft, int extRight) + + Extends popup size horizontally, relative to the edges of the combo + control. Values are given in pixels, and the defaults are zero. It + is up to the popup to fully take these values into account. + """ return _combo.ComboCtrl_SetPopupExtents(*args, **kwargs) def SetCustomPaintWidth(*args, **kwargs): - """SetCustomPaintWidth(self, int width)""" + """ + SetCustomPaintWidth(self, int width) + + Set width, in pixels, of custom painted area in control without + wx.CB_READONLY style. In read-only OwnerDrawnComboBox, this is used + to indicate the area that is not covered by the focus rectangle. + """ return _combo.ComboCtrl_SetCustomPaintWidth(*args, **kwargs) def GetCustomPaintWidth(*args, **kwargs): @@ -217,15 +318,29 @@ class ComboCtrl(_core.Control): return _combo.ComboCtrl_GetCustomPaintWidth(*args, **kwargs) def SetPopupAnchor(*args, **kwargs): - """SetPopupAnchor(self, int anchorSide)""" + """ + SetPopupAnchor(self, int anchorSide) + + Set side of the control to which the popup will align itself. Valid + values are wx.LEFT, wx.RIGHT and 0. The default value 0 means that the + most appropriate side is used (which, currently, is always wx.LEFT). + """ return _combo.ComboCtrl_SetPopupAnchor(*args, **kwargs) def SetButtonPosition(*args, **kwargs): - """SetButtonPosition(self, int width=-1, int height=-1, int side=RIGHT, int spacingX=0)""" + """ + SetButtonPosition(self, int width=-1, int height=-1, int side=RIGHT, int spacingX=0) + + Set the position of the dropdown button. + """ return _combo.ComboCtrl_SetButtonPosition(*args, **kwargs) def GetButtonSize(*args, **kwargs): - """GetButtonSize(self) -> Size""" + """ + GetButtonSize(self) -> Size + + Returns current size of the dropdown button. + """ return _combo.ComboCtrl_GetButtonSize(*args, **kwargs) def SetButtonBitmaps(*args, **kwargs): @@ -233,39 +348,103 @@ class ComboCtrl(_core.Control): SetButtonBitmaps(self, Bitmap bmpNormal, bool pushButtonBg=False, Bitmap bmpPressed=wxNullBitmap, Bitmap bmpHover=wxNullBitmap, Bitmap bmpDisabled=wxNullBitmap) + + Sets custom dropdown button graphics. + + :param bmpNormal: Default button image + :param pushButtonBg: If ``True``, blank push button background is painted below the image. + :param bmpPressed: Depressed butotn image. + :param bmpHover: Button imate to use when the mouse hovers over it. + :param bmpDisabled: Disabled button image. + """ return _combo.ComboCtrl_SetButtonBitmaps(*args, **kwargs) def SetTextIndent(*args, **kwargs): - """SetTextIndent(self, int indent)""" + """ + SetTextIndent(self, int indent) + + This will set the space in pixels between left edge of the control and + the text, regardless whether control is read-only or not. A value of -1 can + be given to indicate platform default. + """ return _combo.ComboCtrl_SetTextIndent(*args, **kwargs) def GetTextIndent(*args, **kwargs): - """GetTextIndent(self) -> int""" + """ + GetTextIndent(self) -> int + + Returns actual indentation in pixels. + """ return _combo.ComboCtrl_GetTextIndent(*args, **kwargs) def GetTextRect(*args, **kwargs): - """GetTextRect(self) -> Rect""" + """ + GetTextRect(self) -> Rect + + Returns area covered by the text field (includes everything except + borders and the dropdown button). + """ return _combo.ComboCtrl_GetTextRect(*args, **kwargs) def UseAltPopupWindow(*args, **kwargs): - """UseAltPopupWindow(self, bool enable=True)""" + """ + UseAltPopupWindow(self, bool enable=True) + + Enable or disable usage of an alternative popup window, which + guarantees ability to focus the popup control, and allows common + native controls to function normally. This alternative popup window is + usually a wxDialog, and as such, when it is shown, its parent + top-level window will appear as if the focus has been lost from it. + """ return _combo.ComboCtrl_UseAltPopupWindow(*args, **kwargs) def EnablePopupAnimation(*args, **kwargs): - """EnablePopupAnimation(self, bool enable=True)""" + """ + EnablePopupAnimation(self, bool enable=True) + + Enables or disables popup animation, if any, depending on the value of + the argument. + """ return _combo.ComboCtrl_EnablePopupAnimation(*args, **kwargs) def IsKeyPopupToggle(*args, **kwargs): - """IsKeyPopupToggle(self, KeyEvent event) -> bool""" + """ + IsKeyPopupToggle(self, KeyEvent event) -> bool + + Returns true if given key combination should toggle the popup. + """ return _combo.ComboCtrl_IsKeyPopupToggle(*args, **kwargs) def PrepareBackground(*args, **kwargs): - """PrepareBackground(self, DC dc, Rect rect, int flags)""" + """ + PrepareBackground(self, DC dc, Rect rect, int flags) + + Prepare background of combo control or an item in a dropdown list in a + way typical on platform. This includes painting the focus/disabled + background and setting the clipping region. Unless you plan to paint + your own focus indicator, you should always call this in your + wxComboPopup::PaintComboControl implementation. In addition, it sets + pen and text colour to what looks good and proper against the + background. + + flags are the same as wx.RendererNative flags: + + ====================== ============================================ + wx.CONTROL_ISSUBMENU drawing a list item instead of combo control + wx.CONTROL_SELECTED list item is selected + wx.CONTROL_DISABLED control/item is disabled + ====================== ============================================ + + """ return _combo.ComboCtrl_PrepareBackground(*args, **kwargs) def ShouldDrawFocus(*args, **kwargs): - """ShouldDrawFocus(self) -> bool""" + """ + ShouldDrawFocus(self) -> bool + + Returns true if focus indicator should be drawn in the control. + """ return _combo.ComboCtrl_ShouldDrawFocus(*args, **kwargs) def GetBitmapNormal(*args, **kwargs): @@ -289,11 +468,19 @@ class ComboCtrl(_core.Control): return _combo.ComboCtrl_GetInternalFlags(*args, **kwargs) def IsCreated(*args, **kwargs): - """IsCreated(self) -> bool""" + """ + IsCreated(self) -> bool + + Return true if Create has finished + """ return _combo.ComboCtrl_IsCreated(*args, **kwargs) def OnPopupDismiss(*args, **kwargs): - """OnPopupDismiss(self)""" + """ + OnPopupDismiss(self) + + Common code to be called on popup hide/dismiss + """ return _combo.ComboCtrl_OnPopupDismiss(*args, **kwargs) Hidden = _combo.ComboCtrl_Hidden @@ -311,8 +498,18 @@ class ComboCtrl(_core.Control): """SetCtrlMainWnd(self, Window wnd)""" return _combo.ComboCtrl_SetCtrlMainWnd(*args, **kwargs) + def GetMainWindowOfCompositeControl(*args, **kwargs): + """GetMainWindowOfCompositeControl(self) -> Window""" + return _combo.ComboCtrl_GetMainWindowOfCompositeControl(*args, **kwargs) + def GetFeatures(*args, **kwargs): - """GetFeatures() -> int""" + """ + GetFeatures() -> int + + Returns a bit-list of flags indicating which features of the ComboCtrl + functionality are implemented by this implemetation. See + `wx.combo.ComboCtrlFeatures`. + """ return _combo.ComboCtrl_GetFeatures(*args, **kwargs) GetFeatures = staticmethod(GetFeatures) @@ -320,13 +517,47 @@ class ComboCtrl(_core.Control): ShowAbove = _combo.ComboCtrl_ShowAbove CanDeferShow = _combo.ComboCtrl_CanDeferShow def DoShowPopup(*args, **kwargs): - """DoShowPopup(self, Rect rect, int flags)""" + """ + DoShowPopup(self, Rect rect, int flags) + + Shows and positions the popup. + + Flags: + ============ ===================================================== + ShowBelow Showing popup below the control + ShowAbove Showing popup above the control + CanDeferShow Can only return true from AnimateShow if this is set + ============ ===================================================== + + """ return _combo.ComboCtrl_DoShowPopup(*args, **kwargs) def AnimateShow(*args, **kwargs): - """AnimateShow(self, Rect rect, int flags) -> bool""" + """ + AnimateShow(self, Rect rect, int flags) -> bool + + Implement in derived class to create a drop-down animation. Return + ``True`` if finished immediately. Otherwise the popup is only shown when the + derived class calls `DoShowPopup`. Flags are same as for `DoShowPopup`. + + """ return _combo.ComboCtrl_AnimateShow(*args, **kwargs) + PopupControl = property(GetPopupControl,SetPopupControl) + PopupWindow = property(GetPopupWindow) + TextCtrl = property(GetTextCtrl) + Button = property(GetButton) + Value = property(GetValue,SetValue) + InsertionPoint = property(GetInsertionPoint) + CustomPaintWidth = property(GetCustomPaintWidth,SetCustomPaintWidth) + ButtonSize = property(GetButtonSize) + TextIndent = property(GetTextIndent,SetTextIndent) + TextRect = property(GetTextRect) + BitmapNormal = property(GetBitmapNormal) + BitmapPressed = property(GetBitmapPressed) + BitmapHover = property(GetBitmapHover) + BitmapDisabled = property(GetBitmapDisabled) + PopupWindowState = property(GetPopupWindowState) _combo.ComboCtrl_swigregister(ComboCtrl) def PreComboCtrl(*args, **kwargs): @@ -335,17 +566,37 @@ def PreComboCtrl(*args, **kwargs): return val def ComboCtrl_GetFeatures(*args): - """ComboCtrl_GetFeatures() -> int""" + """ + ComboCtrl_GetFeatures() -> int + + Returns a bit-list of flags indicating which features of the ComboCtrl + functionality are implemented by this implemetation. See + `wx.combo.ComboCtrlFeatures`. + """ return _combo.ComboCtrl_GetFeatures(*args) #--------------------------------------------------------------------------- class ComboPopup(object): - """Proxy of C++ ComboPopup class""" + """ + In order to use a custom popup with `wx.combo.ComboCtrl` an interface + class derived from wx.combo.ComboPopup is used to manage the interface + between the popup control and the popup. You can either derive a new + class from both the widget class and this ComboPopup class, or the + derived class can have a reference to the widget used for the popup. + In either case you simply need to return the widget from the + `GetControl` method to allow the ComboCtrl to interact with it. + + Nearly all of the methods of this class are overridable in Python. + """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): - """__init__(self) -> ComboPopup""" + """ + __init__(self) -> ComboPopup + + Constructor + """ _combo.ComboPopup_swiginit(self,_combo.new_ComboPopup(*args, **kwargs)) ComboPopup._setCallbackInfo(self, self, ComboPopup) @@ -356,74 +607,173 @@ class ComboPopup(object): return _combo.ComboPopup__setCallbackInfo(*args, **kwargs) def Init(*args, **kwargs): - """Init(self)""" + """ + Init(self) + + This method is called after the popup is contructed and has been + assigned to the ComboCtrl. Derived classes can override this to do + extra inialization or whatever. + """ return _combo.ComboPopup_Init(*args, **kwargs) def Create(*args, **kwargs): - """Create(self, Window parent) -> bool""" + """ + Create(self, Window parent) -> bool + + The derived class must implement this method to create the popup + control. It should be a child of the ``parent`` passed in, but other + than that there is much flexibility in what the widget can be, its + style, etc. Return ``True`` for success, ``False`` otherwise. (NOTE: + this return value is not currently checked...) + """ return _combo.ComboPopup_Create(*args, **kwargs) def GetControl(*args, **kwargs): - """GetControl(self) -> Window""" + """ + GetControl(self) -> Window + + The derived class must implement this method and it should return a + reference to the widget created in the `Create` method. If the + derived class inherits from both the widget class and ComboPopup then + the return value is probably just ``self``. + """ return _combo.ComboPopup_GetControl(*args, **kwargs) def OnPopup(*args, **kwargs): - """OnPopup(self)""" + """ + OnPopup(self) + + The derived class may implement this to do special processing when + popup is shown. + """ return _combo.ComboPopup_OnPopup(*args, **kwargs) def OnDismiss(*args, **kwargs): - """OnDismiss(self)""" + """ + OnDismiss(self) + + The derived class may implement this to do special processing when + popup is hidden. + """ return _combo.ComboPopup_OnDismiss(*args, **kwargs) def SetStringValue(*args, **kwargs): - """SetStringValue(self, String value)""" + """ + SetStringValue(self, String value) + + Called just prior to displaying the popup. The derived class can + implement this to "select" the item in the popup that coresponds to + the passed in string value, if appropriate. The default + implementation does nothing. + """ return _combo.ComboPopup_SetStringValue(*args, **kwargs) def GetStringValue(*args, **kwargs): - """GetStringValue(self) -> String""" + """ + GetStringValue(self) -> String + + Gets the string representation of the currently selected value to be + used to display in the combo widget. + """ return _combo.ComboPopup_GetStringValue(*args, **kwargs) def PaintComboControl(*args, **kwargs): - """PaintComboControl(self, DC dc, Rect rect)""" + """ + PaintComboControl(self, DC dc, Rect rect) + + This is called to custom paint in the combo control itself (ie. not + the popup). Default implementation draws the current value as string. + """ return _combo.ComboPopup_PaintComboControl(*args, **kwargs) def OnComboKeyEvent(*args, **kwargs): - """OnComboKeyEvent(self, KeyEvent event)""" + """ + OnComboKeyEvent(self, KeyEvent event) + + Receives key events from the parent ComboCtrl. Events not handled + should be skipped, as usual. + """ return _combo.ComboPopup_OnComboKeyEvent(*args, **kwargs) def OnComboDoubleClick(*args, **kwargs): - """OnComboDoubleClick(self)""" + """ + OnComboDoubleClick(self) + + Implement this method in the derived class if you need to support + special actions when the user double-clicks on the parent ComboCtrl. + """ return _combo.ComboPopup_OnComboDoubleClick(*args, **kwargs) def GetAdjustedSize(*args, **kwargs): - """GetAdjustedSize(self, int minWidth, int prefHeight, int maxHeight) -> Size""" + """ + GetAdjustedSize(self, int minWidth, int prefHeight, int maxHeight) -> Size + + The derived class may implement this method to return adjusted size + for the popup control, according to the variables given. It is called + on every popup, just prior to `OnPopup`. + + :param minWidth: Preferred minimum width. + :param prefHeight: Preferred height. May be -1 to indicate no preference. + :maxWidth: Max height for window, as limited by screen size, and + should only be rounded down, if necessary. + + """ return _combo.ComboPopup_GetAdjustedSize(*args, **kwargs) def LazyCreate(*args, **kwargs): - """LazyCreate(self) -> bool""" + """ + LazyCreate(self) -> bool + + The derived class may implement this to return ``True`` if it wants to + delay the call to `Create` until the popup is shown for the first + time. It is more efficient, but on the other hand it is often more + convenient to have the control created immediately. The default + implementation returns ``False``. + """ return _combo.ComboPopup_LazyCreate(*args, **kwargs) def Dismiss(*args, **kwargs): - """Dismiss(self)""" + """ + Dismiss(self) + + Hides the popup + """ return _combo.ComboPopup_Dismiss(*args, **kwargs) def IsCreated(*args, **kwargs): - """IsCreated(self) -> bool""" + """ + IsCreated(self) -> bool + + Returns true if `Create` has been called. + """ return _combo.ComboPopup_IsCreated(*args, **kwargs) def DefaultPaintComboControl(*args, **kwargs): - """DefaultPaintComboControl(wxComboCtrlBase combo, DC dc, Rect rect)""" + """ + DefaultPaintComboControl(wxComboCtrlBase combo, DC dc, Rect rect) + + Default PaintComboControl behaviour + """ return _combo.ComboPopup_DefaultPaintComboControl(*args, **kwargs) DefaultPaintComboControl = staticmethod(DefaultPaintComboControl) def GetCombo(*args, **kwargs): - """GetCombo(self) -> ComboCtrl""" + """ + GetCombo(self) -> ComboCtrl + + Returns a reference to the `wx.combo.ComboCtrl` this ComboPopup object + is associated with. + """ return _combo.ComboPopup_GetCombo(*args, **kwargs) _combo.ComboPopup_swigregister(ComboPopup) def ComboPopup_DefaultPaintComboControl(*args, **kwargs): - """ComboPopup_DefaultPaintComboControl(wxComboCtrlBase combo, DC dc, Rect rect)""" + """ + ComboPopup_DefaultPaintComboControl(wxComboCtrlBase combo, DC dc, Rect rect) + + Default PaintComboControl behaviour + """ return _combo.ComboPopup_DefaultPaintComboControl(*args, **kwargs) #--------------------------------------------------------------------------- @@ -433,7 +783,16 @@ ODCB_STD_CONTROL_PAINT = _combo.ODCB_STD_CONTROL_PAINT ODCB_PAINTING_CONTROL = _combo.ODCB_PAINTING_CONTROL ODCB_PAINTING_SELECTED = _combo.ODCB_PAINTING_SELECTED class OwnerDrawnComboBox(ComboCtrl,_core.ItemContainer): - """Proxy of C++ OwnerDrawnComboBox class""" + """ + wx.combo.OwnerDrawnComboBox is a combobox with owner-drawn list + items. In essence, it is a `wx.combo.ComboCtrl` with a `wx.VListBox` + popup and a `wx.ControlWithItems` API. + + Implementing item drawing and measuring is similar to wx.VListBox. + The application needs to subclass wx.combo.OwnerDrawnComboBox and + implement the `OnDrawItem`, `OnMeasureItem` and `OnMeasureItemWidth` + methods. + """ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __init__(self, *args, **kwargs): @@ -443,10 +802,16 @@ class OwnerDrawnComboBox(ComboCtrl,_core.ItemContainer): wxArrayString choices=wxPyEmptyStringArray, long style=0, Validator validator=DefaultValidator, String name=wxPyComboBoxNameStr) -> OwnerDrawnComboBox + + Standard constructor. """ _combo.OwnerDrawnComboBox_swiginit(self,_combo.new_OwnerDrawnComboBox(*args, **kwargs)) self._setOORInfo(self);OwnerDrawnComboBox._setCallbackInfo(self, self, OwnerDrawnComboBox) + def _setCallbackInfo(*args, **kwargs): + """_setCallbackInfo(self, PyObject self, PyObject _class)""" + return _combo.OwnerDrawnComboBox__setCallbackInfo(*args, **kwargs) + def Create(*args, **kwargs): """ Create(self, Window parent, int id=-1, String value=EmptyString, @@ -454,27 +819,186 @@ class OwnerDrawnComboBox(ComboCtrl,_core.ItemContainer): wxArrayString choices=wxPyEmptyStringArray, long style=0, Validator validator=DefaultValidator, String name=wxPyComboBoxNameStr) -> bool + + Create the UI object, and other initialization. """ return _combo.OwnerDrawnComboBox_Create(*args, **kwargs) def GetWidestItemWidth(*args, **kwargs): - """GetWidestItemWidth(self) -> int""" + """ + GetWidestItemWidth(self) -> int + + Return the widest item width (recalculating it if necessary.) + """ return _combo.OwnerDrawnComboBox_GetWidestItemWidth(*args, **kwargs) def GetWidestItem(*args, **kwargs): - """GetWidestItem(self) -> int""" + """ + GetWidestItem(self) -> int + + Return the index of the widest item (recalculating it if necessary.) + """ return _combo.OwnerDrawnComboBox_GetWidestItem(*args, **kwargs) def SetMark(*args, **kwargs): """SetMark(self, long from, long to)""" return _combo.OwnerDrawnComboBox_SetMark(*args, **kwargs) + def OnDrawItem(*args, **kwargs): + """ + OnDrawItem(self, DC dc, Rect rect, int item, int flags) + + The derived class may implement this function to actually draw the + item with the given index on the provided DC. If this method is not + overridden, the item text is simply drawn as if the control was a + normal combobox. + + :param dc: The device context to use for drawing. + :param rect: The bounding rectangle for the item being drawn, the + DC's clipping region is set to this rectangle before + calling this method. + :param item: The index of the item to be drawn. + + :param flags: ``wx.combo.ODCB_PAINTING_CONTROL`` (The Combo control itself + is being painted, instead of a list item. The ``item`` + parameter may be ``wx.NOT_FOUND`` in this case. + ``wx.combo.ODCB_PAINTING_SELECTED`` (An item with + selection background is being painted. The DC's text colour + should already be correct. + + """ + return _combo.OwnerDrawnComboBox_OnDrawItem(*args, **kwargs) + + def OnMeasureItem(*args, **kwargs): + """ + OnMeasureItem(self, size_t item) -> int + + The derived class may implement this method to return the height of + the specified item (in pixels). The default implementation returns + text height, as if this control was a normal combobox. + """ + return _combo.OwnerDrawnComboBox_OnMeasureItem(*args, **kwargs) + + def OnMeasureItemWidth(*args, **kwargs): + """ + OnMeasureItemWidth(self, size_t item) -> int + + The derived class may implement this method to return the width of the + specified item (in pixels). If -1 is returned, then the item text + width is used. The default implementation returns -1. + """ + return _combo.OwnerDrawnComboBox_OnMeasureItemWidth(*args, **kwargs) + + def OnDrawBackground(*args, **kwargs): + """ + OnDrawBackground(self, DC dc, Rect rect, int item, int flags) + + This method is used to draw the items background and, maybe, a border + around it. + + The base class version implements a reasonable default behaviour which + consists in drawing the selected item with the standard background + colour and drawing a border around the item if it is either selected + or current. ``flags`` has the sam meaning as with `OnDrawItem`. + """ + return _combo.OwnerDrawnComboBox_OnDrawBackground(*args, **kwargs) + _combo.OwnerDrawnComboBox_swigregister(OwnerDrawnComboBox) def PreOwnerDrawnComboBox(*args, **kwargs): - """PreOwnerDrawnComboBox() -> OwnerDrawnComboBox""" + """ + PreOwnerDrawnComboBox() -> OwnerDrawnComboBox + + 2-phase create constructor. + """ val = _combo.new_PreOwnerDrawnComboBox(*args, **kwargs) return val +class BitmapComboBox(OwnerDrawnComboBox): + """ + A combobox that displays a bitmap in front of the list items. It + currently only allows using bitmaps of one size, and resizes itself so + that a bitmap can be shown next to the text field. + """ + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self, *args, **kwargs): + """ + __init__(self, Window parent, int id=-1, String value=EmptyString, + Point pos=DefaultPosition, Size size=DefaultSize, + wxArrayString choices=wxPyEmptyStringArray, + long style=0, Validator validator=DefaultValidator, + String name=wxBitmapComboBoxNameStr) -> BitmapComboBox + + Standard constructor + """ + _combo.BitmapComboBox_swiginit(self,_combo.new_BitmapComboBox(*args, **kwargs)) + self._setOORInfo(self); + + def Create(*args, **kwargs): + """ + Create(self, Window parent, int id=-1, String value=EmptyString, + Point pos=DefaultPosition, Size size=DefaultSize, + wxArrayString choices=wxPyEmptyStringArray, + long style=0, Validator validator=DefaultValidator, + String name=wxBitmapComboBoxNameStr) -> bool + + Create the UI object, and other initialization. + """ + return _combo.BitmapComboBox_Create(*args, **kwargs) + + def Append(*args, **kwargs): + """ + Append(self, String item, Bitmap bitmap=wxNullBitmap, PyObject clientData=None) -> int + + Adds the item to the control, associating the given data with the item + if not None. The return value is the index of the newly added item. + """ + return _combo.BitmapComboBox_Append(*args, **kwargs) + + def GetItemBitmap(*args, **kwargs): + """ + GetItemBitmap(self, int n) -> Bitmap + + Returns the image of the item with the given index. + """ + return _combo.BitmapComboBox_GetItemBitmap(*args, **kwargs) + + def Insert(*args, **kwargs): + """ + Insert(self, String item, Bitmap bitmap, int pos, PyObject clientData=None) -> int + + Insert an item into the control before the item at the ``pos`` index, + optionally associating some data object with the item. + """ + return _combo.BitmapComboBox_Insert(*args, **kwargs) + + def SetItemBitmap(*args, **kwargs): + """ + SetItemBitmap(self, int n, Bitmap bitmap) + + Sets the image for the given item. + """ + return _combo.BitmapComboBox_SetItemBitmap(*args, **kwargs) + + def GetBitmapSize(*args, **kwargs): + """ + GetBitmapSize(self) -> Size + + Returns size of the image used in list. + """ + return _combo.BitmapComboBox_GetBitmapSize(*args, **kwargs) + +_combo.BitmapComboBox_swigregister(BitmapComboBox) + +def PreBitmapComboBox(*args, **kwargs): + """ + PreBitmapComboBox() -> BitmapComboBox + + 2-phase create constructor. + """ + val = _combo.new_PreBitmapComboBox(*args, **kwargs) + return val +