xoomer.virgilio.it
Open in
urlscan Pro
213.209.30.138
Public Scan
Submitted URL: http://xoomer.virgilio.it/infinity77/wxPython/wxFunctions.html
Effective URL: https://xoomer.virgilio.it/infinity77/wxPython/wxFunctions.html
Submission Tags: falconsandbox
Submission: On July 21 via api from US — Scanned from IT
Effective URL: https://xoomer.virgilio.it/infinity77/wxPython/wxFunctions.html
Submission Tags: falconsandbox
Submission: On July 21 via api from US — Scanned from IT
Form analysis 1 forms found in the DOM
GET search.html
<form class="search" action="search.html" method="get">
<input type="text" name="q" size="18"> <input type="submit" value="Go">
<input type="hidden" name="check_keywords" value="yes">
<input type="hidden" name="area" value="default">
</form>Text Content
NAVIGATION
* index
* modules |
*
* Home |
* Search |
* Gallery |
* Documentation »
WXPYTHON FUNCTIONS¶
The functions and macros defined in wxPython are described here: you can look up
a function using the alphabetical listing of them.
FUNCTIONS SUMMARY¶
A | B | C | D | E | F | G | H | I | K | L | M | N | P | Q | R | S | T | U | V |
W | Y
A¶
* AboutBox
* AcceleratorEntry_Create
* App_CleanUp
* ArtProvider_Delete
* ArtProvider_GetBitmap
* ArtProvider_GetIcon
* ArtProvider_GetSizeHint
* ArtProvider_Insert
* ArtProvider_Pop
* ArtProvider_Push
* AutoBufferedPaintDCFactory
B¶
* BeginBusyCursor
* Bell
* BitmapFromBits
* BitmapFromBuffer
* BitmapFromBufferRGBA
* BitmapFromIcon
* BitmapFromImage
* BitmapFromXPMData
* BookCtrlBase_GetClassDefaultAttributes
* BrushFromBitmap
* Button_GetClassDefaultAttributes
* Button_GetDefaultSize
C¶
* CallAfter
* Caret_GetBlinkTime
* Caret_SetBlinkTime
* CheckBox_GetClassDefaultAttributes
* Choice_GetClassDefaultAttributes
* ClientDisplayRect
* Clipboard_Get
* ColorRGB
* ColourDisplay
* ColourRGB
* ComboBox_GetClassDefaultAttributes
* ConfigBase_Create
* ConfigBase_DontCreateOnDemand
* ConfigBase_Get
* ConfigBase_Set
* Control_GetClassDefaultAttributes
* CreateFileTipProvider
* CursorFromImage
* CustomDataFormat
D¶
* DLG_PNT
* DLG_SZE
* DROP_ICON
* DateSpan_Day
* DateSpan_Days
* DateSpan_Month
* DateSpan_Months
* DateSpan_Week
* DateSpan_Weeks
* DateSpan_Year
* DateSpan_Years
* DateTimeFromDMY
* DateTimeFromDateTime
* DateTimeFromHMS
* DateTimeFromJDN
* DateTimeFromTimeT
* DateTime_ConvertYearToBC
* DateTime_GetAmPmStrings
* DateTime_GetBeginDST
* DateTime_GetCentury
* DateTime_GetCountry
* DateTime_GetCurrentMonth
* DateTime_GetCurrentYear
* DateTime_GetEndDST
* DateTime_GetMonthName
* DateTime_GetNumberOfDaysInMonth
* DateTime_GetNumberOfDaysInYear
* DateTime_GetWeekDayName
* DateTime_IsDSTApplicable
* DateTime_IsLeapYear
* DateTime_IsWestEuropeanCountry
* DateTime_Now
* DateTime_SetCountry
* DateTime_SetToWeekOfYear
* DateTime_Today
* DateTime_UNow
* Dialog_GetClassDefaultAttributes
* DirSelector
* DisplayDepth
* DisplaySize
* DisplaySizeMM
* Display_GetCount
* Display_GetFromPoint
* Display_GetFromWindow
* DragIcon
* DragListItem
* DragString
* DragTreeItem
* DrawWindowOnDC
E¶
* EmptyBitmap
* EmptyBitmapRGBA
* EmptyIcon
* EmptyImage
* EnableTopLevelWindows
* EncodingConverter_CanConvert
* EncodingConverter_GetAllEquivalents
* EncodingConverter_GetPlatformEquivalents
* EndBusyCursor
* Execute
* Exit
* ExpandEnvVars
F¶
* FFont
* FFontFromPixelSize
* FileSelector
* FileSystem_AddHandler
* FileSystem_CleanUpHandlers
* FileSystem_FileNameToURL
* FileSystem_RemoveHandler
* FileSystem_URLToFileName
* FileTypeInfoSequence
* FileType_ExpandCommand
* FindWindowAtPoint
* FindWindowAtPointer
* FindWindowById
* FindWindowByLabel
* FindWindowByName
* Font2
* FontEnumerator_GetEncodings
* FontEnumerator_GetFacenames
* FontEnumerator_IsValidFacename
* FontFromNativeInfo
* FontFromNativeInfoString
* FontFromPixelSize
* FontMapper_Get
* FontMapper_GetDefaultConfigPath
* FontMapper_GetEncoding
* FontMapper_GetEncodingDescription
* FontMapper_GetEncodingFromName
* FontMapper_GetEncodingName
* FontMapper_GetSupportedEncodingsCount
* FontMapper_Set
* Font_GetDefaultEncoding
* Font_SetDefaultEncoding
* Frame_GetClassDefaultAttributes
G¶
* GBSizerItemSizer
* GBSizerItemSpacer
* GBSizerItemWindow
* Gauge_GetClassDefaultAttributes
* GenericFindWindowAtPoint
* GetAccelFromString
* GetActiveWindow
* GetApp
* GetBatteryState
* GetClientDisplayRect
* GetColourFromUser
* GetCurrentId
* GetCurrentTime
* GetDefaultPyEncoding
* GetDisplayDepth
* GetDisplaySize
* GetDisplaySizeMM
* GetElapsedTime
* GetEmailAddress
* GetFontFromUser
* GetFreeMemory
* GetFullHostName
* GetHomeDir
* GetHostName
* GetKeyState
* GetLocalTime
* GetLocalTimeMillis
* GetLocale
* GetMousePosition
* GetMouseState
* GetNativeFontEncoding
* GetNumberFromUser
* GetOsDescription
* GetOsVersion
* GetPasswordFromUser
* GetPowerType
* GetProcessId
* GetSingleChoice
* GetSingleChoiceIndex
* GetStockHelpString
* GetStockLabel
* GetTextFromUser
* GetTopLevelParent
* GetTopLevelWindows
* GetTranslation
* GetUTCTime
* GetUserHome
* GetUserId
* GetUserName
* GetXDisplay
* GraphicsContext_Create
* GraphicsContext_CreateFromNative
* GraphicsContext_CreateFromNativeWindow
* GraphicsContext_CreateMeasuringContext
* GraphicsRenderer_GetDefaultRenderer
H¶
* HelpProvider_Get
* HelpProvider_Set
I¶
* IconBundleFromFile
* IconBundleFromIcon
* IconFromBitmap
* IconFromLocation
* IconFromXPMData
* IdleEvent_CanSend
* IdleEvent_GetMode
* IdleEvent_SetMode
* ImageFromBitmap
* ImageFromBuffer
* ImageFromData
* ImageFromDataWithAlpha
* ImageFromMime
* ImageFromStream
* ImageFromStreamMime
* ImageHistogram_MakeKey
* Image_AddHandler
* Image_CanRead
* Image_CanReadStream
* Image_GetHandlers
* Image_GetImageCount
* Image_GetImageExtWildcard
* Image_HSVtoRGB
* Image_InsertHandler
* Image_RGBtoHSV
* Image_RemoveHandler
* InitAllImageHandlers
* IntersectRect
* IsBusy
* IsDragResultOk
* IsPlatform64Bit
* IsPlatformLittleEndian
* IsStockID
* IsStockLabel
K¶
* Kill
L¶
* LaunchDefaultBrowser
* ListBox_GetClassDefaultAttributes
* ListCtrl_GetClassDefaultAttributes
* LoadFileSelector
* Locale_AddCatalogLookupPathPrefix
* Locale_AddLanguage
* Locale_FindLanguageInfo
* Locale_GetLanguageInfo
* Locale_GetLanguageName
* Locale_GetSystemEncoding
* Locale_GetSystemEncodingName
* Locale_GetSystemLanguage
* Locale_IsAvailable
* LogDebug
* LogError
* LogFatalError
* LogGeneric
* LogInfo
* LogMessage
* LogStatus
* LogStatusFrame
* LogSysError
* LogTrace
* LogVerbose
* LogWarning
* Log_AddTraceMask
* Log_ClearTraceMasks
* Log_DontCreateOnDemand
* Log_EnableLogging
* Log_FlushActive
* Log_GetActiveTarget
* Log_GetLogLevel
* Log_GetRepetitionCounting
* Log_GetTimestamp
* Log_GetTraceMask
* Log_GetTraceMasks
* Log_GetVerbose
* Log_IsAllowedTraceMask
* Log_IsEnabled
* Log_OnLog
* Log_RemoveTraceMask
* Log_Resume
* Log_SetActiveTarget
* Log_SetLogLevel
* Log_SetRepetitionCounting
* Log_SetTimestamp
* Log_SetTraceMask
* Log_SetVerbose
* Log_Suspend
* Log_TimeStamp
M¶
* MaskColour
* MemoryDCFromDC
* MemoryFSHandler_AddFile
* MemoryFSHandler_AddFileWithMimeType
* MemoryFSHandler_RemoveFile
* MenuBar_GetAutoWindowMenu
* MenuBar_MacSetCommonMenuBar
* MenuBar_SetAutoWindowMenu
* MenuItem_GetDefaultMarginWidth
* MenuItem_GetLabelFromText
* MenuItem_GetLabelText
* MessageBox
* MicroSleep
* MilliSleep
* MimeTypesManager_IsOfType
* MutexGuiEnter
* MutexGuiLeave
N¶
* NamedColor
* NamedColour
* NewEventType
* NewId
* Notebook_GetClassDefaultAttributes
* Now
* NullFileTypeInfo
P¶
* Panel_GetClassDefaultAttributes
* Point2DCopy
* Point2DFromPoint
* PostEvent
* PostScriptDC_GetResolution
* PostScriptDC_SetResolution
* PreBitmapButton
* PreButton
* PreCheckBox
* PreCheckListBox
* PreChoice
* PreChoicebook
* PreCollapsiblePane
* PreColourPickerCtrl
* PreComboBox
* PreControl
* PreDatePickerCtrl
* PreDialog
* PreDirFilterListCtrl
* PreDirPickerCtrl
* PreFilePickerCtrl
* PreFindReplaceDialog
* PreFontPickerCtrl
* PreFrame
* PreGauge
* PreGenericDatePickerCtrl
* PreGenericDirCtrl
* PreHtmlListBox
* PreHyperlinkCtrl
* PreListBox
* PreListCtrl
* PreListView
* PreListbook
* PreMDIChildFrame
* PreMDIClientWindow
* PreMDIParentFrame
* PreMiniFrame
* PreNotebook
* PrePanel
* PrePopupTransientWindow
* PrePopupWindow
* PrePyAxBaseWindow
* PrePyControl
* PrePyPanel
* PrePyScrolledWindow
* PrePyWindow
* PreRadioBox
* PreRadioButton
* PreSashLayoutWindow
* PreSashWindow
* PreScrollBar
* PreScrolledWindow
* PreSearchCtrl
* PreSimpleHtmlListBox
* PreSingleInstanceChecker
* PreSlider
* PreSpinButton
* PreSpinCtrl
* PreSplitterWindow
* PreStaticBitmap
* PreStaticBox
* PreStaticLine
* PreStaticText
* PreStatusBar
* PreTextCtrl
* PreToggleButton
* PreToolBar
* PreToolbook
* PreTreeCtrl
* PreTreebook
* PreVListBox
* PreVScrolledWindow
* PreWindow
* Printer_GetLastError
* Process_Exists
* Process_Kill
* Process_Open
* PyApp_GetComCtl32Version
* PyApp_GetMacAboutMenuItemId
* PyApp_GetMacExitMenuItemId
* PyApp_GetMacHelpMenuTitleName
* PyApp_GetMacPreferencesMenuItemId
* PyApp_GetMacSupportPCMenuShortcuts
* PyApp_IsDisplayAvailable
* PyApp_IsMainLoopRunning
* PyApp_SetMacAboutMenuItemId
* PyApp_SetMacExitMenuItemId
* PyApp_SetMacHelpMenuTitleName
* PyApp_SetMacPreferencesMenuItemId
* PyApp_SetMacSupportPCMenuShortcuts
* PyAxBaseWindow_FromHWND
Q¶
* Quantize_Quantize
R¶
* RadioBox_GetClassDefaultAttributes
* RadioButton_GetClassDefaultAttributes
* RectPP
* RectPS
* RectS
* RegionFromBitmap
* RegionFromBitmapColour
* RegionFromPoints
* RegisterId
* RendererNative_Get
* RendererNative_GetDefault
* RendererNative_GetGeneric
* RendererNative_Set
* RendererVersion_IsCompatible
* Renderer_DrawChoice
* Renderer_DrawComboBox
* Renderer_DrawRadioButton
* Renderer_DrawTextCtrl
S¶
* SafeShowMessage
* SafeYield
* SaveFileSelector
* ScrollBar_GetClassDefaultAttributes
* ScrolledWindow_GetClassDefaultAttributes
* SetCursor
* SetDefaultPyEncoding
* Shell
* ShowTip
* Shutdown
* SizerFlags_GetDefaultBorder
* SizerItemSizer
* SizerItemSpacer
* SizerItemWindow
* Sleep
* Slider_GetClassDefaultAttributes
* SoundFromData
* Sound_PlaySound
* Sound_Stop
* SpinButton_GetClassDefaultAttributes
* SpinCtrl_GetClassDefaultAttributes
* SplitterWindow_GetClassDefaultAttributes
* StandardPaths_Get
* StartTimer
* StaticBitmap_GetClassDefaultAttributes
* StaticBox_GetClassDefaultAttributes
* StaticLine_GetClassDefaultAttributes
* StaticLine_GetDefaultSize
* StaticText_GetClassDefaultAttributes
* StatusBar_GetClassDefaultAttributes
* StockCursor
* StockGDI_DeleteAll
* StockGDI_GetBrush
* StockGDI_GetColour
* StockGDI_GetCursor
* StockGDI_GetPen
* StockGDI_instance
* StripMenuCodes
* SysErrorCode
* SysErrorMsg
* SystemOptions_GetOption
* SystemOptions_GetOptionInt
* SystemOptions_HasOption
* SystemOptions_IsFalse
* SystemOptions_SetOption
* SystemOptions_SetOptionInt
* SystemSettings_GetColour
* SystemSettings_GetFont
* SystemSettings_GetMetric
* SystemSettings_GetScreenType
* SystemSettings_HasFeature
* SystemSettings_SetScreenType
T¶
* TestFontEncoding
* TextAttr_Combine
* TextAttr_Merge
* TextCtrl_GetClassDefaultAttributes
* Thread_IsMain
* TimeSpan_Day
* TimeSpan_Days
* TimeSpan_Hour
* TimeSpan_Hours
* TimeSpan_Millisecond
* TimeSpan_Milliseconds
* TimeSpan_Minute
* TimeSpan_Minutes
* TimeSpan_Second
* TimeSpan_Seconds
* TimeSpan_Week
* TimeSpan_Weeks
* ToggleButton_GetClassDefaultAttributes
* ToolBar_GetClassDefaultAttributes
* ToolTip_Enable
* ToolTip_SetDelay
* Trap
* TreeCtrl_GetClassDefaultAttributes
U¶
* UpdateUIEvent_CanUpdate
* UpdateUIEvent_GetMode
* UpdateUIEvent_GetUpdateInterval
* UpdateUIEvent_ResetUpdateTime
* UpdateUIEvent_SetMode
* UpdateUIEvent_SetUpdateInterval
* Usleep
V¶
* Validator_IsSilent
* Validator_SetBellOnError
* version
W¶
* WakeUpIdle
* WakeUpMainThread
* Window_FindFocus
* Window_FromHWND
* Window_GetCapture
* Window_GetClassDefaultAttributes
* Window_NewControlId
* Window_NextControlId
* Window_PrevControlId
Y¶
* Yield
* YieldIfNeeded
FUNCTIONS¶
AboutBox(info)¶
This function shows the standard about dialog containing the information
specified in info. If the current platform has a native about dialog which is
capable of showing all the fields in wx.AboutDialogInfo, the native dialog is
used, otherwise the function falls back to the generic wxWidgets version of the
dialog.
Here is an example of how this function may be used:
def ShowSimpleAboutDialog(event):
info = wx.AboutDialogInfo()
info.SetName("My Program")
info.SetVersion("1.2.3 Beta")
info.SetDescription("This program does something great.")
info.SetCopyright("(C) 2007 Me <my@email.addre.ss>")
wx.AboutBox(info)
Parameters:
* info (wx.AboutDialogInfo)
--------------------------------------------------------------------------------
AcceleratorEntry_Create(str)¶
Create accelerator corresponding to the specified string, or None if it coulnd’t
be parsed.
Parameters:
* str (string)
Returns:
wx.AcceleratorEntry
--------------------------------------------------------------------------------
App_CleanUp()¶ For internal use only, it is used to cleanup after wxWidgets when
Python shuts down.
--------------------------------------------------------------------------------
ArtProvider_Delete(provider)¶
Remove provider. The provider must have been added previously! The provider is
not deleted.
Parameters:
* provider (wx.ArtProvider)
Returns:
bool
--------------------------------------------------------------------------------
ArtProvider_GetBitmap(id, client=wx.ART_OTHER, size=wx.DefaultSize)¶
Query the providers for bitmap with given ID and return it.
Returns wx.NullBitmap if no provider provides it.
Parameters:
* id (string)
* client (string)
* size (wx.Size)
Returns:
wx.Bitmap
--------------------------------------------------------------------------------
ArtProvider_GetIcon(id, client=wx.ART_OTHER, size=wx.DefaultSize)¶
Query the providers for icon with given ID and return it.
Returns wx.NullIcon if no provider provides it.
Parameters:
* id (string)
* client (string)
* size (wx.Size)
Returns:
wx.Icon
--------------------------------------------------------------------------------
ArtProvider_GetSizeHint(client, platform_dependent=False)¶
Get the size hint of an icon from a specific Art Client, queries the topmost
provider if platform_dependent is False.
Parameters:
* client (string)
* platform_dependent (bool)
Returns:
wx.Size
--------------------------------------------------------------------------------
ArtProvider_Insert(provider)¶
Add new provider to the bottom of providers stack.
Parameters:
* provider (wx.ArtProvider)
--------------------------------------------------------------------------------
ArtProvider_Pop()¶
Remove latest added provider and delete it.
Returns:
bool
--------------------------------------------------------------------------------
ArtProvider_Push(provider)¶
Add new provider to the top of providers stack.
Parameters:
* provider (wx.ArtProvider)
--------------------------------------------------------------------------------
AutoBufferedPaintDCFactory(window)¶
Checks if the window is natively double buffered and will return a wx.PaintDC if
it is, a wx.BufferedPaintDC otherwise.
The advantage of this function over wx.AutoBufferedPaintDC is that this function
will check if the the specified window has double-buffering enabled rather than
just going by platform defaults.
Parameters:
* window (wx.Window)
Returns:
wx.DC
--------------------------------------------------------------------------------
BeginBusyCursor(cursor=wx.HOURGLASS_CURSOR)¶
Changes the cursor to the given cursor for all windows in the application. Use
wx.EndBusyCursor to revert the cursor back to its previous state. These two
calls can be nested, and a counter ensures that only the outer calls take
effect.
Parameters:
* cursor (wx.Cursor)
See also
IsBusy, BusyCursor
--------------------------------------------------------------------------------
Bell()¶ Rings the system bell.
--------------------------------------------------------------------------------
BitmapFromBits(bits, width, height, depth=1)¶
Creates a bitmap from an array of bits.
You should only use this function for monochrome bitmaps (depth 1) in portable
programs: in this case the bits parameter should contain an XBM image.
For other bit depths, the behaviour is platform dependent.
Parameters:
* bits (PyObject)
* width (int)
* height (int)
* depth (int)
Returns:
wx.Bitmap
--------------------------------------------------------------------------------
BitmapFromBuffer(width, height, dataBuffer, alphaBuffer=None)¶
Creates a wx.Bitmap from the data in dataBuffer.
The dataBuffer parameter must be a Python object that implements the buffer
interface, such as a string, array, etc.
The dataBuffer object is expected to contain a series of RGB bytes and be
width*height*3 bytes long. A buffer object can optionally be supplied for the
image’s alpha channel data, and it is expected to be width*height bytes long.
On Windows and Mac the RGB values are ‘premultiplied’ by the alpha values. (The
other platforms do the multiplication themselves.)
Unlike wx.ImageFromBuffer the bitmap created with this function does not share
the memory buffer with the buffer object. This is because the native pixel
buffer format varies on different platforms, and so instead an efficient as
possible copy of the data is made from the buffer objects to the bitmap’s native
pixel buffer.
For direct access to a bitmap’s pixel buffer see wx.NativePixelData and
wx.AlphaPixelData.
Parameters:
* width (int)
* height (int)
* dataBuffer (PyObject)
* alphaBuffer (PyObject)
See also
wx.Bitmap, wx.BitmapFromBufferRGBA, wx.NativePixelData, wx.AlphaPixelData,
wx.ImageFromBuffer
--------------------------------------------------------------------------------
BitmapFromBufferRGBA(width, height, dataBuffer)¶
Creates a wx.Bitmap from the data in dataBuffer.
The dataBuffer parameter must be a Python object that implements the buffer
interface, such as a string, array, etc.
The dataBuffer object is expected to contain a series of RGB bytes and be
width*height*3 bytes long. A buffer object can optionally be supplied for the
image’s alpha channel data, and it is expected to be width*height bytes long.
On Windows and Mac the RGB values are ‘premultiplied’ by the alpha values. (The
other platforms do the multiplication themselves.)
Unlike wx.ImageFromBuffer the bitmap created with this function does not share
the memory buffer with the buffer object. This is because the native pixel
buffer format varies on different platforms, and so instead an efficient as
possible copy of the data is made from the buffer objects to the bitmap’s native
pixel buffer.
For direct access to a bitmap’s pixel buffer see wx.NativePixelData and
wx.AlphaPixelData.
Parameters:
* width (int)
* height (int)
* dataBuffer (PyObject)
See also
wx.Bitmap, wx.BitmapFromBuffer, wx.NativePixelData, wx.AlphaPixelData,
wx.ImageFromBuffer
--------------------------------------------------------------------------------
BitmapFromIcon(icon)¶
Create a new bitmap from a wx.Icon object.
Parameters:
* icon (wx.Icon)
Returns:
wx.Bitmap
--------------------------------------------------------------------------------
BitmapFromImage(image, depth=-1)¶
Creates bitmap object from a wx.Image.
This has to be done to actually display a wx.Image as you cannot draw an image
directly on a window. The resulting bitmap will use the provided colour depth
(or that of the current screen colour depth if depth is -1) which entails that a
colour reduction may have to take place.
Parameters:
* image (wx.Image)
* depth (int)
Returns:
wx.Bitmap
--------------------------------------------------------------------------------
BitmapFromXPMData(listOfStrings)¶
Construct a Bitmap from a list of strings formatted as XPM data.
Parameters:
* listOfStrings (list of strings)
Returns:
wx.Bitmap
--------------------------------------------------------------------------------
BookCtrlBase_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
BrushFromBitmap(stippleBitmap)¶
Constructs a stippled brush using a bitmap.
Parameters:
* stippleBitmap (wx.Bitmap)
Returns:
wx.Brush
--------------------------------------------------------------------------------
Button_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
Button_GetDefaultSize()¶
Returns the default button size for this platform.
Returns:
wx.Size
--------------------------------------------------------------------------------
CallAfter(callable)¶
Call the specified function after the current and pending event handlers have
been completed.
This is also good for making GUI method calls from non-GUI threads.
Any extra positional or keyword args are passed on to the callable when it is
called.
Parameters:
* callable (PyObject)
See also
wx.CallLater
--------------------------------------------------------------------------------
Caret_GetBlinkTime()¶
See wx.Caret.GetBlinkTime
Returns:
int
--------------------------------------------------------------------------------
Caret_SetBlinkTime(milliseconds)¶
See wx.Caret.SetBlinkTime
Parameters:
* milliseconds (int)
--------------------------------------------------------------------------------
CheckBox_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
Choice_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
ClientDisplayRect()¶
Returns the dimensions of the work area on the display.
On Windows this means the area not covered by the taskbar, etc... Other
platforms are currently defaulting to the whole display until a way is found to
provide this info for all window managers, etc.
Returns:
(x, y, width, height)
--------------------------------------------------------------------------------
Clipboard_Get()¶
Returns global instance (wx.TheClipboard) of the object.
Returns:
wx.Clipboard
--------------------------------------------------------------------------------
ColorRGB()¶
Constructs a colour from a packed RGB value.
Returns:
wx.Colour
--------------------------------------------------------------------------------
ColourDisplay()¶
Returns True if the display is colour, False otherwise.
Returns:
bool
--------------------------------------------------------------------------------
ColourRGB()¶
Constructs a colour from a packed RGB value.
Returns:
wx.Colour
--------------------------------------------------------------------------------
ComboBox_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
ConfigBase_Create()¶
Create and return a new global config object.
This function will create the “best” implementation of wx.Config available for
the current platform.
Returns:
wx.ConfigBase
--------------------------------------------------------------------------------
ConfigBase_DontCreateOnDemand()¶ Should Get() try to create a new log object if
there isn’t a current one?
--------------------------------------------------------------------------------
ConfigBase_Get(createOnDemand=True)¶
Returns the current global config object, creating one if neccessary.
Parameters:
* createOnDemand (bool)
Returns:
wx.ConfigBase
--------------------------------------------------------------------------------
ConfigBase_Set(config)¶
Sets the global config object (the one returned by Get) and returns a reference
to the previous global config object.
Parameters:
* config (wx.ConfigBase)
Returns:
wx.ConfigBase
--------------------------------------------------------------------------------
Control_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
CreateFileTipProvider(filename, currentTip)¶
This function creates a wx.TipProvider which may be used with wx.ShowTip.
Parameters:
* filename (string): The name of the file containing the tips, one per line.
* currentTip (int): The index of the first tip to show – normally the index is
remembered between the 2 program runs.
Returns:
wx.TipProvider
--------------------------------------------------------------------------------
CursorFromImage(image)¶
Constructs a cursor from a wx.Image. The mask (if any) will be used for setting
the transparent portions of the cursor.
Parameters:
* image (wx.Image)
Returns:
wx.Cursor
--------------------------------------------------------------------------------
CustomDataFormat(format)¶
Constructs a data format object for a custom format identified by its name.
Parameters:
* format (string)
Returns:
wx.DataFormat
--------------------------------------------------------------------------------
DLG_PNT(win, point_or_x, y=None)¶
Convenience function for converting a wx.Point or (x, y) in dialog units to
pixel units.
Parameters:
* win (wx.Window)
* point_or_x
* y (int)
--------------------------------------------------------------------------------
DLG_SZE(win, size_width, height=None)¶
Convenience function for converting a wx.Size or (w, h) in dialog units to pixel
units.
Parameters:
* win (wx.Window)
* size_width
* height (int)
--------------------------------------------------------------------------------
DROP_ICON(filename)¶
Returns either a wx.Cursor or wx.Icon created from the image file filename. This
function is useful with the wx.DropSource class which, depending on platform
accepts either a icon or a cursor.
Parameters:
* filename (string)
--------------------------------------------------------------------------------
DateSpan_Day()¶
See wx.DateSpan.Day
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateSpan_Days(days)¶
See wx.DateSpan.Days
Parameters:
* days (int)
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateSpan_Month()¶
See wx.DateSpan.Month
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateSpan_Months(mon)¶
See wx.DateSpan.Months
Parameters:
* mon (int)
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateSpan_Week()¶
See wx.DateSpan.Week
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateSpan_Weeks(weeks)¶
See wx.DateSpan.Weeks
Parameters:
* weeks (int)
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateSpan_Year()¶
See wx.DateSpan.Year
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateSpan_Years(years)¶
See wx.DateSpan.Years
Parameters:
* years (int)
Returns:
wx.DateSpan
--------------------------------------------------------------------------------
DateTimeFromDMY(day, month=wx.DateTime.Inv_Month, year=wx.DateTime.Inv_Year,
hour=0, minute=0, second=0, millisec=0)¶
Creates a wx.DateTime object from a day-month-year triplet plus optional hour,
minute, second and millisecond parameters.
Parameters:
* day (int)
* month (int)
* year (int)
* hour (int)
* minute (int)
* second (int)
* millisec (int)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTimeFromDateTime(date)¶
Creates a wx.DateTime object from a wx.DateTime object.
Parameters:
* date (wx.DateTime)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTimeFromHMS(hour, minute=0, second=0, millisec=0)¶
Creates a wx.DateTime object from a hour-minute-second-millisecond quadruplet.
Parameters:
* hour (int)
* minute (int)
* second (int)
* millisec (int)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTimeFromJDN(jdn)¶
Creates a wx.DateTime object from Julian Day Number.
Parameters:
* jdn (double)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTimeFromTimeT(timet)¶
Parameters:
* timet (time_t)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTime_ConvertYearToBC(year)¶
See wx.DateTime.ConvertYearToBC.
Parameters:
* year (int)
Returns:
int
--------------------------------------------------------------------------------
DateTime_GetAmPmStrings()¶
Get the AM and PM strings in the current locale (may be empty)
Returns:
(am, pm)
--------------------------------------------------------------------------------
DateTime_GetBeginDST(year=wx.DateTime.Inv_Year,
country=wx.DateTime.Country_Default)¶
See wx.DateTime.GetBeginDST.
Parameters:
* year (int)
* country (int)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTime_GetCentury(year=wx.DateTime.Inv_Year)¶
See wx.DateTime.GetCentury.
Parameters:
* year (int)
Returns:
int
--------------------------------------------------------------------------------
DateTime_GetCountry()¶
See wx.DateTime.GetCountry.
Returns:
int
--------------------------------------------------------------------------------
DateTime_GetCurrentMonth(cal=wx.DateTime.Gregorian)¶
See wx.DateTime.GetCurrentMonth.
Parameters:
* cal (int)
Returns:
int
--------------------------------------------------------------------------------
DateTime_GetCurrentYear(cal=Gregorian)¶
See wx.DateTime.GetCurrentYear.
Parameters:
* cal (int)
Returns:
int
--------------------------------------------------------------------------------
DateTime_GetEndDST(year=wx.DateTime.Inv_Year,
country=wx.DateTime.Country_Default)¶
See wx.DateTime.GetEndDST.
Parameters:
* year (int)
* country (int)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTime_GetMonthName(month, flags=wx.DateTime.Name_Full)¶
See wx.DateTime.GetMonthName.
Parameters:
* month (int)
* flags (int)
Returns:
String
--------------------------------------------------------------------------------
DateTime_GetNumberOfDaysInMonth(month, year=wx.DateTime.Inv_Year,
cal=wx.DateTime.Gregorian)¶
See wx.DateTime.GetNumberOfDaysInMonth.
Parameters:
* month (int)
* year (int)
* cal (int)
Returns:
int
--------------------------------------------------------------------------------
DateTime_GetNumberOfDaysInYear(year, cal=wx.DateTime.Gregorian)¶
See wx.DateTime.GetNumberOfDaysInYear.
Parameters:
* year (int)
* cal (int)
Returns:
int
--------------------------------------------------------------------------------
DateTime_GetWeekDayName(weekday, flags=wx.DateTime.Name_Full)¶
See wx.DateTime.GetWeekDayName.
Parameters:
* weekday (int)
* flags (int)
Returns:
String
--------------------------------------------------------------------------------
DateTime_IsDSTApplicable(year=wx.DateTime.Inv_Year,
country=wx.DateTime.Country_Default)¶
See wx.DateTime.IsDSTApplicable.
Parameters:
* year (int)
* country (int)
Returns:
bool
--------------------------------------------------------------------------------
DateTime_IsLeapYear(year=wx.DateTime.Inv_Year, cal=wx.DateTime.Gregorian)¶
See wx.DateTime.IsLeapYear.
Parameters:
* year (int)
* cal (int)
Returns:
bool
--------------------------------------------------------------------------------
DateTime_IsWestEuropeanCountry(country=wx.DateTime.Country_Default)¶
See wx.DateTime.IsWestEuropeanCountry.
Parameters:
* country (int)
Returns:
bool
--------------------------------------------------------------------------------
DateTime_Now()¶
See wx.DateTime.Now.
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTime_SetCountry(country)¶
See wx.DateTime.SetCountry.
Parameters:
* country (int)
--------------------------------------------------------------------------------
DateTime_SetToWeekOfYear(year, numWeek, weekday=wx.DateTime.Mon)¶
See wx.DateTime.SetToWeekOfYear.
Parameters:
* year (int)
* numWeek (int)
* weekday (int)
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTime_Today()¶
See wx.DateTime.Today.
Returns:
wx.DateTime
--------------------------------------------------------------------------------
DateTime_UNow()¶
See wx.DateTime.UNow.
Returns:
wx.DateTime
--------------------------------------------------------------------------------
Dialog_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
DirSelector(message=wx.DirSelectorPromptStr, defaultPath="",
style=wx.DD_DEFAULT_STYLE, pos=wx.DefaultPosition, parent=None)¶
Pops up a directory selector dialog. The arguments have the same meaning as
those of wx.DirDialog.__init__. The message is displayed at the top, and the
defaultPath, if specified, is set as the initial selection.
The application must check for an empty return value (if the user pressed
Cancel). For example:
directory = wx.DirSelector("Choose a folder")
if not directory.strip():
# User cancelled the dialog...
DoSomething()
Parameters:
* message (string)
* defaultPath (string)
* style (long)
* pos (wx.Point)
* parent (wx.Window)
Returns:
string
--------------------------------------------------------------------------------
DisplayDepth()¶
Returns the depth of the display (a value of 1 denotes a monochrome display).
Returns:
int
--------------------------------------------------------------------------------
DisplaySize()¶
Returns the display size in pixels.
Returns:
(width, height)
--------------------------------------------------------------------------------
DisplaySizeMM()¶
Returns the display size in millimeters.
Returns:
(width, height)
--------------------------------------------------------------------------------
Display_GetCount()¶
Return the number of available displays.
Returns:
int
--------------------------------------------------------------------------------
Display_GetFromPoint(pt)¶
Find the display where the given point lies, return wx.NOT_FOUND if it doesn’t
belong to any display
Parameters:
* pt (wx.Point)
Returns:
int
--------------------------------------------------------------------------------
Display_GetFromWindow(window)¶
Find the display where the given window lies, return wx.NOT_FOUND if it is not
shown at all.
Parameters:
* window (wx.Window)
Returns:
int
--------------------------------------------------------------------------------
DragIcon(image, cursor=wx.NullCursor)¶
Constructs a drag image from an icon and optional cursor.
Parameters:
* image (wx.Icon)
* cursor (wx.Cursor)
Returns:
wx.DragImage
--------------------------------------------------------------------------------
DragListItem(listCtrl, id)¶
Constructs a drag image from the text in the given list control item, and
optional cursor.
Parameters:
* listCtrl (wx.ListCtrl)
* id (long)
Returns:
wx.DragImage
--------------------------------------------------------------------------------
DragString(str, cursor=wx.NullCursor)¶
Constructs a drag image from a text string and optional cursor.
Parameters:
* str (string)
* cursor (wx.Cursor)
Returns:
wx.DragImage
--------------------------------------------------------------------------------
DragTreeItem(treeCtrl, id)¶
Constructs a drag image from the text in the given tree control item, and
optional cursor.
Parameters:
* treeCtrl (wx.TreeCtrl)
* id (wx.TreeItemId)
Returns:
wx.DragImage
--------------------------------------------------------------------------------
DrawWindowOnDC(window, dc)¶
Parameters:
* window (wx.Window)
* dc (wx.DC)
Returns:
bool
--------------------------------------------------------------------------------
EmptyBitmap(width, height, depth=-1)¶
Creates a new bitmap of the given size. A depth of -1 indicates the depth of the
current screen or visual. Some platforms only support 1 for monochrome and -1
for the current display depth.
Parameters:
* width (int)
* height (int)
* depth (int)
Returns:
wx.Bitmap
--------------------------------------------------------------------------------
EmptyBitmapRGBA(width, height, red=0, green=0, blue=0, alpha=0)¶
Returns a new empty 32-bit bitmap where every pixel has been initialized with
the given RGBA values.
Parameters:
* width (int)
* height (int)
* red (int)
* green (int)
* blue (int)
* alpha (int)
Returns:
wx.Bitmap
--------------------------------------------------------------------------------
EmptyIcon()¶
Returns:
wx.Icon
--------------------------------------------------------------------------------
EmptyImage(width=0, height=0, clear=True)¶
Construct an empty image of a given size, optionally setting all pixels to
black.
Parameters:
* width (int)
* height (int)
* clear (bool)
Returns:
wx.Image
--------------------------------------------------------------------------------
EnableTopLevelWindows(enable)¶
This function enables or disables all top level windows. It is used by
wx.SafeYield.
Parameters:
* enable (bool)
--------------------------------------------------------------------------------
EncodingConverter_CanConvert(encIn, encOut)¶
See wx.EncodingConverter.CanConvert.
Parameters:
* encIn (int)
* encOut (int)
Returns:
bool
--------------------------------------------------------------------------------
EncodingConverter_GetAllEquivalents(enc)¶
See wx.EncodingConverter.GetAllEquivalents.
Parameters:
* enc (int)
Returns:
list of strings
--------------------------------------------------------------------------------
EncodingConverter_GetPlatformEquivalents(enc, platform=wx.PLATFORM_CURRENT)¶
See wx.EncodingConverter.GetPlatformEquivalents.
Parameters:
* enc (int)
* platform (int)
Returns:
list of strings
--------------------------------------------------------------------------------
EndBusyCursor()¶ Changes the cursor back to the original cursor, for all windows
in the application. Use with wx.BeginBusyCursor.
See also
IsBusy, BusyCursor
--------------------------------------------------------------------------------
Execute(command, flags=wx.EXEC_ASYNC, process=None)¶
Launches the specified process.
If flags parameter contains wx.EXEC_ASYNC flag (the default), flow of control
immediately returns. If it contains wx.EXEC_SYNC, the current application waits
until the other program has terminated.
In the case of synchronous execution, the return value is the exit code of the
process (which terminates by the moment the function returns) and will be -1 if
the process couldn’t be started and typically 0 if the process terminated
successfully. Also, while waiting for the process to terminate, wx.Execute will
call wx.Yield. Because of this, by default this function disables all
application windows to avoid unexpected reentrancies which could result from the
users interaction with the program while the child process is running. If you
are sure that it is safe to not disable the program windows, you may pass
wx.EXEC_NODISABLE flag to prevent this automatic disabling from happening.
For asynchronous execution, however, the return value is the process id and zero
value indicates that the command could not be executed. As an added
complication, the return value of -1 in this case indicates that we didn’t
launch a new process, but connected to the running one (this can only happen in
case of using DDE under Windows for command execution). In particular, in this,
and only this, case the calling code will not get the notification about process
termination.
Under Unix the flag wx.EXEC_MAKE_GROUP_LEADER may be used to ensure that the new
process is a group leader (this will create a new session if needed). Calling
wx.Kill passing wx.KILL_CHILDREN will kill this process as well as all of its
children (except those which have started their own session).
Parameters:
* command (string)
* flags (int)
* process (wx.Process)
Returns:
int
Note
Currently wx.Execute can only be used from the main thread, calling this
function from another thread will result in an assert failure in debug build and
won’t work.
--------------------------------------------------------------------------------
Exit()¶
Force an exit of the application.
Exits application after calling wx.App.OnExit. Should only be used in an
emergency: normally the top-level frame should be deleted (after deleting all
other frames) to terminate the application. See wx.CloseEvent.
--------------------------------------------------------------------------------
ExpandEnvVars(sz)¶
Replace environment variables ($SOMETHING) with their values. The format is
$VARNAME or ${VARNAME} where VARNAME contains alphanumeric characters and ‘_’
only. ‘$’ must be escaped (‘$’) in order to be taken literally.
Parameters:
* sz (string)
Returns:
string
--------------------------------------------------------------------------------
FFont(pointSize, family, flags=wx.FONTFLAG_DEFAULT, face="",
encoding=wx.FONTENCODING_DEFAULT)¶
A bit of a simpler way to create a wx.Font using flags instead of individual
attribute settings. The value of flags can be a combination of the following:
Font Flag wx.FONTFLAG_DEFAULT wx.FONTFLAG_ITALIC wx.FONTFLAG_SLANT
wx.FONTFLAG_LIGHT wx.FONTFLAG_BOLD wx.FONTFLAG_ANTIALIASED
wx.FONTFLAG_NOT_ANTIALIASED wx.FONTFLAG_UNDERLINED wx.FONTFLAG_STRIKETHROUGH
Parameters:
* pointSize (int)
* family (int)
* flags (int)
* face (string)
* encoding (int)
Returns:
wx.Font
See also
wx.Font
--------------------------------------------------------------------------------
FFontFromPixelSize(pixelSize, family, flags=wx.FONTFLAG_DEFAULT, face="",
encoding=wx.FONTENCODING_DEFAULT)¶
Creates a font using a size in pixels rather than points.
If there is platform API support for this then it is used, otherwise a font with
the closest size is found using a binary search.
Parameters:
* pixelSize (wx.Size)
* family (int)
* flags (int)
* face (string)
* encoding (int)
Returns:
wx.Font
See also
wx.Font
--------------------------------------------------------------------------------
FileSelector(message=wx.FileSelectorPromptStr, default_path="",
default_filename="", default_extension="",
wildcard=wx.FileSelectorDefaultWildcardStr, flags=0, parent=None, x=-1, y=-1)¶
Pops up a file selector box. In Windows, this is the common file selector
dialog. In X, this is a file selector box with the same functionality. The path
and filename are distinct elements of a full file pathname. If default_path is
empty, the current directory will be used. If default_filename is empty, no
default filename will be supplied. The wildcard determines what files are
displayed in the file selector, and file extension supplies a type extension for
the required filename. flags may be a combination of wx.FD_OPEN, wx.FD_SAVE,
wx.FD_OVERWRITE_PROMPT or wx.FD_FILE_MUST_EXIST.
Both the Unix and Windows versions implement a wildcard filter. Typing a
filename containing wildcards (*, ?) in the filename text item, and clicking on
Ok, will result in only those files matching the pattern being displayed.
The wildcard may be a specification for multiple types of file with a
description for each, such as:
"BMP files (*.bmp)|*.bmp | GIF files (*.gif)|*.gif"
The application must check for an empty return value (the user pressed Cancel).
For example:
filename = wx.FileSelector("Choose a file to open")
if filename.strip():
# work with the file
UserSelectedFile(filename)
else:
# cancelled by user
Cancelled()
Parameters:
* message (string)
* default_path (string)
* default_filename (string)
* default_extension (string)
* wildcard (string)
* flags (int)
* parent (wx.Window)
* x (int)
* y (int)
Returns:
string
Note
Note that wx.FD_MULTIPLE can only be used with wx.FileDialog and not here as
this function only returns a single file name.
--------------------------------------------------------------------------------
FileSystem_AddHandler(handler)¶
See wx.FileSystem.AddHandler.
Parameters:
* handler (wx.FileSystemHandler)
--------------------------------------------------------------------------------
FileSystem_CleanUpHandlers()¶ See wx.FileSystem.CleanUpHandlers.
--------------------------------------------------------------------------------
FileSystem_FileNameToURL(filename)¶
See wx.FileSystem.FileNameToURL.
Parameters:
* filename (string)
Returns:
string
--------------------------------------------------------------------------------
FileSystem_RemoveHandler(handler)¶
See wx.FileSystem.RemoveHandler.
Parameters:
* handler (wx.FileSystemHandler)
Returns:
wx.FileSystemHandler
--------------------------------------------------------------------------------
FileSystem_URLToFileName(url)¶
See wx.FileSystem.URLToFileName.
Parameters:
* url (string)
Returns:
string
--------------------------------------------------------------------------------
FileTypeInfoSequence(sArray)¶
Parameters:
* sArray (list of strings)
Returns:
wx.FileTypeInfo
--------------------------------------------------------------------------------
FileType_ExpandCommand(command, filename, mimetype="")¶
See wx.FileType.ExpandCommand.
Parameters:
* command (string)
* filename (string)
* mimetype (string)
Returns:
string
--------------------------------------------------------------------------------
FindWindowAtPoint(pt)¶
Returns the window currently at point pt. Otherwise it returns None.
Parameters:
* pt (wx.Point)
Returns:
wx.Window
--------------------------------------------------------------------------------
FindWindowAtPointer()¶
Returns the window currently under the mouse pointer, if it belongs to this
application. Otherwise it returns None.
Returns:
wx.Window
--------------------------------------------------------------------------------
FindWindowById(id, parent=None)¶
Find the first window in the application with the given id. If parent is None,
the search will start from all top-level frames and dialog boxes; if non-None,
the search will be limited to the given window hierarchy.
The search is recursive in both cases.
Parameters:
* id (long)
* parent (wx.Window)
Returns:
wx.Window
--------------------------------------------------------------------------------
FindWindowByLabel(label, parent=None)¶
Find a window by its label. Depending on the type of window, the label may be a
window title or panel item label. If parent is None, the search will start from
all top-level frames and dialog boxes; if non-None, the search will be limited
to the given window hierarchy.
The search is recursive in both cases.
Parameters:
* label (string)
* parent (wx.Window)
Returns:
wx.Window
--------------------------------------------------------------------------------
FindWindowByName(name, parent=None)¶
Find a window by its name (as given in a window constructor or Create function
call). If parent is None, the search will start from all top-level frames and
dialog boxes; if non-None, the search will be limited to the given window
hierarchy.
The search is recursive in both cases.
If no window with such name is found, wx.FindWindowByLabel is called.
Parameters:
* name (string)
* parent (wx.Window)
Returns:
wx.Window
--------------------------------------------------------------------------------
Font2()¶ Use wx.FFont instead.
--------------------------------------------------------------------------------
FontEnumerator_GetEncodings()¶
See wx.FontEnumerator.GetEncodings.
Returns:
PyObject
--------------------------------------------------------------------------------
FontEnumerator_GetFacenames()¶
See wx.FontEnumerator.GetFacenames.
Returns:
PyObject
--------------------------------------------------------------------------------
FontEnumerator_IsValidFacename(str)¶
Convenience function that returns True if the given face name exist in the
user’s system.
Parameters:
* str (string)
Returns:
bool
--------------------------------------------------------------------------------
FontFromNativeInfo(info)¶
Construct a wx.Font from a wx.NativeFontInfo object.
Parameters:
* info (wx.NativeFontInfo)
Returns:
wx.Font
--------------------------------------------------------------------------------
FontFromNativeInfoString(info)¶
Construct a wx.Font from the string representation of a wx.NativeFontInfo
object.
Parameters:
* info (string)
Returns:
wx.Font
--------------------------------------------------------------------------------
FontFromPixelSize(pixelSize, family, style, weight, underlined=False, face="",
encoding=wx.FONTENCODING_DEFAULT)¶
Creates a font using a size in pixels rather than points. If there is platform
API support for this then it is used, otherwise a font with the closest size is
found using a binary search.
Parameters:
* pixelSize (wx.Size)
* family (int)
* style (int)
* weight (int)
* underlined (bool)
* face (string)
* encoding (int)
Returns:
wx.Font
See also
wx.Font
--------------------------------------------------------------------------------
FontMapper_Get()¶
See wx.FontMapper.
Returns:
wx.FontMapper
--------------------------------------------------------------------------------
FontMapper_GetDefaultConfigPath()¶
See wx.FontMapper.GetDefaultConfigPath.
Returns:
string
--------------------------------------------------------------------------------
FontMapper_GetEncoding(n)¶
See wx.FontMapper.GetEncoding.
Parameters:
* n (int)
Returns:
int
--------------------------------------------------------------------------------
FontMapper_GetEncodingDescription(encoding)¶
See wx.FontMapper.GetEncodingDescription.
Parameters:
* encoding (int)
Returns:
string
--------------------------------------------------------------------------------
FontMapper_GetEncodingFromName(name)¶
See wx.FontMapper.GetEncodingFromName.
Parameters:
* name (string)
Returns:
int
--------------------------------------------------------------------------------
FontMapper_GetEncodingName(encoding)¶
See wx.FontMapper.GetEncodingName.
Parameters:
* encoding (int)
Returns:
string
--------------------------------------------------------------------------------
FontMapper_GetSupportedEncodingsCount()¶
See wx.FontMapper.GetSupportedEncodingsCount.
Returns:
int
--------------------------------------------------------------------------------
FontMapper_Set(mapper)¶
See wx.FontMapper.Set.
Parameters:
* mapper (wx.FontMapper)
Returns:
wx.FontMapper
--------------------------------------------------------------------------------
Font_GetDefaultEncoding()¶
Returns the encoding used for all fonts created with an encoding of
wx.FONTENCODING_DEFAULT.
Returns:
int
--------------------------------------------------------------------------------
Font_SetDefaultEncoding(encoding)¶
Sets the default font encoding.
Parameters:
* encoding (int)
--------------------------------------------------------------------------------
Frame_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
GBSizerItemSizer(sizer, pos, span, flag, border, userData=None)¶
Construct a wx.GBSizerItem for a sizer
Parameters:
* sizer (wx.Sizer)
* pos (wx.GBPosition)
* span (wx.GBSpan)
* flag (int)
* border (int)
* userData (PyObject)
Returns:
wx.GBSizerItem
--------------------------------------------------------------------------------
GBSizerItemSpacer(width, height, pos, span, flag, border, userData=None)¶
Construct a wx.GBSizerItem for a spacer.
Parameters:
* width (int)
* height (int)
* pos (wx.GBPosition)
* span (wx.GBSpan)
* flag (int)
* border (int)
* userData (PyObject)
Returns:
wx.GBSizerItem
--------------------------------------------------------------------------------
GBSizerItemWindow(window, pos, span, flag, border, userData=None)¶
Construct a wx.GBSizerItem for a window.
Parameters:
* window (wx.Window)
* pos (wx.GBPosition)
* span (wx.GBSpan)
* flag (int)
* border (int)
* userData (PyObject)
Returns:
wx.GBSizerItem
--------------------------------------------------------------------------------
Gauge_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
GenericFindWindowAtPoint(pt)¶
Parameters:
* pt (wx.Point)
Returns:
wx.Window
--------------------------------------------------------------------------------
GetAccelFromString(label)¶
Returns the accelerator string in a label.
Parameters:
* label (string)
Returns:
wx.AcceleratorEntry
--------------------------------------------------------------------------------
GetActiveWindow()¶
Get the currently active window of this application, or None.
Implemented in MSW and GTK+ only, returns None in other ports.
Returns:
wx.Window
--------------------------------------------------------------------------------
GetApp()¶
Returns a reference to the current wx.App object.
Returns:
wx.PyApp
--------------------------------------------------------------------------------
GetBatteryState()¶
Returns battery state as one of wx.BATTERY_NORMAL_STATE, wx.BATTERY_LOW_STATE,
wx.BATTERY_CRITICAL_STATE, wx.BATTERY_SHUTDOWN_STATE or
wx.BATTERY_UNKNOWN_STATE.
wx.BATTERY_UNKNOWN_STATE is also the default on platforms where this feature is
not implemented (currently everywhere but MS Windows).
Returns:
int
--------------------------------------------------------------------------------
GetClientDisplayRect()¶
Returns the dimensions of the work area on the display. On Windows this means
the area not covered by the taskbar, etc. Other platforms are currently
defaulting to the whole display until a way is found to provide this info for
all window managers, etc...
Returns:
wx.Rect
--------------------------------------------------------------------------------
GetColourFromUser(parent=None, colInit=wx.NullColour, caption="")¶
Shows the colour selection dialog and returns the colour selected by user or
invalid colour (use wx.Colour.IsOk to test whether a colour is valid) if the
dialog was cancelled.
Parameters:
* parent (wx.Window): The parent window for the colour selection dialog.
* colInit (wx.Colour): If given, this will be the colour initially selected in
the dialog.
* caption (string): If given, this will be used for the dialog caption.
Returns:
wx.Colour
--------------------------------------------------------------------------------
GetCurrentId()¶
Returns:
int
--------------------------------------------------------------------------------
GetCurrentTime()¶
Returns:
int
--------------------------------------------------------------------------------
GetDefaultPyEncoding()¶
Gets the current encoding that wxPython will use when it needs to convert a
Python string or unicode object to or from a wxString.
Returns:
string
--------------------------------------------------------------------------------
GetDisplayDepth()¶
Returns the depth of the display (a value of 1 denotes a monochrome display).
Returns:
int
--------------------------------------------------------------------------------
GetDisplaySize()¶
Returns the display size in pixels.
Returns:
wx.Size
--------------------------------------------------------------------------------
GetDisplaySizeMM()¶
Returns the display size in millimeters.
Returns:
wx.Size
--------------------------------------------------------------------------------
GetElapsedTime(resetTimer=True)¶
Gets the time in milliseconds since the last wx.StartTimer.
If resetTimer is true (the default), the timer is reset to zero by this call.
Warning
This function is deprecated.
--------------------------------------------------------------------------------
GetEmailAddress()¶
Returns the user’s email address, by concatenating the values returned by
wx.GetFullHostName and wx.GetUserId.
Returns:
string
--------------------------------------------------------------------------------
GetFontFromUser(parent=None, fontInit=wx.NullFont, caption="")¶
Shows the font selection dialog and returns the font selected by user or invalid
font (use wx.Font.IsOk to test whether a font is valid) if the dialog was
cancelled.
Parameters:
* parent (wx.Window): The parent window for the font selection dialog
* fontInit (wx.Font): If given, this will be the font initially selected in the
dialog.
* caption (string): If given, this will be used for the dialog caption
Returns:
wx.Font
--------------------------------------------------------------------------------
GetFreeMemory()¶
Returns the amount of free memory in bytes under environments which support it,
and -1 if not supported or failed to perform measurement.
Returns:
int
--------------------------------------------------------------------------------
GetFullHostName()¶
Returns the FQDN (fully qualified domain host name) or an empty string on error.
Returns:
string
See also
GetHostName
--------------------------------------------------------------------------------
GetHomeDir()¶
Returns the curent user’s home directory.
Returns:
string
See also
GetUserHome, wx.StandardPaths
--------------------------------------------------------------------------------
GetHostName()¶
Returns the hostname if successful or an empty string otherwise. Please note
that the returned name is not fully qualified, i.e. it does not include the
domain name.
Under Windows or NT, this function first looks in the environment variable
SYSTEM_NAME; if this is not found, the entry HostName in the wxWidgets section
of the WIN.INI file is tried.
Returns:
string
--------------------------------------------------------------------------------
GetKeyState(key)¶
Get the state of a key (True if pressed or toggled on, False if not).
This is generally most useful getting the state of the modifier or toggle keys.
On some platforms those may be the only keys that this function is able to
detect.
Parameters:
* key (int)
Returns:
bool
--------------------------------------------------------------------------------
GetLocalTime()¶
Returns the number of seconds since local time 00:00:00 Jan 1st 1970.
Returns:
int
See also
wx.DateTime.Now
--------------------------------------------------------------------------------
GetLocalTimeMillis()¶
Returns the number of milliseconds since local time 00:00:00 Jan 1st 1970.
Returns:
int
See also
wx.DateTime.Now
--------------------------------------------------------------------------------
GetLocale()¶
Returns the current locale.
Returns:
wx.Locale
--------------------------------------------------------------------------------
GetMousePosition()¶
Get the current mouse position on the screen.
Returns:
wx.Point
--------------------------------------------------------------------------------
GetMouseState()¶
Returns the current state of the mouse. Returns an instance of a wx.MouseState
object that contains the current position of the mouse pointer in screen
coordinants, as well as boolean values indicating the up/down status of the
mouse buttons and the modifier keys.
Returns:
wx.MouseState
--------------------------------------------------------------------------------
GetNativeFontEncoding(encoding)¶
Parameters:
* encoding (int)
Returns:
wx.NativeEncodingInfo
--------------------------------------------------------------------------------
GetNumberFromUser(message, prompt, caption, value, min=0, max=100, parent=None,
pos=wx.DefaultPosition)¶
Shows a dialog asking the user for numeric input. The dialogs title is set to
caption, it contains a (possibly) multiline message above the single line prompt
and the zone for entering the number.
The number entered must be in the range min ... max (both of which should be
positive) and value is the initial value of it. If the user enters an invalid
value or cancels the dialog, the function will return -1.
The dialog is centered on its parent unless an explicit position is given in
pos.
Parameters:
* message (string)
* prompt (string)
* caption (string)
* value (long)
* min (long)
* max (long)
* parent (wx.Window)
* pos (wx.Point)
Returns:
int
--------------------------------------------------------------------------------
GetOsDescription()¶
Returns the string containing the description of the current platform in a
user-readable form.
For example, this function may return strings like Windows NT Version 4.0 or
Linux 2.2.2 i386.
Returns:
string
--------------------------------------------------------------------------------
GetOsVersion()¶
Gets the version and the operating system ID for currently running OS.
Returns:
(platform, major, minor)
--------------------------------------------------------------------------------
GetPasswordFromUser(message, caption="", default_value="", parent=None)¶
Similar to wx.GetTextFromUser but the text entered in the dialog is not shown on
screen but replaced with stars. This is intended to be used for entering
passwords as the function name implies.
Parameters:
* message (string)
* caption (string)
* default_value (string)
* parent (wx.Window)
Returns:
string
--------------------------------------------------------------------------------
GetPowerType()¶
Returns the current system power state: online or offline.
Returns:
int
--------------------------------------------------------------------------------
GetProcessId()¶
Returns the number uniquely identifying the current process in the system.
If an error occurs, 0 is returned.
Returns:
int
--------------------------------------------------------------------------------
GetSingleChoice(message, caption, choices, parent=None, x=-1, y=-1, centre=True,
width=150, height=200)¶
Pops up a dialog box containing a message, OK / Cancel buttons and a
single-selection listbox.
The user may choose an item and press OK to return a string or Cancel to return
the empty string. Use wx.GetSingleChoiceIndex if empty string is a valid choice
and if you want to be able to detect pressing Cancel reliably.
You may pass the list of strings to choose from using choices which is an array
of n strings for the listbox.
If centre is True, the message text (which may include new line characters) is
centred; if False, the message is left-justified.
Parameters:
* message (string)
* caption (string)
* choices (int)
* parent (wx.Window)
* x (int)
* y (int)
* centre (bool)
* width (int)
* height (int)
Returns:
string
--------------------------------------------------------------------------------
GetSingleChoiceIndex(message, caption, choices, parent=None, x=-1, y=-1,
centre=True, width=150, height=200)¶
As wx.GetSingleChoice but returns the index representing the selected string.
If the user pressed Cancel, -1 is returned.
Parameters:
* message (string)
* caption (string)
* choices (int)
* parent (wx.Window)
* x (int)
* y (int)
* centre (bool)
* width (int)
* height (int)
Returns:
int
--------------------------------------------------------------------------------
GetStockHelpString(id, client=wx.STOCK_MENU)¶
Parameters:
* id (int)
* client (int)
Returns:
string
--------------------------------------------------------------------------------
GetStockLabel(id, flags=wx.STOCK_WITH_MNEMONIC)¶
Returns label that should be used for given id element.
Parameters:
* id (int): given id of the wx.MenuItem, wx.Button, wx.ToolBar tool etc...
* flags (long): Whether to include mnemonics or not.
Returns:
string
--------------------------------------------------------------------------------
GetTextFromUser(message, caption="", default_value="", parent=None, x=-1, y=-1,
centre=True)¶
Pop up a dialog box with title set to caption, message, and a default_value. The
user may type in text and press OK to return this text, or press Cancel to
return the empty string.
If centre is True, the message text (which may include new line characters) is
centred; if False, the message is left-justified.
Parameters:
* message (string)
* caption (string)
* default_value (string)
* parent (wx.Window)
* x (int)
* y (int)
* centre (bool)
Returns:
string
--------------------------------------------------------------------------------
GetTopLevelParent(win)¶
Returns the first top level parent of the given window, or in other words, the
frame or dialog containing it, or None.
Parameters:
* win (wx.Window)
Returns:
wx.Window
--------------------------------------------------------------------------------
GetTopLevelWindows()¶
Returns a list-like object of the the application’s top-level windows, (frames,
dialogs, etc...).
Returns:
wx.WindowList
--------------------------------------------------------------------------------
GetTranslation(str)¶
Alternative signatures:
GetTranslation(String str, String domain)
GetTranslation(String str, String strPlural, int n)
GetTranslation(String str, String strPlural, int n, String domain)
This function returns the translation of string str in the current locale.
If the string is not found in any of the loaded message catalogs, the original
string is returned. In debug build, an error message is logged – this should
help to find the strings which were not yet translated. If domain is specified
then only that domain/catalog is searched for a matching string.
The third form is used when retrieving translation of string that has different
singular and plural form in English or different plural forms in some other
language. It takes two extra arguments: as above, str parameter must contain the
singular form of the string to be converted and is used as the key for the
search in the catalog. The strPlural parameter is the plural form (in English).
The parameter n is used to determine the plural form. If no message catalog is
found str is returned if n == 1, otherwise strPlural.
All versions call wx.Locale.GetString.
Parameters:
* str (string)
Returns:
string
Note
Note that this function is not suitable for literal strings in Unicode builds.
--------------------------------------------------------------------------------
GetUTCTime()¶
Returns the number of seconds since GMT 00:00:00 Jan 1st 1970.
Returns:
int
--------------------------------------------------------------------------------
GetUserHome(user="")¶
Returns the home directory for the given user. If the user is empty (default
value), this function behaves like wx.GetHomeDir.
Parameters:
* user (string)
Returns:
string
--------------------------------------------------------------------------------
GetUserId()¶
This function returns the “user id” also known as “login name” under Unix i.e.
something like “jsmith”. It uniquely identifies the current user (on this
system).
Under Windows or NT, this function first looks in the environment variables USER
and LOGNAME; if neither of these is found, the entry UserId in the wxWidgets
section of the WIN.INI file is tried.
This function returns the login name if successful or an empty string otherwise.
Returns:
string
--------------------------------------------------------------------------------
GetUserName()¶
This function returns the full user name (something like “Mr. John Smith”).
Under Windows or NT, this function looks for the entry UserName in the wxWidgets
section of the WIN.INI file. If PenWindows is running, the entry Current in the
section User of the PENWIN.INI file is used.
This function returns the user name if successful or an empty string otherwise.
Returns:
string
--------------------------------------------------------------------------------
GetXDisplay()¶
Returns a swigified pointer to the X11 display. Returns None on other platforms.
Returns:
void
--------------------------------------------------------------------------------
GraphicsContext_Create(dc)¶
Alternative signature:
GraphicsContext_Create(wx.Window window)
Creates a wx.GraphicsContext either from a window or a DC.
Parameters:
* dc (wx.DC)
Returns:
wx.GraphicsContext
--------------------------------------------------------------------------------
GraphicsContext_CreateFromNative(context)¶
Creates a wx.GraphicsContext from a native context. This native context must be
eg a CGContextRef for Core Graphics, a Graphics pointer for GDIPlus or a cairo_t
pointer for Cairo.
Parameters:
* context (void)
Returns:
wx.GraphicsContext
Note
For wxPython we still need a way to make this value usable.
--------------------------------------------------------------------------------
GraphicsContext_CreateFromNativeWindow(window)¶
Creates a wx.GraphicsContext from a native window.
Parameters:
* window (void)
Returns:
wx.GraphicsContext
Note
For wxPython we still need a way to make this value usable.
--------------------------------------------------------------------------------
GraphicsContext_CreateMeasuringContext()¶
Create a lightwieght context that can be used for measuring text only.
Returns:
wx.GraphicsContext
--------------------------------------------------------------------------------
GraphicsRenderer_GetDefaultRenderer()¶
Returns the default renderer on this platform. On OS X this is the Core Graphics
(a.k.a. Quartz 2D) renderer, on MSW the GDIPlus renderer, and on GTK we
currently default to the cairo renderer.
Returns:
wx.GraphicsRenderer
--------------------------------------------------------------------------------
HelpProvider_Get()¶
Return the current application-wide help provider.
Returns:
wx.HelpProvider
--------------------------------------------------------------------------------
HelpProvider_Set(helpProvider)¶
Sset the current, application-wide help provider. Returns the previous one.
Unlike some other classes, the help provider is not created on demand. This must
be explicitly done by the application.
Parameters:
* helpProvider (wx.HelpProvider)
Returns:
wx.HelpProvider
--------------------------------------------------------------------------------
IconBundleFromFile(file, type)¶
Initializes the bundle with the icon(s) found in the file.
Parameters:
* file (string)
* type (long)
Returns:
wx.IconBundle
--------------------------------------------------------------------------------
IconBundleFromIcon(icon)¶
Initializes the bundle with a single icon.
Parameters:
* icon (wx.Icon)
Returns:
wx.IconBundle
--------------------------------------------------------------------------------
IconFromBitmap(bmp)¶
Creates an icon starting from a bitmap.
Parameters:
* bmp (wx.Bitmap)
Returns:
wx.Icon
--------------------------------------------------------------------------------
IconFromLocation(loc)¶
Creates an icon starting from a specified location.
Parameters:
* loc (wx.IconLocation)
Returns:
wx.Icon
--------------------------------------------------------------------------------
IconFromXPMData(listOfStrings)¶
Creates an icon starting from a list of strings containing XPM data.
Parameters:
* listOfStrings (list of strings)
Returns:
wx.Icon
--------------------------------------------------------------------------------
IdleEvent_CanSend(win)¶
Returns True if it is appropriate to send idle events to this window.
This function looks at the mode used (see wx.IdleEvent.SetMode), and the
wx.WS_EX_PROCESS_IDLE style in window to determine whether idle events should be
sent to this window now.
By default this will always return True because the update mode is initially
wx.IDLE_PROCESS_ALL.
You can change the mode to only send idle events to windows with the
wx.WS_EX_PROCESS_IDLE extra window style set.
Parameters:
* win (wx.Window)
Returns:
bool
--------------------------------------------------------------------------------
IdleEvent_GetMode()¶
Static method returning a value specifying how wxWidgets will send idle events:
to all windows, or only to those which specify that they will process the
events.
Returns:
int
--------------------------------------------------------------------------------
IdleEvent_SetMode(mode)¶
Static method for specifying how wxWidgets will send idle events: to all
windows, or only to those which specify that they will process the events.
The mode can be one of the following values:
Mode Flag Description wx.IDLE_PROCESS_ALL Send idle events to all windows.
wx.IDLE_PROCESS_SPECIFIED Send idle events only to windows that have the
wx.WS_EX_PROCESS_IDLE extra style flag set.
Parameters:
* mode (int)
--------------------------------------------------------------------------------
ImageFromBitmap(bitmap)¶
Construct a wx.Image from a wx.Bitmap.
Parameters:
* bitmap (wx.Bitmap)
Returns:
wx.Image
--------------------------------------------------------------------------------
ImageFromBuffer(width, height, dataBuffer, alphaBuffer=None)¶
Creates a wx.Image from the data in dataBuffer.
The dataBuffer parameter must be a Python object that implements the buffer
interface, such as a string, array, etc...
The dataBuffer object is expected to contain a series of RGB bytes and be
width*height*3 bytes long. A buffer object can optionally be supplied for the
image’s alpha channel data, and it is expected to be width*height bytes long.
The wx.Image will be created with its data and alpha pointers initialized to the
memory address pointed to by the buffer objects, thus saving the time needed to
copy the image data from the buffer object to the wx.Image. While this has
advantages, it also has the shoot-yourself-in-the-foot risks associated with
sharing a C pointer between two objects.
To help alleviate the risk a reference to the data and alpha buffer objects are
kept with the wx.Image, so that they won’t get deleted until after the wx.Image
is deleted. However please be aware that it is not guaranteed that an object
won’t move its memory buffer to a new location when it needs to resize its
contents. If that happens then the wx.Image will end up referring to an invalid
memory location and could cause the application to crash. Therefore care should
be taken to not manipulate the objects used for the data and alpha buffers in a
way that would cause them to change size.
Parameters:
* width (int)
* height (int)
* dataBuffer (PyObject)
* alphaBuffer (PyObject)
--------------------------------------------------------------------------------
ImageFromData(width, height, data)¶
Construct an Image from a buffer of RGB bytes.
Accepts either a string or a buffer object holding the data and the length of
the data must be width*height*3.
Parameters:
* width (int)
* height (int)
* data (buffer)
Returns:
wx.Image
--------------------------------------------------------------------------------
ImageFromDataWithAlpha(width, height, data, alpha)¶
Construct an Image from a buffer of RGB bytes with an Alpha channel. Accepts
either a string or a buffer object holding the data and the length of the data
must be width*height*3 bytes, and the length of the alpha data must be
width*height bytes.
Parameters:
* width (int)
* height (int)
* data (buffer)
* alpha (buffer)
Returns:
wx.Image
--------------------------------------------------------------------------------
ImageFromMime(name, mimetype, index=-1)¶
Loads an image from a file, using a MIME type string (such as ‘image/jpeg’) to
specify image type.
Parameters:
* name (string)
* mimetype (string)
* index (int)
Returns:
wx.Image
--------------------------------------------------------------------------------
ImageFromStream(stream, type=wx.BITMAP_TYPE_ANY, index=-1)¶
Loads an image from an input stream, or any readable Python file-like object.
Parameters:
* stream (wx.InputStream)
* type (long)
* index (int)
Returns:
wx.Image
--------------------------------------------------------------------------------
ImageFromStreamMime(stream, mimetype, index=-1)¶
Loads an image from an input stream, or any readable Python file-like object,
specifying the image format with a MIME type string.
Parameters:
* stream (wx.InputStream)
* mimetype (string)
* index (int)
Returns:
wx.Image
--------------------------------------------------------------------------------
ImageHistogram_MakeKey(r, g, b)¶
Get the key in the histogram for the given RGB values
Parameters:
* r (byte)
* g (byte)
* b (byte)
Returns:
int
--------------------------------------------------------------------------------
Image_AddHandler(handler)¶
Adds a handler to the end of the static list of format handlers.
Parameters:
* handler (wx.ImageHandler): A new image format handler object. There is
usually only one instance of a given handler class in an application session.
--------------------------------------------------------------------------------
Image_CanRead(filename)¶
Returns True if the image handlers can read this file.
Parameters:
* filename (string)
Returns:
bool
--------------------------------------------------------------------------------
Image_CanReadStream(stream)¶
Returns True if the image handlers can read an image file from the data
currently on the input stream, or a readable Python file-like object.
Parameters:
* stream (wx.InputStream)
Returns:
bool
--------------------------------------------------------------------------------
Image_GetHandlers()¶
Returns the static list of image format handlers.
Returns:
PyObject
--------------------------------------------------------------------------------
Image_GetImageCount(filename, type=wx.BITMAP_TYPE_ANY)¶
If the image file contains more than one image and the image handler is capable
of retrieving these individually, this function will return the number of
available images.
Parameters:
* filename (string)
* type (long)
Returns:
int
--------------------------------------------------------------------------------
Image_GetImageExtWildcard()¶
Iterates all registered wx.ImageHandler objects, and returns a string containing
file extension masks suitable for passing to file open/save dialog boxes.
Returns:
string
--------------------------------------------------------------------------------
Image_HSVtoRGB(hsv)¶
Converts a color in HSV color space to RGB color space.
Parameters:
* hsv (wx.Image_HSVValue)
Returns:
wx.Image_RGBValue
--------------------------------------------------------------------------------
Image_InsertHandler(handler)¶
Adds a handler at the start of the static list of format handlers.
Parameters:
* handler (wx.ImageHandler)
--------------------------------------------------------------------------------
Image_RGBtoHSV(rgb)¶
Converts a color in RGB color space to HSV color space.
Parameters:
* rgb (wx.Image_RGBValue)
Returns:
wx.Image_HSVValue
--------------------------------------------------------------------------------
Image_RemoveHandler(name)¶
Finds the handler with the given name, and removes it. The handler is not
deleted.
Parameters:
* name (string)
Returns:
bool
--------------------------------------------------------------------------------
InitAllImageHandlers()¶ The former functionality of InitAllImageHanders is now
done internal to the _core_ extension module and so this function has become a
simple NOP.
--------------------------------------------------------------------------------
IntersectRect(r1, r2)¶
Calculate and return the intersection of r1 and r2.
Parameters:
* r1 (wx.Rect)
* r2 (wx.Rect)
Returns:
wx.Rect
--------------------------------------------------------------------------------
IsBusy()¶
Returns True if between two wx.BeginBusyCursor and wx.EndBusyCursor calls.
Returns:
bool
See also
wx.BeginBusyCursor, wx.EndBusyCursor
--------------------------------------------------------------------------------
IsDragResultOk(res)¶
Parameters:
* res (int)
Returns:
bool
--------------------------------------------------------------------------------
IsPlatform64Bit()¶
Returns True if the operating system the program is running under is 64 bit. The
check is performed at run-time and may differ from the value available at
compile-time (at compile-time you can just check if sizeof(void*)==8) since the
program could be running in emulation mode or in a mixed 32/64 bit system
(bi-architecture operating system).
Returns:
bool
Important
this function is not 100% reliable on some systems given the fact that there
isn’t always a standard way to do a reliable check on the OS architecture.
--------------------------------------------------------------------------------
IsPlatformLittleEndian()¶
Returns True if the current platform is little endian (instead of big endian).
The check is performed at run-time.
Returns:
bool
--------------------------------------------------------------------------------
IsStockID(id)¶
Parameters:
* id (int)
Returns:
bool
--------------------------------------------------------------------------------
IsStockLabel(id, label)¶
Parameters:
* id (int)
* label (string)
Returns:
bool
--------------------------------------------------------------------------------
Kill(pid, sig=wx.SIGTERM, rc, flags=wx.KILL_NOCHILDREN)¶
Equivalent to the Unix kill function: send the given signal sig to the process
with PID pid. The valid signal values are:
* wx.SIGNONE = 0 —> verify if the process exists under Unix
* wx.SIGHUP
* wx.SIGINT
* wx.SIGQUIT
* wx.SIGILL
* wx.SIGTRAP
* wx.SIGABRT
* wx.SIGEMT
* wx.SIGFPE
* wx.SIGKILL —> forcefully kill, dangerous!
* wx.SIGBUS
* wx.SIGSEGV
* wx.SIGSYS
* wx.SIGPIPE
* wx.SIGALRM
* wx.SIGTERM —> terminate the process gently
wx.SIGNONE, wx.SIGKILL and wx.SIGTERM have the same meaning under both Unix and
Windows but all the other signals are equivalent to wx.SIGTERM under Windows.
Returns one of the following flags:
Kill Error Flags Description wx.KILL_OK no error wx.KILL_BAD_SIGNAL no such
signal wx.KILL_ACCESS_DENIED permission denied wx.KILL_NO_PROCESS no such
process wx.KILL_ERROR another, unspecified error
The flags parameter can be wx.KILL_NOCHILDREN (the default), or
wx.KILL_CHILDREN, in which case the child processes of this process will be
killed too. Note that under Unix, for wx.KILL_CHILDREN to work you should have
created the process passing wx.EXEC_MAKE_GROUP_LEADER.
Parameters:
* pid (long)
* sig (int)
* rc (int)
* flags (int)
Returns:
int
--------------------------------------------------------------------------------
LaunchDefaultBrowser(url)¶
Launches the user’s default browser and tells it to open the location at url.
Returns True if the application was successfully launched.
Parameters:
* url (string)
Returns:
bool
Note
Note that for some configurations of the running user, the application which is
launched to open the given URL may be URL-dependent (e.g. a browser may be used
for local URLs while another one may be used for remote URLs).
--------------------------------------------------------------------------------
ListBox_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
ListCtrl_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
LoadFileSelector(what, extension, default_name="", parent=None)¶
Parameters:
* what (string)
* extension (string)
* default_name (string)
* parent (wx.Window)
Returns:
string
--------------------------------------------------------------------------------
Locale_AddCatalogLookupPathPrefix(prefix)¶
See wx.Locale.AddCatalogLookupPathPrefix.
Parameters:
* prefix (string)
--------------------------------------------------------------------------------
Locale_AddLanguage(info)¶
See wx.Locale.AddLanguage.
Parameters:
* info (wx.LanguageInfo)
--------------------------------------------------------------------------------
Locale_FindLanguageInfo(locale)¶
See wx.Locale.FindLanguageInfo.
Parameters:
* locale (string)
Returns:
wx.LanguageInfo
--------------------------------------------------------------------------------
Locale_GetLanguageInfo(lang)¶
See wx.Locale.GetLanguageInfo.
Parameters:
* lang (int)
Returns:
wx.LanguageInfo
--------------------------------------------------------------------------------
Locale_GetLanguageName(lang)¶
See wx.Locale.GetLanguageName.
Parameters:
* lang (int)
Returns:
string
--------------------------------------------------------------------------------
Locale_GetSystemEncoding()¶
See wx.Locale.GetSystemEncoding.
Returns:
int
--------------------------------------------------------------------------------
Locale_GetSystemEncodingName()¶
See wx.Locale.GetSystemEncodingName.
Returns:
string
--------------------------------------------------------------------------------
Locale_GetSystemLanguage()¶
See wx.Locale.GetSystemLanguage.
Returns:
int
--------------------------------------------------------------------------------
Locale_IsAvailable(lang)¶
See wx.Locale.IsAvailable.
Parameters:
* lang (int)
Returns:
bool
--------------------------------------------------------------------------------
LogDebug(msg)¶
The right functions for debug output. They only do something in debug mode and
expand to nothing in release mode (otherwise).
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogError(msg)¶
The functions to use for error messages, i.e. the messages that must be shown to
the user.
The default processing is to pop up a message box to inform the user about it.
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogFatalError(msg)¶
Like wx.LogError, but also terminates the program with the exit code 3.
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogGeneric()¶ No docstrings available for this function.
--------------------------------------------------------------------------------
LogInfo(msg)¶
See wx.LogVerbose.
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogMessage(msg)¶
For all normal, informational messages. They also appear in a message box by
default (but it can be changed).
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogStatus(msg)¶
Messages logged by these functions will appear in the statusbar of the frame or
of the top level application window by default (i.e. when using the second
version of the functions).
If the target frame doesn’t have a statusbar, the message will be lost.
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogStatusFrame(pFrame, msg)¶
Messages logged by these functions will appear in the statusbar of the frame or
of the top level application window by default (i.e. when using the second
version of the functions).
If the target frame doesn’t have a statusbar, the message will be lost.
Parameters:
* pFrame (wx.Frame)
* msg (string)
--------------------------------------------------------------------------------
LogSysError(msg)¶
Mostly used by wxWidgets itself, but might be handy for logging errors after
system call (API function) failure. It logs the specified message text as well
as the last system error code.
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogTrace(mask, msg)¶
As wx.LogDebug <#LogDebug>, trace functions only do something in debug build and
expand to nothing in the release one. The reason for making it a separate
function from it is that usually there are a lot of trace messages, so it might
make sense to separate them from other debug messages.
The trace messages also usually can be separated into different categories and
the second and third versions of this function only log the message if the mask
which it has is currently enabled in wx.Log. This allows to selectively trace
only some operations and not others by changing the value of the trace mask
(possible during the run-time).
The predefined string trace masks used by wxWidgets are:
* wx.TRACE_MemAlloc: trace memory allocation (new/delete)
* wx.TRACE_Messages: trace window messages/X callbacks
* wx.TRACE_ResAlloc: trace GDI resource allocation
* wx.TRACE_RefCount: trace various ref counting operations
* wx.TRACE_OleCalls: trace OLE method calls (Win32 only)
Parameters:
* mask (int)
* msg (string)
--------------------------------------------------------------------------------
LogVerbose(msg)¶
For verbose output. Normally, it is suppressed, but might be activated if the
user wishes to know more details about the program progress (another, but
possibly confusing name for the same function is wx.LogInfo).
Parameters:
* msg (string)
--------------------------------------------------------------------------------
LogWarning(msg)¶
For warnings - they are also normally shown to the user, but don’t interrupt the
program work.
Parameters:
* msg (string)
--------------------------------------------------------------------------------
Log_AddTraceMask(str)¶
See wx.Log.AddTraceMask.
Parameters:
* str (string)
--------------------------------------------------------------------------------
Log_ClearTraceMasks()¶ See wx.Log.ClearTraceMasks.
--------------------------------------------------------------------------------
Log_DontCreateOnDemand()¶ See wx.Log.DontCreateOnDemand.
--------------------------------------------------------------------------------
Log_EnableLogging(doIt=True)¶
See wx.Log.EnableLogging.
Parameters:
* doIt (bool)
Returns:
bool
--------------------------------------------------------------------------------
Log_FlushActive()¶ See wx.Log.FlushActive.
--------------------------------------------------------------------------------
Log_GetActiveTarget()¶
See wx.Log.GetActiveTarget.
Returns:
wx.Log
--------------------------------------------------------------------------------
Log_GetLogLevel()¶
See wx.Log.GetLogLevel.
Returns:
int
--------------------------------------------------------------------------------
Log_GetRepetitionCounting()¶
See wx.Log.GetRepetitionCounting.
Returns:
bool
--------------------------------------------------------------------------------
Log_GetTimestamp()¶
See wx.Log.GetTimestamp.
Returns:
string
--------------------------------------------------------------------------------
Log_GetTraceMask()¶
See wx.Log.GetTraceMask.
Returns:
int
--------------------------------------------------------------------------------
Log_GetTraceMasks()¶
See wx.Log.GetTraceMasks.
Returns:
list of strings
--------------------------------------------------------------------------------
Log_GetVerbose()¶
See wx.Log.GetVerbose.
Returns:
bool
--------------------------------------------------------------------------------
Log_IsAllowedTraceMask(mask)¶
See wx.Log.IsAllowedTraceMask.
Parameters:
* mask (wx.char)
Returns:
bool
--------------------------------------------------------------------------------
Log_IsEnabled()¶
See wx.Log.IsEnabled.
Returns:
bool
--------------------------------------------------------------------------------
Log_OnLog(level, szString, t)¶
See wx.Log.OnLog.
Parameters:
* level (int)
* szString (string)
* t (int)
--------------------------------------------------------------------------------
Log_RemoveTraceMask(str)¶
See wx.Log.RemoveTraceMask.
Parameters:
* str (string)
--------------------------------------------------------------------------------
Log_Resume()¶ See wx.Log.Resume.
--------------------------------------------------------------------------------
Log_SetActiveTarget(pLogger)¶
See wx.Log.SetActiveTarget.
Parameters:
* pLogger (wx.Log)
Returns:
wx.Log
--------------------------------------------------------------------------------
Log_SetLogLevel(logLevel)¶
See wx.Log.SetLogLevel.
Parameters:
* logLevel (int)
--------------------------------------------------------------------------------
Log_SetRepetitionCounting(bRepetCounting=True)¶
See wx.Log.SetRepetitionCounting.
Parameters:
* bRepetCounting (bool)
--------------------------------------------------------------------------------
Log_SetTimestamp(ts)¶
See wx.Log.SetTimestamp.
Parameters:
* ts (string)
--------------------------------------------------------------------------------
Log_SetTraceMask(ulMask)¶
See wx.Log.SetTraceMask.
Parameters:
* ulMask (int)
--------------------------------------------------------------------------------
Log_SetVerbose(bVerbose=True)¶
See wx.Log.SetVerbose.
Parameters:
* bVerbose (bool)
--------------------------------------------------------------------------------
Log_Suspend()¶ See wx.Log.Suspend.
--------------------------------------------------------------------------------
Log_TimeStamp()¶
See wx.Log.TimeStamp.
Returns:
string
--------------------------------------------------------------------------------
MaskColour()¶
Warning
wx.MaskColour is deprecated, use wx.Mask instead.
--------------------------------------------------------------------------------
MemoryDCFromDC(oldDC)¶
Creates a DC that is compatible with the oldDC.
Parameters:
* oldDC (wx.DC)
Returns:
wx.MemoryDC
--------------------------------------------------------------------------------
MemoryFSHandler_AddFile(filename, dataItem, imgType=-1)¶
Add file to the memory filesystem. The dataItem parameter can either be a
wx.Bitmap, wx.Image or a string that can contain arbitrary data. If a bitmap or
image is used then the imgType parameter should specify what kind of image file
it should be written as, wx.BITMAP_TYPE_PNG, etc...
Parameters:
* filename (string)
* dataItem (PyObject)
* imgType (int)
Note
Note that you must use a type value (aka image format) that wxWidgets can save
(e.g. JPG, PNG, see wx.Image)!
--------------------------------------------------------------------------------
MemoryFSHandler_AddFileWithMimeType(filename, data, mimetype)¶
Like MemoryFSHandler_AddFile, but lets you explicitly specify added file’s MIME
type. This version should be used whenever you know the MIME type, because it
makes accessing the files faster.
This function is new since wxWidgets version 2.8.5
Parameters:
* filename (string)
* data (PyObject)
* mimetype (string)
--------------------------------------------------------------------------------
MemoryFSHandler_RemoveFile(filename)¶
Remove file from memory FS and free occupied memory.
Parameters:
* filename (string)
--------------------------------------------------------------------------------
MenuBar_GetAutoWindowMenu()¶
Returns:
bool
--------------------------------------------------------------------------------
MenuBar_MacSetCommonMenuBar(menubar)¶
Parameters:
* menubar (wx.MenuBar)
--------------------------------------------------------------------------------
MenuBar_SetAutoWindowMenu(enable)¶
Parameters:
* enable (bool)
--------------------------------------------------------------------------------
MenuItem_GetDefaultMarginWidth()¶
Returns:
int
--------------------------------------------------------------------------------
MenuItem_GetLabelFromText(text)¶
Parameters:
* text (string)
Returns:
string
--------------------------------------------------------------------------------
MenuItem_GetLabelText(label)¶
Strips all accelerator characters and mnemonics from the given text. For
example:
menuItem.GetLabelFromText("&Hello\tCtrl-H")
will return just "Hello".
Parameters:
* label (string)
Returns:
String
--------------------------------------------------------------------------------
MessageBox(message, caption="", style=wx.OK|wx.CENTRE, parent=None, x=-1, y=-1)¶
General purpose message dialog. style may be a bit list of the following
identifiers:
Style Flag Description wx.YES_NO Puts Yes and No buttons on the message box. May
be combined with wx.CANCEL. wx.CANCEL Puts a Cancel button on the message box.
May only be combined with wx.YES_NO or wx.OK. wx.OK Puts an Ok button on the
message box. May be combined with wx.CANCEL. wx.ICON_EXCLAMATION Displays an
exclamation mark symbol. wx.ICON_HAND Displays an error symbol. wx.ICON_ERROR
Displays an error symbol - the same as wx.ICON_HAND. wx.ICON_QUESTION Displays a
question mark symbol. wx.ICON_INFORMATION Displays an information symbol.
The return value is one of: wx.YES, wx.NO, wx.CANCEL, wx.OK.
For example:
answer = wx.MessageBox("Quit program?", "Confirm", wx.YES_NO | wx.CANCEL, main_frame)
if answer == wx.YES:
main_frame.Close()
message may contain newline characters, in which case the message will be split
into separate lines, to cater for large messages.
Parameters:
* message (string)
* caption (string)
* style (int)
* parent (wx.Window)
* x (int)
* y (int)
Returns:
int
--------------------------------------------------------------------------------
MicroSleep(microseconds)¶
Sleeps for the specified number of microseconds. The microsecond resolution may
not, in fact, be available on all platforms (currently only Unix platforms with
nanosleep(2) may provide it) in which case this is the same as wx.MilliSleep
(microseconds/1000).
Parameters:
* microseconds (int)
--------------------------------------------------------------------------------
MilliSleep(milliseconds)¶
Sleeps for the specified number of milliseconds.
Parameters:
* milliseconds (int)
--------------------------------------------------------------------------------
MimeTypesManager_IsOfType(mimeType, wildcard)¶
This function returns True if either the given mimeType is exactly the same as
wildcard or if it has the same category and the subtype of wildcard is ‘*’.
The comparison don by this function is case insensitive so it is not necessary
to convert the strings to the same case before calling it.
Parameters:
* mimeType (string)
* wildcard (string)
Returns:
bool
--------------------------------------------------------------------------------
MutexGuiEnter()¶
This function must be called when any thread other than the main GUI thread
wants to get access to the GUI library.
This function will block the execution of the calling thread until the main
thread (or any other thread holding the main GUI lock) leaves the GUI library
and no other thread will enter the GUI library until the calling thread calls
wx.MutexGuiLeave.
Typically, these functions are used like this:
def Foo(self):
# Before doing any GUI calls we must ensure that this thread is the only
# one doing it!
wx.MutexGuiEnter()
# Call GUI here:
my_window.DrawSomething()
wx.MutexGuiLeave()
Note
Note that under GTK, no creation of top-level windows is allowed in any thread
but the main one.
Note
This function is only defined on platforms which support preemptive threads.
--------------------------------------------------------------------------------
MutexGuiLeave()¶ See MutexGuiEnter .
Note
This function is only defined on platforms which support preemptive threads.
--------------------------------------------------------------------------------
NamedColor(colorName)¶
Constructs a colour object using a colour name listed in wx.TheColourDatabase.
Parameters:
* colorName (string)
Returns:
wx.Colour
--------------------------------------------------------------------------------
NamedColour(colorName)¶
Constructs a colour object using a colour name listed in wx.TheColourDatabase.
Parameters:
* colorName (string)
Returns:
wx.Colour
--------------------------------------------------------------------------------
NewEventType()¶
Returns:
EventType
--------------------------------------------------------------------------------
NewId()¶
Generates an integer identifier unique to this run of the program.
Returns:
int
--------------------------------------------------------------------------------
Notebook_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
Now()¶
Returns a string representing the current date and time.
Returns:
string
--------------------------------------------------------------------------------
NullFileTypeInfo()¶
Returns:
wx.FileTypeInfo
--------------------------------------------------------------------------------
Panel_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
Point2DCopy(pt)¶
Create a wx.Point2D object.
Parameters:
* pt (wx.Point2D)
Returns:
wx.Point2D
--------------------------------------------------------------------------------
Point2DFromPoint(pt)¶
Create wx.Point2D object.
Parameters:
* pt (wx.Point)
Returns:
wx.Point2D
--------------------------------------------------------------------------------
PostEvent(dest, event)¶
Send an event to a window or other wx.EvtHandler to be processed later.
Parameters:
* dest (wx.EvtHandler)
* event (wx.Event)
--------------------------------------------------------------------------------
PostScriptDC_GetResolution()¶
Return resolution used in PostScript output.
Returns:
int
--------------------------------------------------------------------------------
PostScriptDC_SetResolution(ppi)¶
Set resolution (in pixels per inch) that will be used in PostScript output.
Default is 720ppi.
Parameters:
* ppi (int)
--------------------------------------------------------------------------------
PreBitmapButton()¶
Precreate a wx.BitmapButton for 2-phase creation.
Returns:
wx.BitmapButton
--------------------------------------------------------------------------------
PreButton()¶
Precreate a wx.Button for 2-phase creation.
Returns:
wx.Button
--------------------------------------------------------------------------------
PreCheckBox()¶
Precreate a wx.CheckBox for 2-phase creation.
Returns:
wx.CheckBox
--------------------------------------------------------------------------------
PreCheckListBox()¶
Precreate a wx.CheckListBox for 2-phase creation.
Returns:
wx.CheckListBox
--------------------------------------------------------------------------------
PreChoice()¶
Precreate a wx.Choice control for 2-phase creation.
Returns:
wx.Choice
--------------------------------------------------------------------------------
PreChoicebook()¶
Precreate a wx.Choicebook control for 2-phase creation.
Returns:
wx.Choicebook
--------------------------------------------------------------------------------
PreCollapsiblePane()¶
Precreate a wx.CollapsiblePane for 2-phase creation.
Returns:
wx.CollapsiblePane
--------------------------------------------------------------------------------
PreColourPickerCtrl()¶
Precreate a wx.ColourPickerCtrl control for 2-phase creation.
Returns:
wx.ColourPickerCtrl
--------------------------------------------------------------------------------
PreComboBox()¶
Precreate a wx.ComboBox control for 2-phase creation.
Returns:
wx.ComboBox
--------------------------------------------------------------------------------
PreControl()¶
Precreate a wx.Control control for 2-phase creation.
Returns:
wx.Control
--------------------------------------------------------------------------------
PreDatePickerCtrl()¶
Precreate a wx.DatePickerCtrl for use in 2-phase creation.
Returns:
wx.DatePickerCtrl
--------------------------------------------------------------------------------
PreDialog()¶
Precreate a wx.Dialog control for 2-phase creation.
Returns:
wx.Dialog
--------------------------------------------------------------------------------
PreDirFilterListCtrl()¶
Precreate a wx.DirFilterListCtrl control for 2-phase creation.
Returns:
wx.DirFilterListCtrl
--------------------------------------------------------------------------------
PreDirPickerCtrl()¶
Precreate a wx.DirPickerCtrl control for 2-phase creation.
Returns:
wx.DirPickerCtrl
--------------------------------------------------------------------------------
PreFilePickerCtrl()¶
Precreate a wx.FilePickerCtrl control for 2-phase creation.
Returns:
wx.FilePickerCtrl
--------------------------------------------------------------------------------
PreFindReplaceDialog()¶
Precreate a wx.FindReplaceDialog for 2-phase creation.
Returns:
wx.FindReplaceDialog
--------------------------------------------------------------------------------
PreFontPickerCtrl()¶
Precreate a wx.FontPickerCtrl control for 2-phase creation.
Returns:
wx.FontPickerCtrl
--------------------------------------------------------------------------------
PreFrame()¶
Precreate a wx.Frame control for 2-phase creation.
Returns:
wx.Frame
--------------------------------------------------------------------------------
PreGauge()¶
Precreate a wx.Gauge control for 2-phase creation.
Returns:
wx.Gauge
--------------------------------------------------------------------------------
PreGenericDatePickerCtrl()¶
Precreate a wx.GenericDatePickerCtrl for use in 2-phase creation.
Returns:
wx.GenericDatePickerCtrl
--------------------------------------------------------------------------------
PreGenericDirCtrl()¶
Precreate a wx.GenericDirCtrl control for 2-phase creation.
Returns:
wx.GenericDirCtrl
--------------------------------------------------------------------------------
PreHtmlListBox()¶
Precreate a wx.HtmlListBox control for 2-phase creation.
Returns:
wx.HtmlListBox
--------------------------------------------------------------------------------
PreHyperlinkCtrl()¶
Precreate a wx.HyperlinkCtrl control for 2-phase creation.
Returns:
wx.HyperlinkCtrl
--------------------------------------------------------------------------------
PreListBox()¶
Precreate a wx.ListBox control for 2-phase creation.
Returns:
wx.ListBox
--------------------------------------------------------------------------------
PreListCtrl()¶
Precreate a wx.ListCtrl control for 2-phase creation.
Returns:
wx.ListCtrl
--------------------------------------------------------------------------------
PreListView()¶
Precreate a wx.ListView control for 2-phase creation.
Returns:
wx.ListView
--------------------------------------------------------------------------------
PreListbook()¶
Precreate a wx.Listbook control for 2-phase creation.
Returns:
wx.Listbook
--------------------------------------------------------------------------------
PreMDIChildFrame()¶
Precreate a wx.MDIChildFrame control for 2-phase creation.
Returns:
wx.MDIChildFrame
--------------------------------------------------------------------------------
PreMDIClientWindow()¶
Precreate a wx.MDIClientWindow control for 2-phase creation.
Returns:
wx.MDIClientWindow
--------------------------------------------------------------------------------
PreMDIParentFrame()¶
Precreate a wx.MDIParentFrame control for 2-phase creation.
Returns:
wx.MDIParentFrame
--------------------------------------------------------------------------------
PreMiniFrame()¶
Precreate a wx.MiniFrame control for 2-phase creation.
Returns:
wx.MiniFrame
--------------------------------------------------------------------------------
PreNotebook()¶
Precreate a wx.Notebook control for 2-phase creation.
Returns:
wx.Notebook
--------------------------------------------------------------------------------
PrePanel()¶
Precreate a wx.Panel control for 2-phase creation.
Returns:
wx.Panel
--------------------------------------------------------------------------------
PrePopupTransientWindow()¶
Precreate a wx.PopupTransientWindow control for 2-phase creation.
Returns:
wx.PopupTransientWindow
--------------------------------------------------------------------------------
PrePopupWindow()¶
Precreate a wx.PopupWindow control for 2-phase creation.
Returns:
wx.PopupWindow
--------------------------------------------------------------------------------
PrePyAxBaseWindow()¶
Precreate a wx.PyAxBaseWindow control for 2-phase creation.
Returns:
wx.PyAxBaseWindow
--------------------------------------------------------------------------------
PrePyControl()¶
Precreate a wx.PyControl control for 2-phase creation.
Returns:
wx.PyControl
--------------------------------------------------------------------------------
PrePyPanel()¶
Precreate a wx.PyPanel control for 2-phase creation.
Returns:
wx.PyPanel
--------------------------------------------------------------------------------
PrePyScrolledWindow()¶
Precreate a wx.PyScrolledWindow control for 2-phase creation.
Returns:
wx.PyScrolledWindow
--------------------------------------------------------------------------------
PrePyWindow()¶
Precreate a wx.PyWindow control for 2-phase creation.
Returns:
wx.PyWindow
--------------------------------------------------------------------------------
PreRadioBox()¶
Precreate a wx.RadioBox control for 2-phase creation.
Returns:
wx.RadioBox
--------------------------------------------------------------------------------
PreRadioButton()¶
Precreate a wx.RadioButton control for 2-phase creation.
Returns:
wx.RadioButton
--------------------------------------------------------------------------------
PreSashLayoutWindow()¶
Precreate a wx.SashLayoutWindow control for 2-phase creation.
Returns:
wx.SashLayoutWindow
--------------------------------------------------------------------------------
PreSashWindow()¶
Precreate a wx.SashWindow control for 2-phase creation.
Returns:
wx.SashWindow
--------------------------------------------------------------------------------
PreScrollBar()¶
Precreate a wx.ScrollBar control for 2-phase creation.
Returns:
wx.ScrollBar
--------------------------------------------------------------------------------
PreScrolledWindow()¶
Precreate a wx.ScrolledWindow control for 2-phase creation.
Returns:
wx.ScrolledWindow
--------------------------------------------------------------------------------
PreSearchCtrl()¶
Precreate a wx.SearchCtrl for 2-phase creation.
Returns:
wx.SearchCtrl
--------------------------------------------------------------------------------
PreSimpleHtmlListBox()¶
Precreate a wx.SimpleHtmlListBox control for 2-phase creation.
Returns:
wx.SimpleHtmlListBox
--------------------------------------------------------------------------------
PreSingleInstanceChecker()¶
Precreate a wx.SingleInstanceChecker control for 2-phase creation.
Returns:
wx.SingleInstanceChecker
--------------------------------------------------------------------------------
PreSlider()¶
Precreate a wx.Slider control for 2-phase creation.
Returns:
wx.Slider
--------------------------------------------------------------------------------
PreSpinButton()¶
Precreate a wx.SpinButton control for 2-phase creation.
Returns:
wx.SpinButton
--------------------------------------------------------------------------------
PreSpinCtrl()¶
Precreate a wx.SpinCtrl control for 2-phase creation.
Returns:
wx.SpinCtrl
--------------------------------------------------------------------------------
PreSplitterWindow()¶
Precreate a wx.SplitterWindow for 2-phase creation.
Returns:
wx.SplitterWindow
--------------------------------------------------------------------------------
PreStaticBitmap()¶
Precreate a wx.StaticBitmap control for 2-phase creation.
Returns:
wx.StaticBitmap
--------------------------------------------------------------------------------
PreStaticBox()¶
Precreate a wx.StaticBox control for 2-phase creation.
Returns:
wx.StaticBox
--------------------------------------------------------------------------------
PreStaticLine()¶
Precreate a wx.StaticLine control for 2-phase creation.
Returns:
wx.StaticLine
--------------------------------------------------------------------------------
PreStaticText()¶
Precreate a wx.StaticText control for 2-phase creation.
Returns:
wx.StaticText
--------------------------------------------------------------------------------
PreStatusBar()¶
Precreate a wx.StatusBar control for 2-phase creation.
Returns:
wx.StatusBar
--------------------------------------------------------------------------------
PreTextCtrl()¶
Precreate a wx.TextCtrl control for 2-phase creation.
Returns:
wx.TextCtrl
--------------------------------------------------------------------------------
PreToggleButton()¶
Precreate a wx.ToggleButton control for 2-phase creation.
Returns:
wx.ToggleButton
--------------------------------------------------------------------------------
PreToolBar()¶
Precreate a wx.ToolBar control for 2-phase creation.
Returns:
wx.ToolBar
--------------------------------------------------------------------------------
PreToolbook()¶
Precreate a wx.Toolbook control for 2-phase creation.
Returns:
wx.Toolbook
--------------------------------------------------------------------------------
PreTreeCtrl()¶
Precreate a wx.TreeCtrl control for 2-phase creation.
Returns:
wx.TreeCtrl
--------------------------------------------------------------------------------
PreTreebook()¶
Precreate a wx.Treebook control for 2-phase creation.
Returns:
wx.Treebook
--------------------------------------------------------------------------------
PreVListBox()¶
Precreate a wx.VListBox control for 2-phase creation.
Returns:
wx.VListBox
--------------------------------------------------------------------------------
PreVScrolledWindow()¶
Precreate a wx.VScrolledWindow control for 2-phase creation.
Returns:
wx.VScrolledWindow
--------------------------------------------------------------------------------
PreWindow()¶
Precreate a wx.Window for 2-phase creation.
Returns:
wx.Window
--------------------------------------------------------------------------------
Printer_GetLastError()¶
See wx.Printer.GetLastError.
Returns:
int
--------------------------------------------------------------------------------
Process_Exists(pid)¶
See wx.Process.Exists.
Parameters:
* pid (int)
Returns:
bool
--------------------------------------------------------------------------------
Process_Kill(pid, sig=wx.SIGTERM, flags=wx.KILL_NOCHILDREN)¶
See wx.Process.Kill.
Parameters:
* pid (int)
* sig (int)
* flags (int)
Returns:
int
--------------------------------------------------------------------------------
Process_Open(cmd, flags=wx.EXEC_ASYNC)¶
See wx.Process.Open.
Parameters:
* cmd (string)
* flags (int)
Returns:
wx.Process
--------------------------------------------------------------------------------
PyApp_GetComCtl32Version()¶
Returns 400, 470, 471, etc. for comctl32.dll 4.00, 4.70, 4.71 or 0 if it wasn’t
found at all.
Raises an exception on non-Windows platforms.
Returns:
int
--------------------------------------------------------------------------------
PyApp_GetMacAboutMenuItemId()¶
Returns:
int
--------------------------------------------------------------------------------
PyApp_GetMacExitMenuItemId()¶
Returns:
int
--------------------------------------------------------------------------------
PyApp_GetMacHelpMenuTitleName()¶
Returns:
String
--------------------------------------------------------------------------------
PyApp_GetMacPreferencesMenuItemId()¶
Returns:
int
--------------------------------------------------------------------------------
PyApp_GetMacSupportPCMenuShortcuts()¶
Returns:
bool
--------------------------------------------------------------------------------
PyApp_IsDisplayAvailable()¶
Tests if it is possible to create a GUI in the current environment.
This will mean different things on the different platforms.
* On X Windows systems this function will return False if it is not able to
open a connection to the X display, which can happen if $DISPLAY is not set,
or is not set correctly.
* On Mac OS X a False return value will mean that wxPython is not able to
access the window manager, which can happen if logged in remotely or if
running from the normal version of python instead of the framework version,
(i.e., pythonw).
* On MS Windows...
Returns:
bool
--------------------------------------------------------------------------------
PyApp_IsMainLoopRunning()¶
Returns True if we’re running the main loop, i.e. if the events can currently be
dispatched.
Returns:
bool
--------------------------------------------------------------------------------
PyApp_SetMacAboutMenuItemId(val)¶
Parameters:
* val (long)
--------------------------------------------------------------------------------
PyApp_SetMacExitMenuItemId(val)¶
Parameters:
* val (long)
--------------------------------------------------------------------------------
PyApp_SetMacHelpMenuTitleName(val)¶
Parameters:
* val (string)
--------------------------------------------------------------------------------
PyApp_SetMacPreferencesMenuItemId(val)¶
Parameters:
* val (long)
--------------------------------------------------------------------------------
PyApp_SetMacSupportPCMenuShortcuts(val)¶
Parameters:
* val (bool)
--------------------------------------------------------------------------------
PyAxBaseWindow_FromHWND()¶ No docstrings available for this function.
--------------------------------------------------------------------------------
Quantize_Quantize(src, dest, desiredNoColours=236,
flags=wx.QUANTIZE_INCLUDE_WINDOWS_COLOURS | wx.QUANTIZE_FILL_DESTINATION_IMAGE)¶
Reduce the colours in the source image and put the result into the destination
image, setting the palette in the destination if needed. Both images may be the
same, to overwrite the source image.
Parameters:
* src (wx.Image)
* dest (wx.Image)
* desiredNoColours (int)
* flags (int)
Returns:
bool
--------------------------------------------------------------------------------
RadioBox_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
RadioButton_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
RectPP(topLeft, bottomRight)¶
Create a new wx.Rect object from Points representing two corners.
Parameters:
* topLeft (wx.Point)
* bottomRight (wx.Point)
Returns:
wx.Rect
--------------------------------------------------------------------------------
RectPS(pos, size)¶
Create a new wx.Rect from a position and size.
Parameters:
* pos (wx.Point)
* size (wx.Size)
Returns:
wx.Rect
--------------------------------------------------------------------------------
RectS(size)¶
Create a new wx.Rect from a size only.
Parameters:
* size (wx.Size)
Returns:
wx.Rect
--------------------------------------------------------------------------------
RegionFromBitmap(bmp)¶
Creates a wx.Region from a bitmap.
Parameters:
* bmp (wx.Bitmap)
Returns:
wx.Region
--------------------------------------------------------------------------------
RegionFromBitmapColour(bmp, transColour, tolerance=0)¶
Converts the non-transparent pixels of a bitmap into a region. Colour to be
treated as transparent is specified in the transColour argument, along with an
optional colour tolerance value.
Parameters:
* bmp (wx.Bitmap)
* transColour (wx.Colour)
* tolerance (int)
Returns:
wx.Region
--------------------------------------------------------------------------------
RegionFromPoints(points, fillStyle=wx.WINDING_RULE)¶
Creates a wx.Region from a list of points
Parameters:
* points (list of wx.Point)
* fillStyle (int)
Returns:
wx.Region
--------------------------------------------------------------------------------
RegisterId(id)¶
Ensures that ids subsequently generated by wx.NewId do not clash with the given
id.
Parameters:
* id (long)
--------------------------------------------------------------------------------
RendererNative_Get()¶
Return the currently used renderer.
Returns:
wx.RendererNative
--------------------------------------------------------------------------------
RendererNative_GetDefault()¶
Return the default (native) implementation for this platform – this is also the
one used by default but this may be changed by calling wx.RendererNative.Set in
which case the return value of this method may be different from the return
value of wx.RendererNative.Get.
Returns:
wx.RendererNative
--------------------------------------------------------------------------------
RendererNative_GetGeneric()¶
Return the generic implementation of the renderer. Under some platforms, this is
the default renderer implementation, others have platform-specific default
renderer which can be retrieved by calling wx.RendererNative.GetDefault.
Returns:
wx.RendererNative
--------------------------------------------------------------------------------
RendererNative_Set(renderer)¶
Set the renderer to use, passing None reverts to using the default renderer.
Returns the previous renderer used with Set or None.
Parameters:
* renderer (wx.RendererNative)
Returns:
wx.RendererNative
--------------------------------------------------------------------------------
RendererVersion_IsCompatible(ver)¶
See wx.RendererVersion.IsCompatible.
Parameters:
* ver (wx.RendererVersion)
Returns:
bool
--------------------------------------------------------------------------------
Renderer_DrawChoice(win, dc, rect, flags=0)¶
See wx.RendererNative.DrawChoice.
Parameters:
* win (wx.Window)
* dc (wx.DC)
* rect (wx.Rect)
* flags (int)
--------------------------------------------------------------------------------
Renderer_DrawComboBox(win, dc, rect, flags=0)¶
See wx.RendererNative.DrawComboBox.
Parameters:
* win (wx.Window)
* dc (wx.DC)
* rect (wx.Rect)
* flags (int)
--------------------------------------------------------------------------------
Renderer_DrawRadioButton(win, dc, rect, flags=0)¶
See wx.RendererNative.DrawRadioButton.
Parameters:
* win (wx.Window)
* dc (wx.DC)
* rect (wx.Rect)
* flags (int)
--------------------------------------------------------------------------------
Renderer_DrawTextCtrl(win, dc, rect, flags=0)¶
See wx.RendererNative.DrawTextCtrl.
Parameters:
* win (wx.Window)
* dc (wx.DC)
* rect (wx.Rect)
* flags (int)
--------------------------------------------------------------------------------
SafeShowMessage(title, text)¶
This function shows a message to the user in a safe way and should be safe to
call even before the application has been initialized or if it is currently in
some other strange state (for example, about to crash). Under Windows this
function shows a message box using a native dialog instead of wx.MessageBox
(which might be unsafe to call), elsewhere it simply prints the message to the
standard output using the title as prefix.
Parameters:
* title (string): The title of the message box shown to the user or the prefix
of the message string.
* text (string): The text to show to the user.
--------------------------------------------------------------------------------
SafeYield(win=None, onlyIfNeeded=False)¶
This function is similar to wx.Yield, except that it disables the user input to
all program windows before calling wx.Yield and re-enables it again afterwards.
If win is not None, this window will remain enabled, allowing the implementation
of some limited user interaction.
Returns the result of the call to wx.Yield.
Parameters:
* win (wx.Window)
* onlyIfNeeded (bool)
Returns:
bool
--------------------------------------------------------------------------------
SaveFileSelector(what, extension, default_name="", parent=None)¶
Parameters:
* what (string)
* extension (string)
* default_name (string)
* parent (wx.Window)
Returns:
string
--------------------------------------------------------------------------------
ScrollBar_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
ScrolledWindow_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
SetCursor(cursor)¶
Globally sets the cursor; only has an effect on Windows, Mac and GTK+. You
should call this function with wx.NullCursor as parameter to restore the system
cursor.
Parameters:
* cursor (wx.Cursor)
See also
wx.Cursor, wx.Window.SetCursor
--------------------------------------------------------------------------------
SetDefaultPyEncoding(encoding)¶
Sets the encoding that wxPython will use when it needs to convert a Python
string or unicode object to or from a wxString.
The default encoding is the value of locale.getdefaultlocale()[1] but please be
aware that the default encoding within the same locale may be slightly different
on different platforms.
For example, please see http://www.alanwood.net/demos/charsetdiffs.html for
differences between the common latin/roman encodings.
Parameters:
* encoding (string)
--------------------------------------------------------------------------------
Shell(command="")¶
Executes a command in an interactive shell window. If no command is specified,
then just the shell is spawned.
Parameters:
* command (string)
Returns:
bool
See also
Execute
--------------------------------------------------------------------------------
ShowTip(parent, tipProvider, showAtStartup=True)¶
This function shows a “startup tip” to the user. The return value is the state
of the ‘Show tips at startup’ checkbox.
Parameters:
* parent (wx.Window): The parent window of the modal dialog.
* tipProvider (wx.TipProvider): An object which is used to get the text of the
tips. It may be created with the wx.CreateFileTipProvider function.
* showAtStartup (bool): Should be True if startup tips are shown, False
otherwise. This is used as the initial value for “Show tips at startup”
checkbox which is shown in the tips dialog.
Returns:
bool
--------------------------------------------------------------------------------
Shutdown(wFlags)¶
This function shuts down or reboots the computer depending on the value of the
flags. Please notice that doing this requires the corresponding access rights
(superuser under Unix, SE_SHUTDOWN privilege under Windows NT) and that this
function is only implemented under Unix and Win32.
Parameters:
* wFlags (int)
Returns:
bool
--------------------------------------------------------------------------------
SizerFlags_GetDefaultBorder()¶
Returns the default border size used by the other border methods.
Returns:
int
--------------------------------------------------------------------------------
SizerItemSizer(sizer, proportion, flag, border, userData=None)¶
Constructs a wx.SizerItem for tracking a subsizer.
Parameters:
* sizer (wx.Sizer)
* proportion (int)
* flag (int)
* border (int)
* userData (PyObject)
Returns:
wx.SizerItem
--------------------------------------------------------------------------------
SizerItemSpacer(width, height, proportion, flag, border, userData=None)¶
Constructs a wx.SizerItem for tracking a spacer.
Parameters:
* width (int)
* height (int)
* proportion (int)
* flag (int)
* border (int)
* userData (PyObject)
Returns:
wx.SizerItem
--------------------------------------------------------------------------------
SizerItemWindow(window, proportion, flag, border, userData=None)¶
Constructs a wx.SizerItem for tracking a window.
Parameters:
* window (wx.Window)
* proportion (int)
* flag (int)
* border (int)
* userData (PyObject)
Returns:
wx.SizerItem
--------------------------------------------------------------------------------
Sleep(secs)¶
Sleeps for the specified number of seconds.
Parameters:
* secs (int)
--------------------------------------------------------------------------------
Slider_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
SoundFromData(data)¶
Creates a wx.Sound from the input data.
Parameters:
* data (PyObject)
Returns:
wx.Sound
--------------------------------------------------------------------------------
Sound_PlaySound(filename, flags=wx.SOUND_ASYNC)¶
See wx.Sound.Play
Parameters:
* filename (string)
* flags (int)
--------------------------------------------------------------------------------
Sound_Stop()¶ See wx.Sound.Stop
--------------------------------------------------------------------------------
SpinButton_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
SpinCtrl_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
SplitterWindow_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
StandardPaths_Get()¶
Return the global standard paths singleton.
Returns:
wx.StandardPaths
--------------------------------------------------------------------------------
StartTimer()¶ Starts a stopwatch; use wx.GetElapsedTime to get the elapsed time.
See also
wx.Timer
--------------------------------------------------------------------------------
StaticBitmap_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
StaticBox_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
StaticLine_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
StaticLine_GetDefaultSize()¶
Returns:
int
--------------------------------------------------------------------------------
StaticText_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
StatusBar_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
StockCursor(id)¶
Create a cursor using one of the stock cursors.
Parameters:
* id (int)
Returns:
wx.Cursor
Note
Note that not all stock cursors are available on all platforms.
--------------------------------------------------------------------------------
StockGDI_DeleteAll()¶ No docstrings available for this function.
--------------------------------------------------------------------------------
StockGDI_GetBrush(item)¶
Parameters:
* item (int)
Returns:
wx.Brush
--------------------------------------------------------------------------------
StockGDI_GetColour(item)¶
Parameters:
* item (int)
Returns:
wx.Colour
--------------------------------------------------------------------------------
StockGDI_GetCursor(item)¶
Parameters:
* item (int)
Returns:
wx.Cursor
--------------------------------------------------------------------------------
StockGDI_GetPen(item)¶
Parameters:
* item (int)
Returns:
wx.Pen
--------------------------------------------------------------------------------
StockGDI_instance()¶
Returns:
wx.StockGDI
--------------------------------------------------------------------------------
StripMenuCodes(in)¶
Strips any menu codes from in and returns the result.
By default, the functions strips both the mnemonics character (‘&’) which is
used to indicate a keyboard shortkey, and the accelerators, which are used only
in the menu items and are separated from the main text by the \t (TAB)
character.
Parameters:
* in (string)
Returns:
string
Note
Notice that in most cases wx.MenuItem.GetLabelFromText or
wx.Control.GetLabelText can be used instead.
--------------------------------------------------------------------------------
SysErrorCode()¶
Returns the error code from the last system call. This function uses errno on
Unix platforms and GetLastError under Win32.
Returns:
int
See also
wx.SysErrorMsg, wx.LogSysError
--------------------------------------------------------------------------------
SysErrorMsg(nErrCode=0)¶
Returns the error message corresponding to the given system error code.
If errCode is 0 (default), the last error code (as returned by wx.SysErrorCode)
is used.
See also
wx.SysErrorCode, wx.LogSysError
--------------------------------------------------------------------------------
SystemOptions_GetOption(name)¶
See wx.SystemOptions.GetOption
Parameters:
* name (string)
Returns:
String
--------------------------------------------------------------------------------
SystemOptions_GetOptionInt(name)¶
See wx.SystemOptions.GetOptionInt
Parameters:
* name (string)
Returns:
int
--------------------------------------------------------------------------------
SystemOptions_HasOption(name)¶
See wx.SystemOptions.HasOption
Parameters:
* name (string)
Returns:
bool
--------------------------------------------------------------------------------
SystemOptions_IsFalse(name)¶
See wx.SystemOptions.IsFalse
Parameters:
* name (string)
Returns:
bool
--------------------------------------------------------------------------------
SystemOptions_SetOption(name, value)¶
See wx.SystemOptions.SetOption
Parameters:
* name (string)
* value (string)
--------------------------------------------------------------------------------
SystemOptions_SetOptionInt(name, value)¶
See wx.SystemOptions.SetOptionInt
Parameters:
* name (string)
* value (int)
--------------------------------------------------------------------------------
SystemSettings_GetColour(index)¶
See wx.SystemSettings.GetColour
Parameters:
* index (int)
Returns:
wx.Colour
--------------------------------------------------------------------------------
SystemSettings_GetFont(index)¶
See wx.SystemSettings.GetFont
Parameters:
* index (int)
Returns:
wx.Font
--------------------------------------------------------------------------------
SystemSettings_GetMetric(index, win=None)¶
See wx.SystemSettings.GetMetric
Parameters:
* index (int)
* win (wx.Window)
Returns:
int
--------------------------------------------------------------------------------
SystemSettings_GetScreenType()¶
See wx.SystemSettings.GetScreenType
Returns:
int
--------------------------------------------------------------------------------
SystemSettings_HasFeature(index)¶
See wx.SystemSettings.HasFeature
Parameters:
* index (int)
Returns:
bool
--------------------------------------------------------------------------------
SystemSettings_SetScreenType(screen)¶
See wx.SystemSettings.SetScreenType
Parameters:
* screen (int)
--------------------------------------------------------------------------------
TestFontEncoding(info)¶
Parameters:
* info (wx.NativeEncodingInfo)
Returns:
bool
--------------------------------------------------------------------------------
TextAttr_Combine(attr, attrDef, text)¶
Parameters:
* attr (wx.TextAttr)
* attrDef (wx.TextAttr)
* text (wx.TextCtrl)
Returns:
wx.TextAttr
--------------------------------------------------------------------------------
TextAttr_Merge(base, overlay)¶
Creates a new wx.TextAttr which is a merge of base and overlay. Properties
defined in overlay take precedence over those in base.
Properties undefined/invalid in both are undefined in the result.
Parameters:
* base (wx.TextAttr)
* overlay (wx.TextAttr)
Returns:
wx.TextAttr
--------------------------------------------------------------------------------
TextCtrl_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
Thread_IsMain()¶
Returns True if this thread is the main one.
Returns:
bool
--------------------------------------------------------------------------------
TimeSpan_Day()¶
See wx.TimeSpan.Day
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Days(days)¶
See wx.TimeSpan.Days
Parameters:
* days (long)
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Hour()¶
See wx.TimeSpan.Hour
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Hours(hours)¶
See wx.TimeSpan.Hours
Parameters:
* hours (long)
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Millisecond()¶
See wx.TimeSpan.Millisecond
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Milliseconds(ms)¶
See wx.TimeSpan.Milliseconds
Parameters:
* ms (long)
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Minute()¶
See wx.TimeSpan.Minute
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Minutes(min)¶
See wx.TimeSpan.Minutes
Parameters:
* min (long)
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Second()¶
See wx.TimeSpan.Second
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Seconds(sec)¶
See wx.TimeSpan.Seconds
Parameters:
* sec (long)
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Week()¶
See wx.TimeSpan.Week
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
TimeSpan_Weeks(days)¶
See wx.TimeSpan.Weeks
Parameters:
* days (long)
Returns:
wx.TimeSpan
--------------------------------------------------------------------------------
ToggleButton_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
ToolBar_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
ToolTip_Enable(flag)¶
See wx.ToolTip.Enable
Parameters:
* flag (bool)
--------------------------------------------------------------------------------
ToolTip_SetDelay(milliseconds)¶
See wx.ToolTip.SetDelay
Parameters:
* milliseconds (long)
--------------------------------------------------------------------------------
Trap()¶
In debug mode this function generates a debugger exception meaning that the
control is passed to the debugger if one is attached to the process. Otherwise
the program just terminates abnormally.
In release mode this function does nothing.
--------------------------------------------------------------------------------
TreeCtrl_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
UpdateUIEvent_CanUpdate(win)¶
Returns True if it is appropriate to update (send UI update events to) this
window.
This function looks at the mode used (see wx.UpdateUIEvent.SetMode), the
wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update events were last
sent in idle time, and the update interval, to determine whether events should
be sent to this window now.
By default this will always return true because the update mode is initially
wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update events will be
sent as often as possible. You can reduce the frequency that events are sent by
changing the mode and/or setting an update interval.
Parameters:
* win (wx.Window)
Returns:
bool
--------------------------------------------------------------------------------
UpdateUIEvent_GetMode()¶
Returns a value specifying how wxWidgets will send update events: to all
windows, or only to those which specify that they will process the events.
Returns:
int
--------------------------------------------------------------------------------
UpdateUIEvent_GetUpdateInterval()¶
Returns the current interval between updates in milliseconds.
Set -1 to disable updates, 0 to update as frequently as possible.
Returns:
int
--------------------------------------------------------------------------------
UpdateUIEvent_ResetUpdateTime()¶ Used internally to reset the last-updated time
to the current time. It is assumed that update events are normally sent in idle
time, so this is called at the end of idle processing.
--------------------------------------------------------------------------------
UpdateUIEvent_SetMode(mode)¶
Specify how wxWidgets will send update events: to all windows, or only to those
which specify that they will process the events.
mode may be one of the following values:
* wx.UPDATE_UI_PROCESS_ALL, Send UI update events to all windows
* wx.UPDATE_UI_PROCESS_SPECIFIED, Send UI update events to windows that have
the wx.WS_EX_PROCESS_UI_UPDATES flag specified
The default is wx.UPDATE_UI_PROCESS_ALL.
Parameters:
* mode (int)
--------------------------------------------------------------------------------
UpdateUIEvent_SetUpdateInterval(updateInterval)¶
Sets the interval between updates in milliseconds. Set to -1 to disable updates,
or to 0 to update as frequently as possible. The default is 0.
Use this to reduce the overhead of UI update events if your application has a
lot of windows. If you set the value to -1 or greater than 0, you may also need
to call wx.Window.UpdateWindowUI at appropriate points in your application, such
as when a dialog is about to be shown.
Parameters:
* updateInterval (long)
--------------------------------------------------------------------------------
Usleep(secs)¶
Sleeps for the specified number of seconds.
Parameters:
* secs (int)
--------------------------------------------------------------------------------
Validator_IsSilent()¶
See wx.Validator.IsSilent
Returns:
bool
--------------------------------------------------------------------------------
Validator_SetBellOnError(doIt=True)¶
See wx.Validator.SetBellOnError
Parameters:
* doIt (int)
--------------------------------------------------------------------------------
version()
Returns a string containing version and port info.
Returns:
string
--------------------------------------------------------------------------------
WakeUpIdle()¶
This functions wakes up the (internal and platform dependent) idle system, i.e.
it will force the system to send an idle event even if the system currently is
idle and thus would not send any idle event until after some other event would
get sent.
This is also useful for sending events between two threads and is used by the
corresponding functions wx.PostEvent and wx.EvtHandler.AddPendingEvent.
--------------------------------------------------------------------------------
WakeUpMainThread()¶ No docstrings available for this function.
--------------------------------------------------------------------------------
Window_FindFocus()¶
Returns the window or control that currently has the keyboard focus, or None.
Returns:
wx.Window
--------------------------------------------------------------------------------
Window_FromHWND()¶ No docstrings available for this function.
--------------------------------------------------------------------------------
Window_GetCapture()¶
Returns the window which currently captures the mouse or None.
Returns:
wx.Window
--------------------------------------------------------------------------------
Window_GetClassDefaultAttributes(variant=wx.WINDOW_VARIANT_NORMAL)¶
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 user’s 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
wx.Window.SetWindowVariant for more about this.
Parameters:
* variant (int)
Returns:
wx.VisualAttributes
--------------------------------------------------------------------------------
Window_NewControlId()¶
Generate a control id for the controls which were not given one.
Returns:
int
--------------------------------------------------------------------------------
Window_NextControlId(winid)¶
Get the id of the control following the one with the given autogenerated) winid.
Parameters:
* winid (int)
Returns:
int
--------------------------------------------------------------------------------
Window_PrevControlId(winid)¶
Get the id of the control preceding the one with the given autogenerated) winid.
Parameters:
* winid (int)
Returns:
int
--------------------------------------------------------------------------------
Yield()¶
Yield to other apps/messages. Convenience for wx.GetApp().Yield().
Returns:
bool
Note
This function is kept only for backwards compatibility. Please use the
wx.GetApp().Yield() method instead in any new code.
--------------------------------------------------------------------------------
YieldIfNeeded()¶
Yield to other apps/messages. Convenience for wx.GetApp().Yield(True).
Returns:
bool
TABLE OF CONTENTS
* wxPython Functions
* Functions Summary
* A
* B
* C
* D
* E
* F
* G
* H
* I
* K
* L
* M
* N
* P
* Q
* R
* S
* T
* U
* V
* W
* Y
* Functions
THIS PAGE
* Show Source
QUICK SEARCH
NAVIGATION
* index
* modules |
*
* Home |
* Search |
* Gallery |
* Documentation »
© Copyright 2008, Andrea Gavana. Last updated on 20-November-2008. Created using
Sphinx 0.5.
Rispetta la tua privacy
Informativa
Noi e terze parti selezionate utilizziamo cookie o tecnologie simili per
finalità tecniche e, con il tuo consenso, anche per altre finalità come
specificato nella cookie policy. Il rifiuto del consenso può rendere non
disponibili le relative funzioni.
Per quanto riguarda la pubblicità, noi e terze parti selezionate, potremmo
utilizzare dati di geolocalizzazione precisi e l’identificazione attraverso la
scansione del dispositivo, al fine di archiviare e/o accedere a informazioni su
un dispositivo e trattare dati personali come i tuoi dati di utilizzo, per le
seguenti finalità pubblicitarie: annunci e contenuti personalizzati, valutazione
degli annunci e del contenuto, osservazioni del pubblico e sviluppo di prodotti.
Puoi liberamente prestare, rifiutare o revocare il tuo consenso, in qualsiasi
momento, accedendo al pannello delle preferenze.
RifiutaPersonalizzaAccetta