# wxLua 2.8.12.2 Reference Manual for wxWidgets 2.8.12

## Classes

Class Name | In wxWidgets Manual | Wrapped by wxLua | Notes
--- | --- | --- | ---
wxANIHandler |  | X |
wxAboutDialogInfo | X | X |
wxAcceleratorEntry | X | X |
wxAcceleratorTable | X | X |
wxAccessible | X |  | MS Windows only and disabled by default in wxWidgets
wxActivateEvent | X | X |
wxActiveXContainer | X |  |
wxActiveXEvent | X |  |
wxAnimation | X | X |
wxAnimationCtrl | X | X |
wxApp | X | X |
wxAppTraits | X |  | Most functions are available elsewhere
wxArchiveClassFactory | X |  |
wxArchiveEntry | X |  |
wxArchiveFSHandler |  | X |
wxArchiveInputStream | X |  |
wxArchiveIterator | X |  |
wxArchiveNotifier | X |  |
wxArchiveOutputStream | X |  |
wxArray | X |  | Not a real class, see implementations (wxArrayInt)
wxArrayInt |  | X | Interchangeable with a numeric indexed Lua table
wxArrayString | X | X | Interchangeable with a numeric indexed Lua table
wxArrayVideoModes |  | X |
wxArtProvider | X | X |
wxAuiDefaultDockArt |  | X |
wxAuiDefaultTabArt |  | X |
wxAuiDefaultToolBarArt |  | X |
wxAuiDockArt | X | X |
wxAuiDockInfo |  | X |
wxAuiDockUIPart |  | X |
wxAuiFloatingFrame |  | X |
wxAuiMDIChildFrame |  | X |
wxAuiMDIClientWindow |  | X |
wxAuiMDIParentFrame |  | X |
wxAuiManager | X | X |
wxAuiManagerEvent |  | X |
wxAuiNotebook | X | X |
wxAuiNotebookEvent |  | X |
wxAuiNotebookPage |  | X |
wxAuiNotebookPageArray |  | X |
wxAuiPaneButton |  | X |
wxAuiPaneInfo | X | X |
wxAuiPaneInfoArray |  | X |
wxAuiSimpleTabArt |  | X |
wxAuiTabArt | X | X |
wxAuiTabContainerButton |  | X |
wxAuiTabCtrl |  | X |
wxAuiToolBar |  | X |
wxAuiToolBarArt |  | X |
wxAuiToolBarEvent |  | X |
wxAuiToolBarItem |  | X |
wxAuiToolBarItemArray |  | X |
wxAutoBufferedPaintDC | X | X |
wxAutomationObject | X |  |
wxBMPHandler |  | X |
wxBestHelpController |  | X |
wxBitmap | X | X |
wxBitmapButton | X | X |
wxBitmapComboBox | X | X |
wxBitmapDataObject | X | X |
wxBitmapHandler | X |  | Base class for bitmap loaders, not needed
wxBookCtrlBase |  | X |
wxBookCtrlBaseEvent |  | X |
wxBoxSizer | X | X |
wxBrush | X | X |
wxBrushList | X | X |
wxBufferedDC | X | X |
wxBufferedInputStream | X |  |
wxBufferedOutputStream | X |  |
wxBufferedPaintDC | X | X |
wxBusyCursor | X | X |
wxBusyInfo | X | X |
wxButton | X | X |
wxCSConv | X |  | Lua uses ANSI 8-bit strings
wxCURHandler |  | X |
wxCalculateLayoutEvent | X | X |
wxCalendarCtrl | X | X |
wxCalendarDateAttr | X | X |
wxCalendarEvent | X | X |
wxCaret | X | X |
wxCaretSuspend |  | X |
wxCheckBox | X | X |
wxCheckListBox | X | X |
wxChildFocusEvent | X | X |
wxChoice | X | X |
wxChoicebook | X | X |
wxChoicebookEvent |  | X |
wxClassInfo | X | X |
wxClient | X |  |
wxClientDC | X | X |
wxClientData | X | X |
wxClientDataContainer | X | X |
wxClipboard | X | X |
wxClipboardLocker |  | X |
wxClipboardTextEvent | X | X |
wxCloseEvent | X | X |
wxCmdLineParser | X |  | Easier to implement in Lua
wxCollapsiblePane | X | X |
wxCollapsiblePaneEvent | X | X |
wxColour | X | X |
wxColourData | X | X |
wxColourDatabase | X | X |
wxColourDialog | X | X |
wxColourPickerCtrl | X | X |
wxColourPickerEvent | X | X |
wxComboBox | X | X |
wxComboCtrl | X |  |
wxComboPopup | X |  |
wxCommand | X | X |
wxCommandEvent | X | X |
wxCommandProcessor | X | X |
wxCondition | X |  | For threading in C
wxConfig |  | X |
wxConfigBase | X | X |
wxConfigPathChanger |  | X |
wxConnection | X |  |
wxContextHelp | X | X |
wxContextHelpButton | X | X |
wxContextMenuEvent | X | X |
wxControl | X | X |
wxControlWithItems | X | X |
wxCountingOutputStream | X |  |
wxCriticalSection | X | X |
wxCriticalSectionLocker | X | X |
wxCursor | X | X |
wxCustomDataObject | X |  |
wxDC | X | X |
wxDCClipper | X | X |
wxDDEClient | X |  |
wxDDEConnection | X |  |
wxDDEServer | X |  |
wxDataFormat | X | X |
wxDataInputStream | X | X |
wxDataObject | X | X |
wxDataObjectComposite | X | X |
wxDataObjectSimple | X | X |
wxDataOutputStream | X | X |
wxDataViewBitmapRenderer | X |  |
wxDataViewColumn | X |  |
wxDataViewCtrl | X |  |
wxDataViewCustomRenderer | X |  |
wxDataViewDateRenderer | X |  |
wxDataViewEvent | X |  |
wxDataViewListModel | X |  |
wxDataViewListModelNotifier | X |  |
wxDataViewModel | X |  |
wxDataViewProgressRenderer | X |  |
wxDataViewRenderer | X |  |
wxDataViewSortedListModel | X |  |
wxDataViewTextRenderer | X |  |
wxDataViewToggleRenderer | X |  |
wxDatagramSocket | X |  |
wxDateEvent | X | X |
wxDatePickerCtrl | X | X |
wxDateSpan | X | X |
wxDateTime | X | X |
wxDateTime::TimeZone |  | X |
wxDateTimeArray |  | X |
wxDateTimeHolidayAuthority | X | X |
wxDateTimeWorkDays | X | X |
wxDb | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbColDataPtr | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbColDef | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbColFor | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbColInf | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbConnectInf | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbGridColInfo | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbGridTableBase | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbIdxDef | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbInf | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbTable | X |  | Deprecated and will not be in wxWidgets 3.0
wxDbTableInf | X |  | Deprecated and will not be in wxWidgets 3.0
wxDebugContext | X |  |
wxDebugReport | X |  |
wxDebugReportCompress | X |  |
wxDebugReportPreview | X |  |
wxDebugReportPreviewStd | X |  |
wxDebugReportUpload | X |  |
wxDebugStreamBuf | X |  |
wxDelegateRendererNative | X |  |
wxDialUpEvent | X |  |
wxDialUpManager | X |  |
wxDialog | X | X |
wxDir | X | X |
wxDirDialog | X | X |
wxDirPickerCtrl | X | X |
wxDirTraverser | X |  | Use wxDir::GetFirst() and GetNext()
wxDisplay | X | X |
wxDisplayChangedEvent |  | X |
wxDllLoader | X |  | Deprecated since version 2.4, see wxDynamicLibrary
wxDocChildFrame | X | X |
wxDocMDIChildFrame | X | X |
wxDocMDIParentFrame | X | X |
wxDocManager | X | X |
wxDocParentFrame | X | X |
wxDocTemplate | X | X |
wxDocument | X | X |
wxDragImage | X |  |
wxDropFilesEvent | X | X |
wxDropSource | X | X |
wxDropTarget | X | X |
wxDynamicLibrary | X | X |
wxDynamicLibraryDetails | X | X |
wxDynamicLibraryDetailsArray |  | X |
wxEffects |  | X |
wxEncodingConverter | X |  | Lua uses ANSI 8-bit strings
wxEraseEvent | X | X |
wxEvent | X | X |
wxEvtHandler | X | X |
wxExtHelpController |  | X |
wxFFile | X |  |
wxFFileInputStream | X |  |
wxFFileOutputStream | X |  |
wxFFileStream | X |  |
wxFSFile | X | X |
wxFTP | X | X |
wxFile | X | X |
wxFileConfig | X | X |
wxFileDataObject | X | X |
wxFileDialog | X | X |
wxFileDirPickerCtrlBase |  | X |
wxFileDirPickerEvent | X | X |
wxFileDropTarget | X | X |
wxFileHistory | X | X |
wxFileInputStream | X | X |
wxFileName | X | X |
wxFileOutputStream | X | X |
wxFilePickerCtrl | X | X |
wxFileStream | X |  |
wxFileSystem | X | X |
wxFileSystemHandler | X | X |
wxFileSystemWatcher |  | X |
wxFileSystemWatcherEvent |  | X |
wxFileType | X | X |
wxFileType::MessageParameters |  | X |
wxFileTypeInfo |  | X |
wxFilterClassFactory | X |  |
wxFilterFSHandler |  | X |
wxFilterInputStream | X |  |
wxFilterOutputStream | X |  |
wxFindDialogEvent | X | X |
wxFindReplaceData | X | X |
wxFindReplaceDialog | X | X |
wxFlexGridSizer | X | X |
wxFocusEvent | X | X |
wxFont | X | X |
wxFontData | X | X |
wxFontDialog | X | X |
wxFontEnumerator | X | X |
wxFontList | X | X |
wxFontMapper | X | X |
wxFontPickerCtrl | X | X |
wxFontPickerEvent | X | X |
wxFrame | X | X |
wxGBPosition | X | X |
wxGBSizerItem | X | X |
wxGBSpan | X | X |
wxGDIObject | X | X |
wxGIFHandler |  | X |
wxGLCanvas | X | X |
wxGLContext | X | X |
wxGauge | X | X |
wxGenericDirCtrl | X | X |
wxGenericValidator | X | X |
wxGraphicsBrush | X |  |
wxGraphicsContext | X |  |
wxGraphicsFont | X |  |
wxGraphicsMatrix | X |  |
wxGraphicsObject | X |  |
wxGraphicsPath | X |  |
wxGraphicsPen | X |  |
wxGraphicsRenderer | X |  |
wxGrid | X | X |
wxGridBagSizer | X | X |
wxGridCellAttr | X | X |
wxGridCellAttrProvider |  | X |
wxGridCellAutoWrapStringEditor |  | X |
wxGridCellAutoWrapStringRenderer |  | X |
wxGridCellBoolEditor | X | X |
wxGridCellBoolRenderer | X | X |
wxGridCellChoiceEditor | X | X |
wxGridCellCoords |  | X |
wxGridCellCoordsArray |  | X |
wxGridCellDateTimeRenderer |  | X |
wxGridCellEditor | X | X |
wxGridCellEnumEditor |  | X |
wxGridCellEnumRenderer |  | X |
wxGridCellFloatEditor | X | X |
wxGridCellFloatRenderer | X | X |
wxGridCellNumberEditor | X | X |
wxGridCellNumberRenderer | X | X |
wxGridCellRenderer | X | X |
wxGridCellStringRenderer | X | X |
wxGridCellTextEditor | X | X |
wxGridCellWorker |  | X |
wxGridEditorCreatedEvent | X | X |
wxGridEvent | X | X |
wxGridRangeSelectEvent | X | X |
wxGridSizeEvent | X | X |
wxGridSizer | X | X |
wxGridStringTable |  | X |
wxGridTableBase | X | X |
wxGridTableMessage |  | X |
wxHTTP | X | X |
wxHashMap | X |  | Lua tables are hash tables
wxHashSet | X |  | Lua tables are hash tables
wxHashTable | X |  | Lua tables are hash tables
wxHeaderButtonParams |  | X |
wxHelpController | X | X |
wxHelpControllerBase |  | X |
wxHelpControllerHelpProvider | X | X |
wxHelpEvent | X | X |
wxHelpProvider | X | X |
wxHtmlCell | X | X |
wxHtmlCellEvent | X | X |
wxHtmlColourCell | X | X |
wxHtmlContainerCell | X | X |
wxHtmlDCRenderer | X | X |
wxHtmlEasyPrinting | X | X |
wxHtmlFilter | X |  |
wxHtmlFontCell |  | X |
wxHtmlHelpController | X | X |
wxHtmlHelpData | X | X |
wxHtmlHelpDialog | X |  |
wxHtmlHelpFrame | X |  |
wxHtmlHelpWindow | X |  |
wxHtmlLinkEvent | X |  |
wxHtmlLinkInfo | X | X |
wxHtmlListBox | X |  |
wxHtmlModalHelp | X |  |
wxHtmlParser | X | X |
wxHtmlPrintout | X | X |
wxHtmlTag | X | X |
wxHtmlTagHandler | X |  |
wxHtmlTagsModule | X |  |
wxHtmlWidgetCell | X | X |
wxHtmlWinParser | X | X |
wxHtmlWinTagHandler | X |  |
wxHtmlWindow | X | X |
wxHtmlWindowInterface |  | X |
wxHyperlinkCtrl | X | X |
wxHyperlinkEvent | X | X |
wxICOHandler |  | X |
wxIFFHandler |  | X |
wxIPV4address | X | X |
wxIPaddress | X | X |
wxIcon | X | X |
wxIconBundle | X | X |
wxIconLocation | X | X |
wxIconizeEvent | X | X |
wxIdleEvent | X | X |
wxImage | X | X |
wxImageHandler | X | X |
wxImageHistogram |  | X |
wxImageHistogram::iterator |  | X |
wxImageHistogramEntry |  | X |
wxImageList | X | X |
wxIndividualLayoutConstraint | X | X |
wxInfoBar |  | X |
wxInitDialogEvent | X | X |
wxInputStream | X | X |
wxInternetFSHandler |  | X |
wxItemContainer |  | X |
wxItemContainerImmutable |  | X |
wxJPEGHandler |  | X |
wxJoystick | X | X |
wxJoystickEvent | X | X |
wxKeyEvent | X | X |
wxLanguageInfo |  | X |
wxLayoutAlgorithm | X | X |
wxLayoutConstraints | X | X |
wxList | X | X |
wxListBox | X | X |
wxListCtrl | X | X |
wxListEvent | X | X |
wxListItem | X | X |
wxListItemAttr | X | X |
wxListView | X | X |
wxListbook | X | X |
wxListbookEvent |  | X |
wxLocalFSHandler |  | X |
wxLocale | X | X |
wxLog | X | X |
wxLogBuffer |  | X |
wxLogChain | X | X |
wxLogGui | X | X |
wxLogNull | X | X |
wxLogPassThrough | X | X |
wxLogStderr | X |  |
wxLogStream | X |  |
wxLogTextCtrl | X | X |
wxLogWindow | X | X |
wxLongLong | X | X |
wxLuaArtProvider |  | X |
wxLuaDataObjectSimple |  | X |
wxLuaDebuggerEvent |  | X |
wxLuaDebuggerServer |  | X |
wxLuaEvent |  | X |
wxLuaFileDropTarget |  | X |
wxLuaGridTableBase |  | X |
wxLuaHtmlWinTagEvent |  | X |
wxLuaHtmlWindow |  | X |
wxLuaListCtrl |  | X |
wxLuaObject |  | X |
wxLuaPrintout |  | X |
wxLuaState |  | X |
wxLuaTextDropTarget |  | X |
wxLuaTreeItemData |  | X |
wxLuaURLDropTarget |  | X |
wxMBConv | X |  | Lua uses ANSI 8-bit strings
wxMBConvFile | X |  | Lua uses ANSI 8-bit strings
wxMBConvUTF16 | X |  | Lua uses ANSI 8-bit strings
wxMBConvUTF32 | X |  | Lua uses ANSI 8-bit strings
wxMBConvUTF7 | X |  | Lua uses ANSI 8-bit strings
wxMBConvUTF8 | X |  | Lua uses ANSI 8-bit strings
wxMDIChildFrame | X | X |
wxMDIClientWindow | X | X |
wxMDIParentFrame | X | X |
wxMask | X | X |
wxMaximizeEvent | X | X |
wxMediaCtrl | X | X |
wxMediaEvent | X | X |
wxMemoryBuffer | X |  |
wxMemoryConfig |  | X |
wxMemoryDC | X | X |
wxMemoryFSHandler | X | X |
wxMemoryInputStream | X | X |
wxMemoryOutputStream | X |  |
wxMenu | X | X |
wxMenuBar | X | X |
wxMenuEvent | X | X |
wxMenuItem | X | X |
wxMenuItemList |  | X |
wxMessageDialog | X | X |
wxMetafile | X | X |
wxMetafileDC | X | X |
wxMimeTypesManager | X | X |
wxMiniFrame | X | X |
wxMirrorDC | X | X |
wxModule | X |  | Useable in C++ only
wxMouseCaptureChangedEvent | X | X |
wxMouseCaptureLostEvent | X | X |
wxMouseEvent | X | X |
wxMouseState |  | X |
wxMoveEvent | X | X |
wxMultiChoiceDialog | X | X |
wxMutex | X |  | For threading in C
wxMutexLocker | X |  | For threading in C
wxNativeFontInfo |  | X |
wxNavigationKeyEvent |  | X |
wxNode | X | X |
wxNotebook | X | X |
wxNotebookEvent | X | X |
wxNotebookPage |  | X |
wxNotebookSizer | X | X |
wxNotifyEvent | X | X |
wxObject | X | X |
wxObjectRefData | X | X |
wxOutputStream | X | X |
wxOwnerDrawnComboBox | X |  |
wxPCXHandler |  | X |
wxPNGHandler |  | X |
wxPNMHandler |  | X |
wxPageSetupDialog | X | X |
wxPageSetupDialogData | X | X |
wxPaintDC | X | X |
wxPaintEvent | X | X |
wxPalette | X | X |
wxPaletteChangedEvent |  | X |
wxPanel | X | X |
wxPasswordEntryDialog | X | X |
wxPathList | X | X |
wxPen | X | X |
wxPenList | X | X |
wxPickerBase | X | X |
wxPlatformInfo | X | X |
wxPoint | X | X |
wxPoint2DDouble |  | X |
wxPoint2DInt |  | X |
wxPopupTransientWindow |  | X |
wxPopupWindow |  | X |
wxPostScriptDC | X | X |
wxPowerEvent | X | X |
wxPreviewCanvas | X | X |
wxPreviewControlBar | X | X |
wxPreviewFrame | X | X |
wxPrintData | X | X |
wxPrintDialog | X | X |
wxPrintDialogData | X | X |
wxPrintPreview | X | X |
wxPrinter | X | X |
wxPrinterDC | X | X |
wxPrintout | X | X |
wxProcess | X | X |
wxProcessEvent | X | X |
wxProgressDialog | X | X |
wxPropagateOnce |  | X |
wxPropagationDisabler |  | X |
wxPropertySheetDialog | X |  |
wxProtocol | X | X |
wxQuantize | X | X |
wxQueryLayoutInfoEvent | X | X |
wxQueryNewPaletteEvent |  | X |
wxRadioBox | X | X |
wxRadioButton | X | X |
wxRealPoint | X |  | Not used anywhere in wxWidgets
wxRect | X | X |
wxRect2DDouble |  | X |
wxRect2DInt |  | X |
wxRecursionGuard | X |  | Easier to implement in Lua
wxRecursionGuardFlag | X |  | Easier to implement in Lua
wxRegEx | X | X |
wxRegKey | X |  |
wxRegion | X | X |
wxRegionIterator | X | X |
wxRendererNative | X | X |
wxRendererVersion | X | X |
wxRichTextAttr | X |  |
wxRichTextBuffer | X |  |
wxRichTextCharacterStyleDefinition | X |  |
wxRichTextCtrl | X |  |
wxRichTextEvent | X |  |
wxRichTextFileHandler | X |  |
wxRichTextFormattingDialog | X |  |
wxRichTextFormattingDialogFactory | X |  |
wxRichTextHTMLHandler | X |  |
wxRichTextHeaderFooterData | X |  |
wxRichTextListStyleDefinition | X |  |
wxRichTextParagraphStyleDefinition | X |  |
wxRichTextPrinting | X |  |
wxRichTextPrintout | X |  |
wxRichTextRange | X |  |
wxRichTextStyleComboCtrl | X |  |
wxRichTextStyleDefinition | X |  |
wxRichTextStyleListBox | X |  |
wxRichTextStyleListCtrl | X |  |
wxRichTextStyleOrganiserDialog | X |  |
wxRichTextStyleSheet | X |  |
wxRichTextXMLHandler | X |  |
wxSashEvent | X | X |
wxSashLayoutWindow | X | X |
wxSashWindow | X | X |
wxScopedArray | X |  | Useable in C++ only (unnecessary in Lua)
wxScopedPtr | X |  | Useable in C++ only (unnecessary in Lua)
wxScopedTiedPtr | X |  | Useable in C++ only (unnecessary in Lua)
wxScreenDC | X | X |
wxScrollBar | X | X |
wxScrollEvent | X | X |
wxScrollWinEvent | X | X |
wxScrolledWindow | X | X |
wxSearchCtrl | X |  |
wxSemaphore | X |  | For threading in C
wxServer | X |  |
wxSetCursorEvent | X | X |
wxShowEvent |  | X |
wxSimpleHelpProvider | X | X |
wxSimpleHtmlListBox | X | X |
wxSingleChoiceDialog | X | X |
wxSingleInstanceChecker | X | X |
wxSize | X | X |
wxSizeEvent | X | X |
wxSizer | X | X |
wxSizerFlags | X | X |
wxSizerItem | X | X |
wxSizerItemList |  | X |
wxSlider | X | X |
wxSockAddress | X | X |
wxSocketBase | X | X |
wxSocketClient | X | X |
wxSocketEvent | X | X |
wxSocketInputStream | X |  |
wxSocketOutputStream | X |  |
wxSocketServer | X | X |
wxSortedArrayString |  | X | Interchangeable with a numeric indexed Lua table
wxSound | X | X |
wxSpinButton | X | X |
wxSpinCtrl | X | X |
wxSpinEvent | X | X |
wxSplashScreen | X | X |
wxSplashScreenWindow |  | X |
wxSplitterEvent | X | X |
wxSplitterRenderParams | X | X |
wxSplitterWindow | X | X |
wxStackFrame | X |  |
wxStackWalker | X |  |
wxStandardPaths | X | X |
wxStaticBitmap | X | X |
wxStaticBox | X | X |
wxStaticBoxSizer | X | X |
wxStaticLine | X | X |
wxStaticText | X | X |
wxStatusBar | X | X |
wxStdDialogButtonSizer | X | X |
wxStockGDI |  | X |
wxStopWatch | X | X |
wxStreamBase | X | X |
wxStreamBuffer | X |  |
wxStreamToTextRedirector | X |  |
wxString | X | X | Interchangeable with a Lua string
wxString::const_iterator |  | X |
wxString::iterator |  | X |
wxStringBuffer | X |  | Useable in C++ only (unnecessary in Lua)
wxStringBufferLength | X |  | Useable in C++ only (unnecessary in Lua)
wxStringClientData | X | X |
wxStringInputStream | X |  |
wxStringOutputStream | X |  |
wxStringTokenizer | X | X |
wxStyledTextCtrl |  | X |
wxStyledTextEvent |  | X |
wxSymbolPickerDialog | X |  |
wxSysColourChangedEvent | X | X |
wxSystemOptions | X | X |
wxSystemSettings | X | X |
wxTCPClient | X |  |
wxTCPConnection | X |  |
wxTCPServer | X |  |
wxTGAHandler |  | X |
wxTIFFHandler |  | X |
wxTabCtrl |  | X |
wxTabEvent |  | X |
wxTarClassFactory | X |  |
wxTarEntry | X |  |
wxTarInputStream | X |  |
wxTarOutputStream | X |  |
wxTaskBarIcon | X | X |
wxTaskBarIconEvent |  | X |
wxTempFile | X | X |
wxTempFileOutputStream | X |  |
wxTextAttr | X | X |
wxTextAttrEx | X |  |
wxTextCtrl | X | X |
wxTextDataObject | X | X |
wxTextDropTarget | X | X |
wxTextEntryDialog | X | X |
wxTextFile | X |  |
wxTextInputStream | X |  |
wxTextOutputStream | X |  |
wxTextUrlEvent |  | X |
wxTextValidator | X | X |
wxThread | X |  |
wxThreadHelper | X |  |
wxTimeSpan | X | X |
wxTimer | X | X |
wxTimerEvent | X | X |
wxTipProvider | X |  |
wxTipWindow | X |  |
wxToggleButton | X | X |
wxToolBar | X | X |
wxToolBarBase |  | X |
wxToolBarSimple |  | X |
wxToolBarToolBase |  | X |
wxToolTip | X | X |
wxToolbook | X | X |
wxToolbookEvent |  | X |
wxTopLevelWindow | X | X |
wxTreeCtrl | X | X |
wxTreeEvent | X | X |
wxTreeItemData | X | X |
wxTreeItemId | X | X |
wxTreebook | X | X |
wxTreebookEvent | X | X |
wxULongLong |  | X |
wxURI | X | X |
wxURL | X | X |
wxURLDataObject | X | X |
wxUpdateUIEvent | X | X |
wxVListBox | X |  |
wxVScrolledWindow | X |  |
wxValidator | X | X |
wxVariant | X |  | Unnecessary in Lua
wxVariantData | X |  | Unnecessary in Lua
wxVideoMode |  | X |
wxView | X | X |
wxVisualAttributes |  | X |
wxWave |  | X |
wxWebView |  | X |
wxWebViewArchiveHandler |  | X |
wxWebViewEvent |  | X |
wxWebViewFSHandler |  | X |
wxWebViewFactory |  | X |
wxWebViewHandler |  | X |
wxWebViewHistoryItem |  | X |
wxWinHelpController |  | X |
wxWindow | X | X |
wxWindowCreateEvent | X | X |
wxWindowDC | X | X |
wxWindowDestroyEvent | X | X |
wxWindowDisabler | X | X |
wxWindowList |  | X |
wxWindowUpdateLocker | X | X |
wxWizard | X | X |
wxWizardEvent | X | X |
wxWizardPage | X | X |
wxWizardPageSimple | X | X |
wxWrapSizer |  | X |
wxXPMHandler |  | X |
wxXmlDocument | X | X |
wxXmlNode | X | X |
wxXmlProperty | X | X |
wxXmlResource | X | X |
wxXmlResourceHandler | X |  |
wxZipClassFactory | X |  |
wxZipEntry | X |  |
wxZipInputStream | X |  |
wxZipNotifier | X |  |
wxZipOutputStream | X |  |
wxZlibInputStream | X |  |
wxZlibOutputStream | X |  |

## Enums

Propagation_state
wxAlignment
wxAnimationType
wxArchitecture
wxAuiButtonId
wxAuiDockUIPart::dummy
wxAuiManagerDock
wxAuiManagerOption
wxAuiNotebookOption
wxAuiPaneButtonState
wxAuiPaneDockArtGradients
wxAuiPaneDockArtSetting
wxAuiPaneInfo::wxAuiPaneState
wxAuiPaneInsertLevel
wxAuiToolBarArtSetting
wxAuiToolBarStyle
wxAuiToolBarToolTextOrientation
wxBackgroundStyle
wxBatteryState
wxBitmapType
wxBorder
wxCalendarDateBorder
wxCalendarHitTestResult
wxCheckBoxState
wxConfigBase::EntryType
wxDLFlags
wxDataFormatId
wxDataObject::Direction
wxDateTime::Calendar
wxDateTime::Country
wxDateTime::Month
wxDateTime::NameFlags
wxDateTime::TZ
wxDateTime::WeekDay
wxDateTime::WeekFlags
wxDateTime::Year
wxDirTraverseResult
wxDirection
wxDragResult
wxDuplexMode
wxDynamicLibraryCategory
wxEOL
wxEdge
wxEndianness
wxFSWPathType
wxFSWWarningType
wxFTP::TransferMode
wxFile::OpenMode
wxFile::dummy
wxFileKind
wxFindReplaceDialogStyles
wxFindReplaceFlags
wxFlexSizerGrowMode
wxFloodFillStyle
wxFontEncoding
wxFontFamily
wxFontStyle
wxFontWeight
wxGrid::wxGridSelectionModes
wxGridCellAttr::wxAttrKind
wxGridTableRequest
wxHeaderSortIconType
wxHelpEvent::Origin
wxHelpSearchMode
wxHtmlWindowInterface::HTMLCursor
wxIdleMode
wxImageResizeQuality
wxItemKind
wxKeyCode
wxKeyModifier
wxKeyType
wxKillError
wxKillFlags
wxLanguage
wxLayoutAlignment
wxLayoutDirection
wxLayoutOrientation
wxListColumnFormat
wxLocaleCategory
wxLocaleInfo
wxLocaleInitFlags
wxLuaMethod_Type
wxLuaObject_Type
wxMappingMode
wxMediaCtrlPlayerControls
wxMediaState
wxNavigationKeyEvent::dummy
wxOperatingSystemId
wxOrientation
wxOutCode
wxPaperSize
wxPathFormat
wxPathNormalize
wxPenCap
wxPenJoin
wxPenStyle
wxPluginCategory
wxPolygonFillMode
wxPortId
wxPowerType
wxPrintBin
wxPrintMode
wxPrintQuality
wxPrinterError
wxProtocolError
wxRasterOperationMode
wxRegionContain
wxRegionOp
wxRelationship
wxRendererVersion::dummy
wxSashDragStatus
wxSashEdgePosition
wxSeekMode
wxShutdownFlags
wxSignal
wxSocketError
wxSocketEventFlags
wxSocketFlags
wxSocketNotify
wxSocketType
wxStandardPaths::ResourceCat
wxStockCursor
wxStockGDI::Item
wxStreamError
wxStretch
wxStringTokenizerMode
wxSystemColour
wxSystemFeature
wxSystemFont
wxSystemMetric
wxSystemScreenType
wxTextAttrAlignment
wxTextCtrlHitTestResult
wxToolBarToolStyle
wxTreeItemIcon
wxURIFieldType
wxURIFlags
wxURIHostType
wxURLError
wxUpdateUI
wxUpdateUIMode
wxWebViewFindFlags
wxWebViewNavigationError
wxWebViewReloadFlags
wxWebViewZoom
wxWebViewZoomType
wxWindowVariant
wxXmlNodeType
wxXmlResourceFlags

## Colours used to denote types

Comments - //
Block Comments - /* ... */
Enums - enum
Defines - #define [_string] [_object] [_pointer]
Events - %define_event
Functions - %function
Classes - class
Class Members - %member
Renamed Functions - %rename
Overridden Functions - %override
Operator Functions - operator

## Interface files

wxwidgets/wxbase_base.i
wxwidgets/wxbase_config.i
wxwidgets/wxbase_data.i
wxwidgets/wxbase_datetime.i
wxwidgets/wxbase_file.i
wxwidgets/wxcore_appframe.i
wxwidgets/wxcore_clipdrag.i
wxwidgets/wxcore_controls.i
wxwidgets/wxcore_core.i
wxwidgets/wxcore_defsutils.i
wxwidgets/wxcore_dialogs.i
wxwidgets/wxcore_event.i
wxwidgets/wxcore_gdi.i
wxwidgets/wxcore_geometry.i
wxwidgets/wxcore_help.i
wxwidgets/wxcore_image.i
wxwidgets/wxcore_mdi.i
wxwidgets/wxcore_menutool.i
wxwidgets/wxcore_picker.i
wxwidgets/wxcore_print.i
wxwidgets/wxcore_sizer.i
wxwidgets/wxcore_windows.i
wxwidgets/wxadv_adv.i
wxwidgets/wxadv_grid.i
wxwidgets/wxnet_net.i
wxwidgets/wxmedia_media.i
wxwidgets/wxgl_gl.i
wxwidgets/wxxml_xml.i
wxwidgets/wxxrc_xrc.i
wxwidgets/wxaui_aui.i
wxwidgets/wxhtml_html.i
wxwidgets/wxstc_stc.i
wxwidgets/wxwebview_webview.i
wxlua/wxlua.i
wxlua_debugger/wxluadebugger.i

## wxwidgets/wxbase_base.i - Lua table = 'wx'

// ===========================================================================
// Purpose: Various wxBase classes
// Author: Ray Gilbert, John Labenski
// Created: July 2004
// Copyright: (c) Ray Gilbert
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxWidgets version defines
#define wxMAJOR_VERSION
#define wxMINOR_VERSION
#define wxRELEASE_NUMBER
#define wxSUBRELEASE_NUMBER
#define_wxstring wxVERSION_STRING
bool wxCHECK_VERSION(int major, int minor, int release); // actually a define
bool wxCHECK_VERSION_FULL(int major, int minor, int release, int subrel); // actually a define
#define wxABI_VERSION
// ---------------------------------------------------------------------------
// wxWidgets platform defines
%__WINDOWS__ #define __WINDOWS__ 1
%__WIN16__ #define __WIN16__ 1
%__WIN32__ #define __WIN32__ 1
%__WIN95__ #define __WIN95__ 1
%__WXBASE__ #define __WXBASE__ 1
%__WXCOCOA__ #define __WXCOCOA__ 1
%__WXWINCE__ #define __WXWINCE__ 1
%__WXGTK__ #define __WXGTK__ 1
%__WXGTK12__ #define __WXGTK12__ 1
%__WXGTK20__ #define __WXGTK20__ 1
%__WXMOTIF__ #define __WXMOTIF__ 1
%__WXMOTIF20__ #define __WXMOTIF20__ 1
%__WXMAC__ #define __WXMAC__ 1
%__WXMAC_CLASSIC__ #define __WXMAC_CLASSIC__ 1
%__WXMAC_CARBON__ #define __WXMAC_CARBON__ 1
%__WXMAC_OSX__ #define __WXMAC_OSX__ 1
%__WXMGL__ #define __WXMGL__ 1
%__WXMSW__ #define __WXMSW__ 1
%__WXOS2__ #define __WXOS2__ 1
%__WXOSX__ #define __WXOSX__ 1
%__WXPALMOS__ #define __WXPALMOS__ 1
%__WXPM__ #define __WXPM__ 1
%__WXSTUBS__ #define __WXSTUBS__ 1
%__WXXT__ #define __WXXT__ 1
%__WXX11__ #define __WXX11__ 1
%__WXWINE__ #define __WXWINE__ 1
%__WXUNIVERSAL__ #define __WXUNIVERSAL__ 1
%__X__ #define __X__ 1
// ---------------------------------------------------------------------------
#if wxUSE_ON_FATAL_EXCEPTION
bool wxHandleFatalExceptions(bool doIt = true );
#endif // wxUSE_ON_FATAL_EXCEPTION
// ---------------------------------------------------------------------------
// Network, user, and OS functions
#if !%wxchkver_2_8
enum
{
wxUNKNOWN_PLATFORM,
wxCURSES,
wxXVIEW_X,
wxMOTIF_X,
wxCOSE_X,
wxNEXTSTEP,
wxMAC,
wxMAC_DARWIN,
wxBEOS,
wxGTK,
wxGTK_WIN32,
wxGTK_OS2,
wxGTK_BEOS,
wxGEOS,
wxOS2_PM,
wxWINDOWS,
wxMICROWINDOWS,
wxPENWINDOWS,
wxWINDOWS_NT,
wxWIN32S,
wxWIN95,
wxWIN386,
wxWINDOWS_CE,
wxWINDOWS_POCKETPC,
wxWINDOWS_SMARTPHONE,
wxMGL_UNIX,
wxMGL_X,
wxMGL_WIN32,
wxMGL_OS2,
wxMGL_DOS,
wxWINDOWS_OS2,
wxUNIX,
wxX11,
wxPALMOS,
wxDOS
};
#endif // !%wxchkver_2_8
// ---------------------------------------------------------------------------
#define wxNOT_FOUND // (-1)
// ---------------------------------------------------------------------------
wxString wxGetEmailAddress( );
wxLongLong wxGetFreeMemory( );
wxString wxGetFullHostName( );
wxString wxGetHomeDir( );
wxString wxGetHostName( );
wxString wxGetOsDescription( );
// %override [int version, int major, int minor] wxGetOsVersion( );
// int wxGetOsVersion(int *major = NULL, int *minor = NULL );
int wxGetOsVersion( );
wxString wxGetUserHome(const wxString& user = "" );
wxString wxGetUserId( );
wxString wxGetUserName( );
// ---------------------------------------------------------------------------
// Environmental access functions
// %override [bool lua_string] wxGetEnv(const wxString& var );
// Returns success and the string environment variable.
// C++ Func: bool wxGetEnv(const wxString& var, wxString *value );
bool wxGetEnv(const wxString& var );
bool wxSetEnv(const wxString& var, const wxString& value );
bool wxUnsetEnv(const wxString& var );
// ---------------------------------------------------------------------------
// wxSystemOptions
#if wxLUA_USE_wxSystemOptions
#include "wx/sysopt.h"
class wxSystemOptions : public wxObject
{

> //wxSystemOptions(); // No constructor, all member functions static
> static wxString GetOption(const wxString& name) const;
> static int GetOptionInt(const wxString& name) const;
> static bool HasOption(const wxString& name) const;
> static bool IsFalse(const wxString& name) const;
> #if wxUSE_SYSTEM_OPTIONS
> static void SetOption(const wxString& name, const wxString& value );
> static void SetOption(const wxString& name, int value );
> #endif //wxUSE_SYSTEM_OPTIONS

};
#endif //wxLUA_USE_wxSystemOptions
// ---------------------------------------------------------------------------
// wxPlatformInfo
enum wxOperatingSystemId
{

> wxOS_UNKNOWN, // returned on error
> wxOS_MAC_OS, // Apple Mac OS 8/9/X with Mac paths
> wxOS_MAC_OSX_DARWIN, // Apple Mac OS X with Unix paths
> wxOS_MAC, // wxOS_MAC_OS|wxOS_MAC_OSX_DARWIN,
> wxOS_WINDOWS_9X, // Windows 9x family (95/98/ME );
> wxOS_WINDOWS_NT, // Windows NT family (NT/2000/XP );
> wxOS_WINDOWS_MICRO, // MicroWindows
> wxOS_WINDOWS_CE, // Windows CE (Window Mobile );
> wxOS_WINDOWS, // wxOS_WINDOWS_9X|wxOS_WINDOWS_NT|wxOS_WINDOWS_MICRO|wxOS_WINDOWS_CE,
> wxOS_UNIX_LINUX, // Linux
> wxOS_UNIX_FREEBSD, // FreeBSD
> wxOS_UNIX_OPENBSD, // OpenBSD
> wxOS_UNIX_NETBSD, // NetBSD
> wxOS_UNIX_SOLARIS, // SunOS
> wxOS_UNIX_AIX, // AIX
> wxOS_UNIX_HPUX, // HP/UX
> wxOS_UNIX, // wxOS_UNIX_LINUX|wxOS_UNIX_FREEBSD|wxOS_UNIX_OPENBSD|wxOS_UNIX_NETBSD|wxOS_UNIX_SOLARIS|wxOS_UNIX_AIX|wxOS_UNIX_HPUX,
> wxOS_DOS, // Microsoft DOS
> wxOS_OS2 // OS/2

};
enum wxPortId
{

> wxPORT_UNKNOWN, // returned on error
> wxPORT_BASE, // wxBase, no native toolkit used
> wxPORT_MSW, // wxMSW, native toolkit is Windows API
> wxPORT_MOTIF, // wxMotif, using [Open]Motif or Lesstif
> wxPORT_GTK, // wxGTK, using GTK+ 1.x, 2.x, GPE or Maemo
> !%wxchkver_2_9 wxPORT_MGL, // wxMGL, using wxUniversal
> wxPORT_X11, // wxX11, using wxUniversal
> wxPORT_PM, // wxOS2, using OS/2 Presentation Manager
> wxPORT_OS2, // wxOS2, using OS/2 Presentation Manager
> wxPORT_MAC, // wxMac, using Carbon or Classic Mac API
> wxPORT_COCOA, // wxCocoa, using Cocoa NextStep/Mac API
> wxPORT_WINCE, // wxWinCE, toolkit is WinCE SDK API
> !%wxchkver_2_9 wxPORT_PALMOS, // wxPalmOS, toolkit is PalmOS API
> wxPORT_DFB // wxDFB, using wxUniversal

};
enum wxArchitecture
{

> wxARCH_INVALID, // returned on error
> wxARCH_32, // 32 bit
> wxARCH_64,
> wxARCH_MAX

};
enum wxEndianness
{

> wxENDIAN_INVALID, // returned on error
> wxENDIAN_BIG, // 4321
> wxENDIAN_LITTLE, // 1234
> wxENDIAN_PDP, // 3412
> wxENDIAN_MAX

};
class wxPlatformInfo
{

> // No constructor, use static Get() function
> //wxPlatformInfo();
> //wxPlatformInfo(wxPortId pid, int tkMajor = -1, int tkMinor = -1, wxOperatingSystemId id = wxOS_UNKNOWN, int osMajor = -1, int osMinor = -1, wxArchitecture arch = wxARCH_INVALID, wxEndianness endian = wxENDIAN_INVALID, bool usingUniversal = false );
> // Gets a wxPlatformInfo already initialized with the values for
> // the currently running platform.
> //static const wxPlatformInfo& Get();
> static const wxPlatformInfo& Get( );
> static wxOperatingSystemId GetOperatingSystemId(const wxString &name);
> static wxPortId GetPortId(const wxString &portname);
> static wxArchitecture GetArch(const wxString &arch);
> static wxEndianness GetEndianness(const wxString &end);
> static wxString GetOperatingSystemFamilyName(wxOperatingSystemId os);
> static wxString GetOperatingSystemIdName(wxOperatingSystemId os);
> static wxString GetPortIdName(wxPortId port, bool usingUniversal);
> static wxString GetPortIdShortName(wxPortId port, bool usingUniversal);
> static wxString GetArchName(wxArchitecture arch);
> static wxString GetEndiannessName(wxEndianness end);
> int GetOSMajorVersion() const;
> int GetOSMinorVersion() const;
> bool CheckOSVersion(int major, int minor) const;
> int GetToolkitMajorVersion() const;
> int GetToolkitMinorVersion() const;
> bool CheckToolkitVersion(int major, int minor) const;
> bool IsUsingUniversalWidgets() const;
> wxOperatingSystemId GetOperatingSystemId() const;
> wxPortId GetPortId() const;
> wxArchitecture GetArchitecture() const;
> wxEndianness GetEndianness() const;
> wxString GetOperatingSystemFamilyName() const;
> wxString GetOperatingSystemIdName() const;
> wxString GetPortIdName() const;
> wxString GetPortIdShortName() const;
> wxString GetArchName() const;
> wxString GetEndiannessName() const;
> void SetOSVersion(int major, int minor );
> void SetToolkitVersion(int major, int minor );
> void SetOperatingSystemId(wxOperatingSystemId n );
> void SetPortId(wxPortId n );
> void SetArchitecture(wxArchitecture n );
> void SetEndianness(wxEndianness n );
> bool IsOk() const;
> //bool operator==(const wxPlatformInfo &t) const; // we only use the wxWidget's wxPlatformInfo
> //bool operator!=(const wxPlatformInfo &t) const;

};
// ---------------------------------------------------------------------------
// wxSingleInstanceChecker
#if wxUSE_SNGLINST_CHECKER
#include "wx/snglinst.h"
class %delete wxSingleInstanceChecker
{

> wxSingleInstanceChecker(); // default ctor, use Create() after it
> // like Create() but no error checking (dangerous! );
> //wxSingleInstanceChecker(const wxString& name, const wxString& path = "" );
> // name must be given and be as unique as possible, it is used as the mutex
> // name under Win32 and the lock file name under Unix -
> // wxTheApp->GetAppName() may be a good value for this parameter
> //
> // path is optional and is ignored under Win32 and used as the directory to
> // create the lock file in under Unix (default is wxGetHomeDir() );
> //
> // returns false if initialization failed, it doesn't mean that another
> // instance is running - use IsAnotherRunning() to check it
> bool Create(const wxString& name, const wxString& path = "" );
> bool IsAnotherRunning() const; // is another copy of this program already running?

};
#endif // wxUSE_SNGLINST_CHECKER
// ---------------------------------------------------------------------------
// wxLog - See GUI log bindings in wxcore_core.i
#if wxLUA_USE_wxLog && wxUSE_LOG
#include "wx/log.h"
// These functions are in log.h
unsigned long wxSysErrorCode( );
wxString wxSysErrorMsg(unsigned long nErrCode = 0 );
void wxSafeShowMessage(const wxString& title, const wxString& text );
// All of the wxLogXXX functions take only a single string,
// use string.format(...) to format the string in Lua.
// C++ Func: void wxLogError(const char *formatString, ... );
void wxLogError(const wxString& message );
// C++ Func: void wxLogFatalError(const char *formatString, ... );
void wxLogFatalError(const wxString& message );
// C++ Func: void wxLogWarning(const char *formatString, ... );
void wxLogWarning(const wxString& message );
// C++ Func: void wxLogMessage(const char *formatString, ... );
void wxLogMessage(const wxString& message );
// C++ Func: void wxLogVerbose(const char *formatString, ... );
void wxLogVerbose(const wxString& message );
// C++ Func: void wxLogStatus(wxFrame *frame, const char *formatString, ... );
// void wxLogStatus(const char *formatString, ...); // this just uses the toplevel frame, use wx.NULL for the frame
// IN wxCore void wxLogStatus(wxFrame *frame, const wxString& message );
// C++ Func: void wxLogSysError(const char *formatString, ... );
void wxLogSysError(const wxString& message );
// C++ Func: void wxLogDebug(const char *formatString, ... );
void wxLogDebug(const wxString& message );
// C++ Func: void wxLogTrace(const char *mask, const char *formatString, ... );
void wxLogTrace(const wxString& mask, const wxString& message );
// void wxLogTrace(const char *formatString, ... );
// void wxLogTrace(wxTraceMask mask, const char *formatString, ...) - deprecated
typedef unsigned long wxTraceMask
typedef unsigned long wxLogLevel
enum // wxLogLevel - uses these enums
{

> wxLOG_FatalError, // program can't continue, abort immediately
> wxLOG_Error, // a serious error, user must be informed about it
> wxLOG_Warning, // user is normally informed about it but may be ignored
> wxLOG_Message, // normal message (i.e. normal output of a non GUI app );
> wxLOG_Status, // informational: might go to the status line of GUI app
> wxLOG_Info, // informational message (a.k.a. 'Verbose' );
> wxLOG_Debug, // never shown to the user, disabled in release mode
> wxLOG_Trace, // trace messages are also only enabled in debug mode
> wxLOG_Progress, // used for progress indicator (not yet );
> wxLOG_User, // user defined levels start here
> wxLOG_Max

};
// symbolic trace masks - wxLogTrace("foo", "some trace message...") will be
// discarded unless the string "foo" has been added to the list of allowed
// ones with AddTraceMask( );
#define_wxstring wxTRACE_MemAlloc //wxT("memalloc"); // trace memory allocation (new/delete );
#define_wxstring wxTRACE_Messages //wxT("messages"); // trace window messages/X callbacks
#define_wxstring wxTRACE_ResAlloc //wxT("resalloc"); // trace GDI resource allocation
#define_wxstring wxTRACE_RefCount //wxT("refcount"); // trace various ref counting operations
%msw #define_wxstring wxTRACE_OleCalls //wxT("ole"); // OLE interface calls
class %delete wxLog
{

> //wxLog() - No constructor, a base class, use one of the derived classes.
> static bool IsEnabled( );
> static bool EnableLogging(bool doIt = true );
> virtual void Flush( );
> static void FlushActive( );
> // Don't delete the active target until you set a new one or set it to wx.NULL
> // Note, a new wxLog is created unless DontCreateOnDemand() is called.
> static wxLog *GetActiveTarget( );
> // When you create a new wxLog and call "oldLog = SetActiveTarget(MyLog)"
> // the returned oldLog will be garbage collected or you can delete() the
> // oldLog unless you want to reuse it by calling "myLog = SetActiveTarget(oldLog)"
> // which releases myLog to be garbage collected or delete()ed by you.
> // Basicly, wxWidgets 'owns' the log you pass to SetActiveTarget() and
> // wxLua 'owns' the returned log.
> static %gc wxLog *SetActiveTarget(%ungc wxLog *pLogger );
> static void Suspend( );
> static void Resume( );
> static void SetVerbose(bool bVerbose = true );
> static void SetLogLevel(wxLogLevel logLevel );
> static void DontCreateOnDemand( );
> %wxchkver_2_8 static void SetRepetitionCounting(bool bRepetCounting = true );
> %wxchkver_2_8 static bool GetRepetitionCounting( );
> static void SetTraceMask(wxTraceMask ulMask );
> static void AddTraceMask(const wxString& str );
> static void RemoveTraceMask(const wxString& str );
> static void ClearTraceMasks( );
> static wxArrayString GetTraceMasks(); // not const wxArrayString since we copy it anyway
> // %override static void wxLog::SetTimestamp(const wxString& ts );
> // Allows an input of "nil" or no value to disable time stamping.
> // C++ Func: static void wxLog::SetTimestamp(const wxChar* ts );
> static void SetTimestamp(const wxString& ts );
> static bool GetVerbose( );
> static wxTraceMask GetTraceMask( );
> static bool IsAllowedTraceMask(const wxString& mask );
> static wxLogLevel GetLogLevel( );
> static wxString GetTimestamp( );

};
// ---------------------------------------------------------------------------
// wxLogBuffer
class %delete wxLogBuffer : public wxLog
{

> wxLogBuffer( );
> const wxString& GetBuffer() const; // get the string contents with all messages logged

};
// ---------------------------------------------------------------------------
// wxLogChain
class %delete wxLogChain : public wxLog
{

> wxLogChain(wxLog *logger );
> void SetLog(wxLog *logger); // change the new log target
> // this can be used to temporarily disable (and then reenable) passing
> // messages to the old logger (by default we do pass them );
> void PassMessages(bool bDoPass );
> // are we passing the messages to the previous log target?
> bool IsPassingMessages() const;
> // return the previous log target (may be NULL );
> wxLog *GetOldLog() const;

};
// ---------------------------------------------------------------------------
// wxLogNull
class %delete wxLogNull NOTEolor=#009900>// NOTE: this is not derived from wxLog
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxLogNull( );

};
// ---------------------------------------------------------------------------
// wxLogPassThrough - a chain log target which uses itself as the new logger
class %delete wxLogPassThrough : public wxLogChain
{

> wxLogPassThrough( );

};
// ---------------------------------------------------------------------------
// wxLogStderr - FIXME need to implement FILE*
/*
class %delete wxLogStderr : public wxLog
{

> wxLogStderr(FILE *fp = (FILE *) NULL); // redirect log output to a FILE

};
*/
// ---------------------------------------------------------------------------
// wxLogStream - FIXME need to implement wxSTD ostream* (just use wxLogBuffer );
/*
#if wxUSE_STD_IOSTREAM
class %delete wxLogStream : public wxLog
{

> wxLogStream(wxSTD ostream *ostr = NULL); // redirect log output to an ostream

};
#endif // wxUSE_STD_IOSTREAM
*/
#endif // wxLUA_USE_wxLog && wxUSE_LOG
// ---------------------------------------------------------------------------
// wxDynamicLibrary - No a lot you can do with this, but it might make
// testing or debugging a C++ program easier to test thing
// out in wxLua first.
#if // wxLUA_USE_wxDynamicLibrary && wxUSE_DYNLIB_CLASS
#include "wx/dynlib.h"
enum wxDLFlags
{

> wxDL_LAZY, // resolve undefined symbols at first use
> // (only works on some Unix versions );
> wxDL_NOW, // resolve undefined symbols on load
> // (default, always the case under Win32 );
> wxDL_GLOBAL, // export extern symbols to subsequently
> // loaded libs.
> wxDL_VERBATIM, // attempt to load the supplied library
> // name without appending the usual dll
> // filename extension.
> wxDL_NOSHARE, // load new DLL, don't reuse already loaded
> // (only for wxPluginManager );
> wxDL_DEFAULT, // = wxDL_NOW // default flags correspond to Win32

};
enum wxDynamicLibraryCategory
{

> wxDL_LIBRARY, // standard library
> wxDL_MODULE // loadable module/plugin

};
enum wxPluginCategory
{

> wxDL_PLUGIN_GUI, // plugin that uses GUI classes
> wxDL_PLUGIN_BASE // wxBase-only plugin

};
class %delete wxDynamicLibraryDetails
{

> // ctor, normally never used as these objects are only created by wxDynamicLibrary
> // wxDynamicLibrary::ListLoaded( );
> //wxDynamicLibraryDetails() { m_address = NULL; m_length = 0; }
> wxString GetName() const; // get the (base) name
> wxString GetPath() const; // get the full path of this object
> // get the load address and the extent, return true if this information is available
> //bool GetAddress(void **addr, size_t *len) const;
> wxString GetVersion() const; // return the version of the DLL (may be empty if no version info );

};
class %delete wxDynamicLibraryDetailsArray
{

> //wxDynamicLibraryDetailsArray(); // Get this from wxDynamicLibrary::ListLoaded
> int GetCount() const;
> wxDynamicLibraryDetails Item( int n );

};
class %delete wxDynamicLibrary
{

> wxDynamicLibrary( );
> wxDynamicLibrary(const wxString& libname, int flags = wxDL_DEFAULT );
> // return a valid handle for the main program itself or NULL if back
> // linking is not supported by the current platform (e.g. Win32 );
> //static wxDllType GetProgramHandle();
> // return the platform standard DLL extension (with leading dot );
> //static const wxChar *GetDllExt( );
> static wxString GetDllExt( );
> // return true if the library was loaded successfully
> bool IsLoaded() const;
> // load the library with the given name (full or not), return true if ok
> bool Load(const wxString& libname, int flags = wxDL_DEFAULT);
> // raw function for loading dynamic libs: always behaves as if
> // wxDL_VERBATIM were specified and doesn't log error message if the
> // library couldn't be loaded but simply returns NULL
> //static wxDllType RawLoad(const wxString& libname, int flags = wxDL_DEFAULT);
> // detach the library object from its handle, i.e. prevent the object from
> // unloading the library in its dtor -- the caller is now responsible for doing this
> //wxDllType Detach( );
> // unload the given library handle (presumably returned by Detach() before );
> //static void Unload(wxDllType handle);
> // unload the library, also done automatically in dtor
> void Unload( );
> // Return the raw handle from dlopen and friends.
> //wxDllType GetLibHandle() const; // { return m_handle; }
> // check if the given symbol is present in the library, useful to verify if
> // a loadable module is our plugin, for example, without provoking error
> // messages from GetSymbol( );
> bool HasSymbol(const wxString& name) const;
> // resolve a symbol in a loaded DLL, such as a variable or function name.
> // 'name' is the (possibly mangled) name of the symbol. (use extern "C" to
> // export unmangled names );
> // Since it is perfectly valid for the returned symbol to actually be NULL,
> // that is not always indication of an error. Pass and test the parameter
> // 'success' for a true indication of success or failure to load the symbol.
> // Returns a pointer to the symbol on success, or NULL if an error occurred
> // or the symbol wasn't found.
> //void *GetSymbol(const wxString& name, bool *success = NULL) const;
> // low-level version of GetSymbol( );
> //static void *RawGetSymbol(wxDllType handle, const wxString& name);
> //void *RawGetSymbol(const wxString& name) const;
> //#ifdef __WXMSW__
> // this function is useful for loading functions from the standard Windows
> // DLLs: such functions have an 'A' (in ANSI build) or 'W' (in Unicode, or
> // wide character build) suffix if they take string parameters
> //static void *RawGetSymbolAorW(wxDllType handle, const wxString& name );
> //void *GetSymbolAorW(const wxString& name) const;
> //#endif // __WXMSW__
> // return all modules/shared libraries in the address space of this process
> // returns an empty array if not implemented or an error occurred
> static wxDynamicLibraryDetailsArray ListLoaded();
> // return platform-specific name of dynamic library with proper extension
> // and prefix (e.g. "foo.dll" on Windows or "libfoo.so" on Linux );
> static wxString CanonicalizeName(const wxString& name, wxDynamicLibraryCategory cat = wxDL_LIBRARY);
> // return name of wxWidgets plugin (adds compiler and version info
> // to the filename):
> static wxString CanonicalizePluginName(const wxString& name, wxPluginCategory cat = wxDL_PLUGIN_GUI);
> // return plugin directory on platforms where it makes sense and empty string on others:
> static wxString GetPluginsDirectory( );

};
// ---------------------------------------------------------------------------
// wxPluginLibrary - You cannot use this within wxLua
// ---------------------------------------------------------------------------
// wxPluginManager - You cannot use this within wxLua
#endif // wxLUA_USE_wxDynamicLibrary && wxUSE_DYNLIB_CLASS
// ---------------------------------------------------------------------------
// wxCriticalSection
#if wxLUA_USE_wxCriticalSection && wxUSE_THREADS
#include "wx/thread.h"
class %delete wxCriticalSection
{

> wxCriticalSection( );
> void Enter( );
> void Leave( );

};
#endif // wxLUA_USE_wxCriticalSection
// ---------------------------------------------------------------------------
// wxCriticalSectionLocker
#if wxLUA_USE_wxCriticalSectionLocker
#include "wx/thread.h"
class %delete wxCriticalSectionLocker
{

> wxCriticalSectionLocker(wxCriticalSection& cs);

};
#endif // wxLUA_USE_wxCriticalSectionLocker && wxUSE_THREADS
// ---------------------------------------------------------------------------
// wxRegEx - Regular expression support
#if wxLUA_USE_wxRegEx && wxUSE_REGEX
#include "wx/regex.h"
enum
{
wxRE_EXTENDED,
wxRE_BASIC,
wxRE_ICASE,
wxRE_NOSUB,
wxRE_NEWLINE,
wxRE_DEFAULT
};
enum
{
wxRE_NOTBOL,
wxRE_NOTEOL
};
class %delete wxRegEx
{

> wxRegEx( );
> wxRegEx(const wxString& expr, int flags = wxRE_DEFAULT );
> bool Compile(const wxString& pattern, int flags = wxRE_DEFAULT );
> bool IsValid() const;
> wxString GetMatch(const wxString& text, size_t index = 0) const;
> // %override [bool, size_t start, size_t len] wxRegEx::GetMatch(size_t index = 0) const;
> // C++ Func: bool GetMatch(size_t* start, size_t* len, size_t index = 0) const;
> %override_name wxLua_wxRegEx_GetMatchIndexes bool GetMatch(size_t index = 0) const;
> size_t GetMatchCount() const;
> // Note: only need this form of Matches
> bool Matches(const wxString &text, int flags = 0) const;
> // %override [int, string text] wxRegEx::Replace(const wxString& text, const wxString& replacement, size_t maxMatches = 0) const;
> // C++ Func: int Replace(wxString* text, const wxString& replacement, size_t maxMatches = 0) const;
> int Replace(const wxString& text, const wxString& replacement, size_t maxMatches = 0) const;
> // %override [int, string text] wxRegEx::ReplaceAll(const wxString& text, const wxString& replacement) const;
> // C++ Func: int ReplaceAll(wxString* text, const wxString& replacement) const;
> int ReplaceAll(const wxString& text, const wxString& replacement) const;
> // %override [int, string text] wxRegEx::ReplaceFirst(const wxString& text, const wxString& replacement) const;
> // C++ Func: int ReplaceFirst(wxString* text, const wxString& replacement) const;
> int ReplaceFirst(const wxString& text, const wxString& replacement) const;

};
#endif //wxLUA_USE_wxRegEx && wxUSE_REGEX
// ---------------------------------------------------------------------------
// wxEvtHandler
#include "wx/event.h"
class %delete wxEvtHandler : public wxObject
{

> wxEvtHandler( );
> void AddPendingEvent(wxEvent& event );
> // NOTE: Connect used to be called ConnectEvent in wxLua which is not the name of any C++ function.
> // %override wxEvtHandler::Connect(int id, int lastId, wxEventType eventType, Lua function );
> // %override wxEvtHandler::Connect(int id, wxEventType eventType, Lua function );
> // %override wxEvtHandler::Connect(wxEventType eventType, Lua function );
> // The function type above is determined at runtime depending on the inputs.
> // C++ Func: void Connect(int id, int lastId, wxEventType eventType, wxObjectEventFunction function, wxObject* userData = NULL, wxEvtHandler* eventSink = NULL );
> // Note: wxLua uses the userdata and the event sink and so they're not available
> void Connect(int id, int lastId, wxEventType eventType, LuaFunction func );
> // %override bool Disconnect(int winid, int lastId, wxEventType eventType );
> // %override bool Disconnect(int winid, wxEventType eventType );
> // %override bool Disconnect(wxEventType eventType );
> // The function type above is determined at runtime depending on the inputs.
> // C++ Func: bool Disconnect(int id, int lastId = wxID_ANY, wxEventType eventType = wxEVT_NULL, wxObjectEventFunction function = NULL, wxObject* userData = NULL, wxEvtHandler* eventSink = NULL );
> // Note: wxLua uses the userdata and the event sink and so they're not available
> bool Disconnect(int id, int lastId, wxEventType eventType );
> voidptr_long GetClientData(); // C++ returns (void *) You get a number here
> wxClientData* GetClientObject() const;
> bool GetEvtHandlerEnabled( );
> wxEvtHandler* GetNextHandler( );
> wxEvtHandler* GetPreviousHandler( );
> virtual bool ProcessEvent(wxEvent& event );
> %wxchkver_2_9 virtual void QueueEvent(%ungc wxEvent *event);
> //virtual bool SearchEventTable(wxEventTable& table, wxEvent& event );
> void SetClientData(voidptr_long number); // C++ is (void *clientData) You can put a number here
> void SetClientObject(wxClientData* data );
> void SetEvtHandlerEnabled(bool enabled );
> void SetNextHandler(wxEvtHandler* handler );
> void SetPreviousHandler(wxEvtHandler* handler );

};
// ---------------------------------------------------------------------------
// wxEvent
enum Propagation_state
{

> wxEVENT_PROPAGATE_NONE, // don't propagate it at all
> wxEVENT_PROPAGATE_MAX // propagate it until it is processed

};
class %delete wxEvent : public wxObject
{

> // wxEvent(int id = 0, wxEventType eventType = wxEVT_NULL) virtual base class
> wxObject* GetEventObject( );
> wxEventType GetEventType( );
> int GetId( );
> bool GetSkipped( );
> long GetTimestamp( );
> bool IsCommandEvent() const;
> void ResumePropagation(int propagationLevel );
> void SetEventObject(wxObject* object );
> void SetEventType(wxEventType type );
> void SetId(int id );
> void SetTimestamp(long timeStamp );
> bool ShouldPropagate() const;
> void Skip(bool skip = true );
> int StopPropagation( );

};

## wxwidgets/wxbase_config.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxConfig and wxConfigBase classes
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// TODO - add wxConfigFile and Reg
// ---------------------------------------------------------------------------
// wxConfigBase
#if wxLUA_USE_wxConfig && wxUSE_CONFIG
#include "wx/confbase.h"
#include "wx/config.h"
#include "wx/fileconf.h"
enum
{
wxCONFIG_USE_LOCAL_FILE,
wxCONFIG_USE_GLOBAL_FILE,
wxCONFIG_USE_RELATIVE_PATH,
wxCONFIG_USE_NO_ESCAPE_CHARACTERS,
%wxchkver_2_8_1 wxCONFIG_USE_SUBDIR
};
enum wxConfigBase::EntryType
{

> Type_Unknown,
> Type_String,
> Type_Boolean,
> Type_Integer,
> Type_Float

};
class %delete wxConfigBase
{

> // No constructor since this is a base class
> // %override wxConfigBase::delete() - this is a wxLua provided function to
> // delete the config (or derived class). Created wxConfigs are NOT tracked
> // in memory since you MUST call wxConfigBase::Set(NULL) before
> // deleting them. This is because the wxConfig you install using
> // wxConfigBase::Set may need to exist outside of the scope it was created
> // in and we don't want Lua to garbage collect it.
> //void delete( );
> // Note: the return wxConfig cannot be deleted.
> // You must call "config = Set(wx.NULL); config:delete()"
> static wxConfigBase* Create( );
> static void DontCreateOnDemand( );
> bool DeleteAll( );
> bool DeleteEntry(const wxString& key, bool bDeleteGroupIfEmpty = true );
> bool DeleteGroup(const wxString& key );
> bool Exists(wxString& strName) const;
> bool Flush(bool bCurrentOnly = false );
> static wxConfigBase* Get(bool CreateOnDemand = true );
> wxString GetAppName() const;
> wxConfigBase::EntryType GetEntryType(const wxString& name) const;
> // %override [bool, string, index] wxConfigBase::GetFirstGroup( );
> // C++ Func: bool GetFirstGroup(wxString& str, long& index) const;
> bool GetFirstGroup() const;
> // %override [bool, string, index] wxConfigBase::GetFirstEntry( );
> // C++ Func: bool GetFirstEntry(wxString& str, long& index) const;
> bool GetFirstEntry() const;
> // %override [bool, string, index] wxConfigBase::GetNextGroup(index );
> // C++ Func: bool GetNextGroup(wxString& str, long& index) const;
> bool GetNextGroup() const;
> // %override [bool, string, index] wxConfigBase::GetNextEntry(index );
> // C++ Func: bool GetNextEntry(wxString& str, long& index) const;
> bool GetNextEntry(long index) const;
> unsigned int GetNumberOfEntries(bool bRecursive = false) const;
> unsigned int GetNumberOfGroups(bool bRecursive = false) const;
> const wxString& GetPath() const;
> wxString GetVendorName() const;
> bool HasEntry(wxString& strName) const;
> bool HasGroup(const wxString& strName) const;
> bool IsExpandingEnvVars() const;
> bool IsRecordingDefaults() const;
> // %override [bool, string] wxConfigBase::Read(const wxString& key, const wxString& defaultVal = "" );
> // C++ Func: bool Read(const wxString& key, wxString* str, const wxString& defaultVal) const;
> bool Read(const wxString& key, const wxString& defaultVal = "") const;
> // Since Lua uses double as it's number type, we only read/write doubles
> // %override [bool, double] wxConfigBase::Read(const wxString& key, double defaultVal = 0 );
> // C++ Func: bool Read(const wxString& key, double* d, double defaultVal = 0) const;
> %override_name wxLua_wxConfigBase_ReadFloat bool Read(const wxString& key, double defaultVal) const;
> // // %override [bool, int] wxConfigBase::ReadInt(const wxString& key, long defaultVal = 0 );
> // // C++ Func: bool Read(const wxString& key, long* l, long defaultVal = 0) const;
> // %rename ReadInt bool Read(const wxString& key, long defaultVal = 0) const;
> // // %override [bool, double] wxConfigBase::ReadFloat(const wxString& key, double defaultVal = 0 );
> // // C++ Func: bool Read(const wxString& key, double* d, double defaultVal = 0) const;
> // %rename ReadFloat bool Read(const wxString& key, double defaultVal = 0) const;
> bool RenameEntry(const wxString& oldName, const wxString& newName );
> bool RenameGroup(const wxString& oldName, const wxString& newName );
> static %gc wxConfigBase* Set(%ungc wxConfigBase *pConfig = NULL );
> void SetExpandEnvVars(bool bDoIt = true );
> void SetPath(const wxString& strPath );
> void SetRecordDefaults(bool bDoIt = true );
> bool Write(const wxString& key, wxString &value );
> // Since Lua uses double as it's number type, we only read/write doubles
> bool Write(const wxString &key, double value );
> // %rename WriteInt bool Write(const wxString &key, long value );
> // %rename WriteFloat bool Write(const wxString &key, double value );

};
// ---------------------------------------------------------------------------
// wxConfig
class %delete wxConfig : public wxConfigBase
{

> wxConfig(const wxString& appName = "", const wxString& vendorName = "", const wxString& localFilename = "", const wxString& globalFilename = "", long style = 0 );

};
// ---------------------------------------------------------------------------
// wxFileConfig
class %delete wxFileConfig : public wxConfigBase
{

> wxFileConfig(const wxString& appName = "", const wxString& vendorName = "", const wxString& localFilename = "", const wxString& globalFilename = "", long style = wxCONFIG_USE_LOCAL_FILE | wxCONFIG_USE_GLOBAL_FILE); //, wxMBConv& conv = wxConvUTF8 );
> void SetUmask(int mode );

};
// ---------------------------------------------------------------------------
// wxMemoryConfig
#include "wx/memconf.h"
class %delete wxMemoryConfig : public wxFileConfig
{

> wxMemoryConfig( );

};
// ---------------------------------------------------------------------------
// wxConfigPathChanger
// a handy little class which changes current path to the path of given entry
// and restores it in dtor: so if you declare a local variable of this type,
// you work in the entry directory and the path is automatically restored
// when the function returns
class %delete wxConfigPathChanger
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxConfigPathChanger(const wxConfigBase *pContainer, const wxString& strEntry );
> wxString Name() const;
> %wxchkver_2_8 void UpdateIfDeleted( );

};
#endif //wxLUA_USE_wxConfig && wxUSE_CONFIG

## wxwidgets/wxbase_data.i - Lua table = 'wx'

// ===========================================================================
// Purpose: data classes, wxObject, arrays, lists, hash
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxString - A stub class for people who absolutely need wxStrings
//
// wxLua uses Lua strings for almost everything and any function that takes
// a wxString can take a Lua string. All functions that return a wxString
// actually return Lua string unless otherwise noted.
class %delete wxString
{

> wxString(const wxString& str = "" );
> wxString GetData() const;
> wxString AfterFirst(wxChar ch) const;
> wxString AfterLast(wxChar ch) const;
> wxString BeforeFirst(wxChar ch) const;
> wxString BeforeLast(wxChar ch) const;
> size_t Len() const;
> const wxCharBuffer ToUTF8() const;
> static wxString FromUTF8(const char* s);
> static wxString From8BitData(const char* s);
> wxCharBuffer To8BitData();
> #if %wxchkver_2_9
> //wxString(wxString::const_iterator first, wxString::const_iterator last );
> wxString::const_iterator begin() const;
> wxString::iterator begin( );
> wxString::const_iterator end() const;
> wxString::iterator end( );
> #endif

};
// ---------------------------------------------------------------------------
// wxString::const_iterator - A wxString iterator class
// wxWidgets has wxString iterators in < 2.9, but they are #if wxUSE_STL
// so they are not necessary for anything, in 2.9 they are inputs to some functions.
#if %wxchkver_2_9
class %delete wxString::const_iterator
{

> wxString::const_iterator( );
> wxString::const_iterator(const wxString::const_iterator& i );
> wxString::const_iterator(const wxString::iterator& i );
> //wxUniChar operator*() const;
> char operator*() const;
> wxString::const_iterator& operator=(const wxString::const_iterator& i );
> wxString::const_iterator operator+(ptrdiff_t n) const;
> wxString::const_iterator operator-(ptrdiff_t n) const;

};
// ---------------------------------------------------------------------------
// wxString::iterator - A wxString iterator class
class %delete wxString::iterator
{

> wxString::iterator( );
> wxString::iterator(const wxString::iterator& i );
> //wxUniChar operator*() const;
> char operator*() const;
> wxString::iterator& operator=(const wxString::iterator& i );
> wxString::iterator operator+(ptrdiff_t n) const;
> wxString::iterator operator-(ptrdiff_t n) const;

};
#endif
// ---------------------------------------------------------------------------
// wxStringTokenizer
#include "wx/tokenzr.h"
enum wxStringTokenizerMode
{

> wxTOKEN_INVALID, // set by def ctor until SetString() is called
> wxTOKEN_DEFAULT, // strtok() for whitespace delims, RET_EMPTY else
> wxTOKEN_RET_EMPTY, // return empty token in the middle of the string
> wxTOKEN_RET_EMPTY_ALL, // return trailing empty tokens too
> wxTOKEN_RET_DELIMS, // return the delim with token (implies RET_EMPTY );
> wxTOKEN_STRTOK // behave exactly like strtok(3 );

};
class %delete wxStringTokenizer : public wxObject
{

> wxStringTokenizer( );
> wxStringTokenizer(const wxString& str, const wxString& delims = wxDEFAULT_DELIMITERS, wxStringTokenizerMode mode = wxTOKEN_DEFAULT);
> void SetString(const wxString& str, const wxString& delims = wxDEFAULT_DELIMITERS, wxStringTokenizerMode mode = wxTOKEN_DEFAULT);
> void Reinit(const wxString& str);
> size_t CountTokens() const;
> bool HasMoreTokens() const;
> wxString GetNextToken();
> //wxChar GetLastDelimiter() const;
> wxString GetString() const;
> size_t GetPosition() const;
> wxStringTokenizerMode GetMode() const;
> bool AllowEmpty() const;

};
// ---------------------------------------------------------------------------
// wxClientData
//
// No %delete since the container will delete it and you should only create one
// of these if you plan on attaching it to a container to avoid a memory leak.
//enum wxClientDataType - used internally so we don't need it
//{
// wxClientData_None,
// wxClientData_Object,
// wxClientData_Void
//};
class wxClientData
{

> // declare this as a datatype, but there is nothing we can do with this as
> // it must be derived, see wxStringClientData

};
// ---------------------------------------------------------------------------
// wxStringClientData
//
// No %delete since the container will delete it and you should only create one
// of these if you plan on attaching it to a container to avoid a memory leak.
class wxStringClientData : public wxClientData
{

> wxStringClientData(const wxString& data = "" );
> wxString GetData() const;
> void SetData(const wxString& data );

};
// ---------------------------------------------------------------------------
// wxClientDataContainer
class wxClientDataContainer
{

> wxClientDataContainer( );
> void SetClientObject( wxClientData *data );
> wxClientData *GetClientObject() const;
> void SetClientData( voidptr_long data ); // C++ is (void *clientData) You can put a number here
> // C++ Func: void *GetClientData() const;
> voidptr_long GetClientData() const; // C++ returns (void *) You get a number here

};
// ---------------------------------------------------------------------------
// wxObject
#if wxLUA_USE_wxObject
#include "wx/object.h"
wxObject* wxCreateDynamicObject(const wxString& className );
class %delete wxObject
{

> wxObject( );
> //void Dump(ostream& stream );
> // %override [new class type] wxObject::DynamicCast() converts the wxObject
> // to an object of type classname
> void *DynamicCast(const wxString &classname );
> wxClassInfo* GetClassInfo( );
> wxObjectRefData* GetRefData() const;
> bool IsKindOf(wxClassInfo *info );
> bool IsSameAs(const wxObject& o) const;
> void Ref(const wxObject& clone );
> void SetRefData(wxObjectRefData* data );
> void UnRef( );
> //wxObject& operator=(const wxObject& other );

};
class wxObjectRefData // no %delete since this should be from a wxObject
{

> int GetRefCount() const;

};
#endif //wxLUA_USE_wxObject
// ---------------------------------------------------------------------------
// wxClassInfo
#if wxLUA_USE_wxClassInfo
#include "wx/object.h"
class wxClassInfo // no %delete since we're always getting a static instance
{

> // %override wxClassInfo() constructor creates an instance using wxClassInfo::FindClass
> wxClassInfo(const wxString &name );
> wxObject* CreateObject( );
> static wxClassInfo* FindClass(const wxString &name );
> wxString GetBaseClassName1() const;
> wxString GetBaseClassName2() const;
> const wxClassInfo *GetBaseClass1() const;
> const wxClassInfo *GetBaseClass2() const;
> wxString GetClassName() const;
> int GetSize() const;
> bool IsDynamic( );
> bool IsKindOf(wxClassInfo* info );
> static const wxClassInfo *GetFirst( );
> const wxClassInfo *GetNext() const;

};
#endif //wxLUA_USE_wxClassInfo
// ---------------------------------------------------------------------------
// wxList
#if wxLUA_USE_wxList && !wxUSE_STL
#include "wx/list.h"
enum wxKeyType
{

> wxKEY_NONE,
> wxKEY_INTEGER,
> wxKEY_STRING

};
class %delete wxList // not derived from wxObject in 2.9
{

> wxList( );
> wxNode *Append(wxObject *object );
> wxNode *Append(long key, wxObject *object );
> wxNode *Append(const wxString& key, wxObject *object );
> void Clear( );
> void DeleteContents(bool destroy );
> bool DeleteNode(wxNode *pNode );
> bool DeleteObject(wxObject *pObject );
> wxNode* Find(wxObject* pObject );
> wxNode *Find(long key );
> wxNode *Find(const wxString &key );
> int GetCount() const;
> wxNode *GetFirst( );
> wxNode *GetLast( );
> int IndexOf(wxObject* pObject );
> wxNode *Insert(wxObject *pObject );
> wxNode *Insert(size_t position, wxObject *pObject );
> wxNode *Insert(wxNode *pNode, wxObject *pObject );
> bool IsEmpty() const;
> wxNode *Item(int iIndex) const;
> wxNode *Member(wxObject *pObject );

};
// ---------------------------------------------------------------------------
// wxNode - wxList
class wxNode // no %delete since we get this from a wxList
{

> // no constructor, just use this from a wxList
> wxObject *GetData( );
> wxNode *GetNext( );
> wxNode *GetPrevious( );
> void SetData(wxObject *data );
> //int IndexOf() - unfortunately a protected member of wxNodeBase
> // To convert wxObject* GetData() to another type use wxObject::DynamicCast
> // See wxMenuItemList, wxWindowList
> // Example: How to use a wxWindowList
> // frame = wx.wxFrame(wx.NULL, wx.wxID_ANY, "Test");
> // win = wx.wxWindow(frame, wx.wxID_ANY );
> // frame:Show(true );
> // wlist = frame:GetChildren( );
> // wlist:Item(0):GetData():DynamicCast("wxWindow"):SetBackgroundColour(wx.wxRED );
> // Example: How to use a wxMenuItemList
> // local fileMenu = wx.wxMenu( );
> // fileMenu:Append(wx.wxID_EXIT, "E&xit", "Quit the program" );
> // mList = fileMenu:GetMenuItems( );
> // print(mList:GetCount(), mList:GetFirst():GetData():DynamicCast("wxMenuItem"):GetLabel() );

};
#endif //wxLUA_USE_wxList && !wxUSE_STL
// ---------------------------------------------------------------------------
// wxArray - Can't implement this since it's not really a class.
// Here's the list of generic functions.
//class wxArray
// // no constructor since this class doesn't exist
// void Add(T &item, size_t copies = 1 );
// void Alloc(size_t count );
// void Clear( );
// void Empty( );
// int GetCount() const;
// void Insert(T &item, size_t n, size_t copies = 1 );
// bool IsEmpty() const;
// void RemoveAt(size_t index, size_t count = 1 );
// void Shrink( );
//};
// ---------------------------------------------------------------------------
// wxArrayInt
//
// NOTE: Any function that takes a "const wxArrayInt& arr" or "wxArrayInt arr"
// can take a Lua table of integers with numeric indexes
#if wxLUA_USE_wxArrayInt
#include "wx/dynarray.h"
class %delete wxArrayInt
{

> wxArrayInt( );
> wxArrayInt(const wxArrayInt& array );
> // %override [Lua table] wxArrayInt::ToLuaTable() const;
> // returns a table array of the integers
> int ToLuaTable() const;
> void Add( int num );
> void Alloc(size_t count );
> void Clear( );
> void Empty( );
> int GetCount() const;
> bool IsEmpty() const;
> int Index(int n, bool searchFromEnd = false );
> void Insert( int num, int n, int copies = 1 );
> int Item( int n );
> void Remove(int n );
> void RemoveAt(size_t index );
> void Shrink( );
> int operator[](size_t nIndex );

};
#endif //wxLUA_USE_wxArrayInt
// ---------------------------------------------------------------------------
// wxArrayString
//
// NOTE: Any function that takes a "const wxArrayString& arr" or "wxArrayString arr"
// can take a Lua table of strings with numeric indexes
#if wxLUA_USE_wxArrayString
#include "wx/arrstr.h"
class %delete wxArrayString
{

> wxArrayString( );
> wxArrayString(const wxArrayString& array );
> // %override [Lua table] wxArrayString::ToLuaTable() const;
> // returns a table array of the strings
> int ToLuaTable() const;
> size_t Add(const wxString& str, size_t copies = 1 );
> void Alloc(size_t nCount );
> void Clear( );
> void Empty( );
> int GetCount() const;
> int Index(const wxString &sz, bool bCase = true, bool bFromEnd = false );
> void Insert(const wxString& str, int nIndex, size_t copies = 1 );
> bool IsEmpty( );
> wxString Item(size_t nIndex) const;
> wxString Last( );
> void Remove(const wxString &sz );
> void RemoveAt(size_t nIndex, size_t count = 1 );
> void Shrink( );
> void Sort(bool reverseOrder = false );
> wxString& operator[](size_t nIndex );

};
// ---------------------------------------------------------------------------
// wxSortedArrayString
//
// NOTE: Any function that takes a "const wxSortedArrayString& arr" or "wxSortedArrayString arr"
// can take a Lua table of strings with numeric indexes
//
// Note: We cheat by saying that it's derived from a wxArrayString to not
// have to duplicate it's methods. The binder doesn't know any better.
class %delete wxSortedArrayString : public wxArrayString
{

> wxSortedArrayString( );
> wxSortedArrayString(const wxArrayString& src); // have to have this constructor since they're not actually derived
> wxSortedArrayString(const wxSortedArrayString& src );

};
#endif //wxLUA_USE_wxArrayString
// ---------------------------------------------------------------------------
// wxStringList - is deprecated in wxWidgets since 2.2
//#if wxLUA_USE_wxStringList
//%include "wx/list.h"
//class wxStringList : public wxList
//{
// wxStringList( );
// wxNode *Add(const wxString& s );
// void Clear( );
// void Delete(const wxString& s );
// bool Member(const wxString& s );
// void Sort( );
//};
//#endif wxLUA_USE_wxStringList
// ---------------------------------------------------------------------------
// wxHashTable - Lua tables are hashtables
//#if wxLUA_USE_wxHashTable
//%include "wx/hash.h"
//#if %wxchkver_2_6
//class wxHashTable::Node
//{
//};
//#endif
//class wxHashTable : public wxObject
//{
// !%wxchkver_2_6 wxHashTable(unsigned int key_type, int size = 1000 );
// %wxchkver_2_6 wxHashTable(wxKeyType key_type, int size = 1000 );
// void BeginFind( );
// void Clear( );
// wxObject * Delete(long key );
// void DeleteContents(bool flag );
// wxObject * Get(long key );
// wxObject * Get(const wxString &key );
// long MakeKey(const wxString& string );
// !%wxchkver_2_6 wxNode * Next( );
// %wxchkver_2_6 wxHashTable::Node * Next( );
// void Put(long key, wxObject *object );
// void Put(const wxString& key, wxObject *object );
// int GetCount() const;
//};
//#endif wxLUA_USE_wxHashTable
// ---------------------------------------------------------------------------
// wxLongLong
#if wxUSE_LONGLONG
#include "wx/longlong.h"
class %delete wxLongLong
{

> wxLongLong(long hi = 0, unsigned long lo = 0 );
> wxLongLong Abs() const;
> wxLongLong& Assign(double d );
> long GetHi() const;
> unsigned long GetLo() const;
> double ToDouble() const;
> long ToLong() const;
> wxString ToString() const;
> //wxLongLong operator+(const wxLongLong& ll) const;
> //wxLongLong& operator+(const wxLongLong& ll );
> //wxLongLong& operator++( );
> //wxLongLong operator-() const;
> //wxLongLong operator-(const wxLongLong& ll) const;

};
// ---------------------------------------------------------------------------
// wxULongLong
class %delete wxULongLong
{

> wxULongLong(unsigned long hi = 0, unsigned long lo = 0 );
> unsigned long GetHi() const;
> unsigned long GetLo() const;
> long ToULong() const;
> wxString ToString() const;

};
#endif wxUSE_LONGLONG

## wxwidgets/wxbase_datetime.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxDateTime and other time related classes and functions
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#include "wx/utils.h"
#include "wx/timer.h"
wxString wxNow( );
long wxGetLocalTime( );
long wxGetUTCTime( );
wxLongLong wxGetLocalTimeMillis( );
%wxcompat_2_6 void wxStartTimer(); // deprecated in 2.8 use wxStopWatch
%wxcompat_2_6 long wxGetElapsedTime(bool resetTimer = true); // deprecated in 2.8 use wxStopWatch
void wxSleep(int secs );
%wxchkver_2_6 void wxMilliSleep(unsigned long milliseconds );
%wxchkver_2_6 void wxMicroSleep(unsigned long microseconds );
!%wxchkver_2_6 void wxUsleep(unsigned long milliseconds );
// ---------------------------------------------------------------------------
// wxDateTime
#if wxLUA_USE_wxDateTime && wxUSE_DATETIME
#include "wx/datetime.h"
enum wxDateTime::TZ
{

> Local,
> GMT_12,
> GMT_11,
> GMT_10,
> GMT_9,
> GMT_8,
> GMT_7,
> GMT_6,
> GMT_5,
> GMT_4,
> GMT_3,
> GMT_2,
> GMT_1,
> GMT0,
> GMT1,
> GMT2,
> GMT3,
> GMT4,
> GMT5,
> GMT6,
> GMT7,
> GMT8,
> GMT9,
> GMT10,
> GMT11,
> GMT12,
> %wxchkver_2_8 GMT13,
> WET,
> WEST,
> CET,
> CEST,
> EET,
> EEST,
> MSK,
> MSD,
> AST,
> ADT,
> EST,
> EDT,
> CST,
> CDT,
> MST,
> MDT,
> PST,
> PDT,
> HST,
> AKST,
> AKDT,
> A_WST,
> A_CST,
> A_EST,
> A_ESST,
> %wxchkver_2_8 NZST,
> %wxchkver_2_8 NZDT,
> UTC

};
enum wxDateTime::Calendar
{

> Gregorian,
> Julian

};
enum wxDateTime::Country
{

> Country_Unknown,
> Country_Default,
> Country_WesternEurope_Start,
> Country_EEC,
> France,
> Germany,
> UK,
> Country_WesternEurope_End,
> Russia,
> USA

};
enum wxDateTime::Month
{

> Jan,
> Feb,
> Mar,
> Apr,
> May,
> Jun,
> Jul,
> Aug,
> Sep,
> Oct,
> Nov,
> Dec,
> Inv_Month

};
enum wxDateTime::WeekDay
{

> Sun,
> Mon,
> Tue,
> Wed,
> Thu,
> Fri,
> Sat,
> Inv_WeekDay

};
enum wxDateTime::Year
{

> Inv_Year

};
enum wxDateTime::NameFlags
{

> Name_Full,
> Name_Abbr

};
enum wxDateTime::WeekFlags
{

> Default_First,
> Monday_First,
> Sunday_First

};
class %delete wxDateTime::TimeZone
{

> wxDateTime::TimeZone(wxDateTime::TZ tz );
> static wxDateTime::TimeZone Make(long offset );
> long GetOffset() const;

};
typedef unsigned short wxDateTime::wxDateTime_t
class %delete wxDateTime
{

> #define_object wxDefaultDateTime
> static void SetCountry(wxDateTime::Country country );
> static wxDateTime::Country GetCountry( );
> static bool IsWestEuropeanCountry(wxDateTime::Country country = wxDateTime::Country_Default );
> static int GetCurrentYear(wxDateTime::Calendar cal = wxDateTime::Gregorian );
> static int ConvertYearToBC(int year );
> static wxDateTime::Month GetCurrentMonth(wxDateTime::Calendar cal = wxDateTime::Gregorian );
> static bool IsLeapYear(int year = wxDateTime::Inv_Year, wxDateTime::Calendar cal = wxDateTime::Gregorian );
> static int GetCentury(int year );
> static wxDateTime::wxDateTime_t GetNumberOfDays(int year, wxDateTime::Calendar cal = wxDateTime::Gregorian );
> static wxDateTime::wxDateTime_t GetNumberOfDays(wxDateTime::Month month, int year = wxDateTime::Inv_Year, wxDateTime::Calendar cal = wxDateTime::Gregorian );
> static wxString GetMonthName(wxDateTime::Month month, wxDateTime::NameFlags flags = wxDateTime::Name_Full );
> static wxString GetWeekDayName(wxDateTime::WeekDay weekday, wxDateTime::NameFlags flags = wxDateTime::Name_Full );
> //static void GetAmPmStrings(wxString *am, wxString *pm );
> static bool IsDSTApplicable(int year = wxDateTime::Inv_Year, wxDateTime::Country country = wxDateTime::Country_Default );
> static wxDateTime GetBeginDST(int year = wxDateTime::Inv_Year, wxDateTime::Country country = wxDateTime::Country_Default );
> static wxDateTime GetEndDST(int year = wxDateTime::Inv_Year, wxDateTime::Country country = wxDateTime::Country_Default );
> static wxDateTime Now( );
> static wxDateTime UNow( );
> static wxDateTime Today( );
> wxDateTime( );
> wxDateTime(const wxDateTime& dateTime );
> wxDateTime(time_t dateTime); // use with Lua's os.time() on MSW, Linux, others?
> %rename wxDateTimeFromJDN wxDateTime(double dateTime );
> %rename wxDateTimeFromHMS wxDateTime(int hour, int minute, int second, int millisec );
> %rename wxDateTimeFromDMY wxDateTime(int day, wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year, int hour = 0, int minute = 0, int second = 0, int millisec = 0 );
> wxDateTime& SetToCurrent( );
> wxDateTime& Set(time_t time); // use with Lua's os.time() on MSW, Linux, others?
> %rename SetToJDN wxDateTime& Set(double dateTime );
> %rename SetToHMS wxDateTime& Set(int hour, int minute, int second, int millisec );
> %rename SetToDMY wxDateTime& Set(int day, wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year, int hour = 0, int minute = 0, int second = 0, int millisec = 0 );
> wxDateTime& ResetTime( );
> wxDateTime GetDateOnly() const;
> wxDateTime& SetYear(int year );
> wxDateTime& SetMonth(wxDateTime::Month month );
> wxDateTime& SetDay(int day );
> wxDateTime& SetHour(int hour );
> wxDateTime& SetMinute(int minute );
> wxDateTime& SetSecond(int second );
> wxDateTime& SetMillisecond(int millisecond );
> bool IsWorkDay(wxDateTime::Country country = wxDateTime::Country_Default) const;
> bool IsEqualTo(const wxDateTime& datetime) const;
> bool IsEarlierThan(const wxDateTime& datetime) const;
> bool IsLaterThan(const wxDateTime& datetime) const;
> bool IsStrictlyBetween(const wxDateTime& t1, const wxDateTime& t2) const;
> bool IsBetween(const wxDateTime& t1, const wxDateTime& t2) const;
> bool IsSameDate(const wxDateTime& dt) const;
> bool IsSameTime(const wxDateTime& dt) const;
> bool IsEqualUpTo(const wxDateTime& dt, const wxTimeSpan& ts) const;
> bool IsValid( );
> long GetTicks( );
> wxDateTime& SetToWeekDayInSameWeek(wxDateTime::WeekDay weekday );
> wxDateTime GetWeekDayInSameWeek(wxDateTime::WeekDay weekday) const;
> wxDateTime& SetToNextWeekDay(wxDateTime::WeekDay weekday );
> wxDateTime GetNextWeekDay(wxDateTime::WeekDay weekday) const;
> wxDateTime& SetToPrevWeekDay(wxDateTime::WeekDay weekday );
> wxDateTime GetPrevWeekDay(wxDateTime::WeekDay weekday) const;
> bool SetToWeekDay(wxDateTime::WeekDay weekday, int n = 1, wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year );
> wxDateTime GetWeekDay(wxDateTime::WeekDay weekday, int n = 1, wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year) const;
> bool SetToLastWeekDay(wxDateTime::WeekDay weekday, wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year );
> wxDateTime GetLastWeekDay(wxDateTime::WeekDay weekday, wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year );
> !%wxchkver_2_6 bool SetToTheWeek(wxDateTime::wxDateTime_t numWeek, wxDateTime::WeekDay weekday = wxDateTime::Mon );
> !%wxchkver_2_6 wxDateTime GetWeek(wxDateTime::wxDateTime_t numWeek, wxDateTime::WeekDay weekday = wxDateTime::Mon) const;
> %wxchkver_2_6 static wxDateTime SetToWeekOfYear(int year, wxDateTime::wxDateTime_t numWeek, wxDateTime::WeekDay weekday = wxDateTime::Mon );
> wxDateTime& SetToLastMonthDay(wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year );
> wxDateTime GetLastMonthDay(wxDateTime::Month month = wxDateTime::Inv_Month, int year = wxDateTime::Inv_Year) const;
> wxDateTime& SetToYearDay(wxDateTime::wxDateTime_t yday );
> wxDateTime GetYearDay(wxDateTime::wxDateTime_t yday) const;
> double GetJulianDayNumber() const;
> double GetJDN() const;
> double GetModifiedJulianDayNumber() const;
> double GetMJD() const;
> double GetRataDie() const;
> wxDateTime ToTimezone(const wxDateTime::TimeZone& tz, bool noDST = false) const;
> wxDateTime& MakeTimezone(const wxDateTime::TimeZone& tz, bool noDST = false );
> wxDateTime FromTimezone(const wxDateTime::TimeZone& tz, bool noDST = false) const;
> wxDateTime& MakeFromTimezone(const wxDateTime::TimeZone& tz, bool noDST = false );
> wxDateTime ToUTC(bool noDST = false) const;
> wxDateTime& MakeUTC(bool noDST = false );
> wxDateTime ToGMT(bool noDST = false) const;
> wxDateTime& MakeGMT(bool noDST = false );
> wxDateTime FromUTC(bool noDST = false) const;
> wxDateTime& MakeFromUTC(bool noDST = false );
> int IsDST(wxDateTime::Country country = wxDateTime::Country_Default) const;
> bool IsValid() const;
> //Tm GetTm(const wxDateTime::TimeZone& tz = wxDateTime::Local) const;
> time_t GetTicks() const;
> int GetCentury(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> int GetYear(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::Month GetMonth(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetDay(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::WeekDay GetWeekDay(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetHour(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetMinute(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetSecond(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetMillisecond(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetDayOfYear(const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetWeekOfYear(wxDateTime::WeekFlags flags = wxDateTime::Monday_First, const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> wxDateTime::wxDateTime_t GetWeekOfMonth(wxDateTime::WeekFlags flags = wxDateTime::Monday_First, const wxDateTime::TimeZone& tz = wxLua_wxDateTime_TimeZone_Local) const;
> bool IsWorkDay(wxDateTime::Country country = wxDateTime::Country_Default) const;
> //bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const;
> wxDateTime& SetFromDOS(unsigned long ddt);
> unsigned long GetAsDOS() const;
> bool IsEqualTo(const wxDateTime& datetime) const;
> bool IsEarlierThan(const wxDateTime& datetime) const;
> bool IsLaterThan(const wxDateTime& datetime) const;
> bool IsStrictlyBetween(const wxDateTime& t1, const wxDateTime& t2) const;
> bool IsBetween(const wxDateTime& t1, const wxDateTime& t2) const;
> bool IsSameDate(const wxDateTime& dt) const;
> bool IsSameTime(const wxDateTime& dt) const;
> bool IsEqualUpTo(const wxDateTime& dt, const wxTimeSpan& ts) const;
> bool operator<(const wxDateTime& dt) const;
> bool operator<=(const wxDateTime& dt) const;
> bool operator>(const wxDateTime& dt) const;
> bool operator>=(const wxDateTime& dt) const;
> bool operator==(const wxDateTime& dt) const;
> bool operator!=(const wxDateTime& dt) const;
> wxDateTime& Add(const wxTimeSpan& diff );
> wxDateTime& Add(const wxDateSpan& diff );
> wxDateTime& Subtract(const wxTimeSpan& diff );
> wxDateTime& Subtract(const wxDateSpan& diff );
> // ALL of the ParseXXX() functions in wx29 that take a 'wxString::const_iterator *end'
> // return the remainder of the input string after the error occurred if possible or
> // the whole string. Only a bool value of true is returned on success.
> // %override [bool, lua String remainder on error] ParseRfc822Date(const wxString& date );
> // C++ Func: bool ParseRfc822Date(const wxString& date, wxString::const_iterator *end );
> %wxchkver_2_9 bool ParseRfc822Date(const wxString& date );
> // %override [bool, lua String remainder on error] ParseFormat(const wxString& date, wxString format, const wxDateTime& dateDef );
> // C++ Func: bool ParseFormat(const wxString& date, wxString format, const wxDateTime& dateDef, wxString::const_iterator *end );
> %wxchkver_2_9 bool ParseFormat(const wxString& date, wxString format, const wxDateTime& dateDef );
> // %override [bool, lua String remainder on error] ParseFormat(const wxString& date, wxString format );
> // C++ Func: bool ParseFormat(const wxString& date, wxString format, wxString::const_iterator *end );
> %wxchkver_2_9 bool ParseFormat(const wxString& date, wxString format );
> // %override [bool, lua String remainder on error] ParseFormat(const wxString& date );
> // C++ Func: bool ParseFormat(const wxString& date, wxString::const_iterator *end );
> %wxchkver_2_9 bool ParseFormat(const wxString& date );
> // %override [bool, lua String remainder on error] ParseDateTime(const wxString& date );
> // C++ Func: bool ParseDateTime(const wxString& date, wxString::const_iterator *end );
> %wxchkver_2_9 bool ParseDateTime(const wxString& datetime );
> // %override [bool, lua String remainder on error] ParseDate(const wxString& date );
> // C++ Func: bool ParseDate(const wxString& date, wxString::const_iterator *end );
> %wxchkver_2_9 bool ParseDate(const wxString& date );
> // %override [bool, lua String remainder on error] ParseTime(const wxString& date );
> // C++ Func: bool ParseTime(const wxString& date, wxString::const_iterator *end );
> %wxchkver_2_9 bool ParseTime(const wxString& time );
> !%wxchkver_2_9 wxString ParseRfc822Date(wxString date );
> !%wxchkver_2_9 wxString ParseFormat(wxString date, wxString format = "%c", const wxDateTime& dateDef = wxDefaultDateTime );
> !%wxchkver_2_9 wxString ParseDateTime(wxString datetime );
> !%wxchkver_2_9 wxString ParseDate(wxString date );
> !%wxchkver_2_9 wxString ParseTime(wxString time );
> wxString FormatDate() const;
> wxString FormatTime() const;
> wxString FormatISODate() const;
> wxString FormatISOTime() const;
> wxString Format(wxString format = "%c", wxDateTime::TZ tz = wxDateTime::Local) const;

};
// ---------------------------------------------------------------------------
// wxDateTimeArray
class %delete wxDateTimeArray
{

> wxDateTimeArray( );
> wxDateTimeArray(const wxDateTimeArray& array );
> void Add(const wxDateTime& dateTime, size_t copies = 1 );
> void Alloc(size_t nCount );
> void Clear( );
> void Empty( );
> int GetCount() const;
> void Insert(const wxDateTime& dt, int nIndex, size_t copies = 1 );
> bool IsEmpty( );
> wxDateTime Item(size_t nIndex) const;
> wxDateTime Last( );
> void RemoveAt(size_t nIndex, size_t count = 1 );
> void Shrink( );

};
#endif //wxLUA_USE_wxDateTime && wxUSE_DATETIME
// ---------------------------------------------------------------------------
// wxTimeSpan
#if wxLUA_USE_wxTimeSpan && wxUSE_DATETIME
#include "wx/datetime.h"
class %delete wxTimeSpan
{

> wxTimeSpan( );
> wxTimeSpan(long hours, long minutes = 0, long seconds = 0, long milliseconds = 0 );
> wxTimeSpan Abs( );
> wxTimeSpan Add(const wxTimeSpan& diff) const;
> static wxTimeSpan Days(long days );
> static wxTimeSpan Day( );
> wxString Format(wxString format = "%H:%M:%S") const;
> int GetDays() const;
> int GetHours() const;
> wxLongLong GetMilliseconds() const;
> int GetMinutes() const;
> wxLongLong GetSeconds() const;
> wxLongLong GetValue() const;
> int GetWeeks() const;
> static wxTimeSpan Hours(long hours );
> static wxTimeSpan Hour( );
> bool IsEqualTo(const wxTimeSpan& ts) const;
> bool IsLongerThan(const wxTimeSpan& ts) const;
> bool IsNegative() const;
> bool IsNull() const;
> bool IsPositive() const;
> bool IsShorterThan(const wxTimeSpan& ts) const;
> static wxTimeSpan Minutes(long min );
> static wxTimeSpan Minute( );
> wxTimeSpan Multiply(int n) const;
> wxTimeSpan Negate() const;
> wxTimeSpan& Neg( );
> static wxTimeSpan Seconds(long sec );
> static wxTimeSpan Second( );
> wxTimeSpan Subtract(const wxTimeSpan& diff) const;
> static wxTimeSpan Weeks(long weeks );
> static wxTimeSpan Week( );

};
#endif //wxLUA_USE_wxTimeSpan && wxUSE_DATETIME
// ---------------------------------------------------------------------------
// wxDateSpan
#if wxLUA_USE_wxDateSpan && wxUSE_DATETIME
#include "wx/datetime.h"
class %delete wxDateSpan
{

> wxDateSpan(int years = 0, int months = 0, int weeks = 0, int days = 0 );
> wxDateSpan Add(const wxDateSpan& other) const;
> static wxDateSpan Day( );
> static wxDateSpan Days(int days );
> int GetDays() const;
> int GetMonths() const;
> int GetTotalDays() const;
> int GetWeeks() const;
> int GetYears() const;
> static wxDateSpan Month( );
> static wxDateSpan Months(int mon );
> wxDateSpan Multiply(int factor) const;
> wxDateSpan Negate() const;
> wxDateSpan& Neg( );
> wxDateSpan& SetDays(int n );
> wxDateSpan& SetMonths(int n );
> wxDateSpan& SetWeeks(int n );
> wxDateSpan& SetYears(int n );
> wxDateSpan Subtract(const wxDateSpan& other) const;
> static wxDateSpan Week( );
> static wxDateSpan Weeks(int weeks );
> static wxDateSpan Year( );
> static wxDateSpan Years(int years );
> bool operator==(wxDateSpan& other) const;

};
#endif //wxLUA_USE_wxDateSpan && wxUSE_DATETIME
// ---------------------------------------------------------------------------
// wxDateTimeHolidayAuthority
#if wxLUA_USE_wxDateTimeHolidayAuthority && wxUSE_DATETIME
class wxDateTimeHolidayAuthority
{

> // no constructor since this class has pure virtual functions
> static bool IsHoliday(const wxDateTime& dt );
> static size_t GetHolidaysInRange(const wxDateTime& dtStart, const wxDateTime& dtEnd, wxDateTimeArray& holidays );
> static void ClearAllAuthorities( );
> static void AddAuthority(wxDateTimeHolidayAuthority *auth );

};
// ---------------------------------------------------------------------------
// wxDateTimeWorkDays
class %delete wxDateTimeWorkDays : public wxDateTimeHolidayAuthority
{

> wxDateTimeWorkDays( );

};
#endif //wxLUA_USE_wxDateTimeHolidayAuthority && wxUSE_DATETIME
// ---------------------------------------------------------------------------
// wxStopWatch
#if wxLUA_USE_wxStopWatch && wxUSE_STOPWATCH
#include "wx/stopwatch.h"
class %delete wxStopWatch
{

> wxStopWatch(); // ctor starts the stop watch
> void Start(long t0 = 0); // start the stop watch at the moment t0
> void Pause( );
> void Resume( );
> long Time() const;

};
#endif // wxLUA_USE_wxStopWatch && wxUSE_STOPWATCH
// ---------------------------------------------------------------------------
// wxLocale
#include "wx/intl.h"
#if wxUSE_INTL
enum wxLanguage
{

> // user's default/preffered language as got from OS:
> wxLANGUAGE_DEFAULT,
> // unknown language, if wxLocale::GetSystemLanguage fails:
> wxLANGUAGE_UNKNOWN,
> wxLANGUAGE_ABKHAZIAN,
> wxLANGUAGE_AFAR,
> wxLANGUAGE_AFRIKAANS,
> wxLANGUAGE_ALBANIAN,
> wxLANGUAGE_AMHARIC,
> wxLANGUAGE_ARABIC,
> wxLANGUAGE_ARABIC_ALGERIA,
> wxLANGUAGE_ARABIC_BAHRAIN,
> wxLANGUAGE_ARABIC_EGYPT,
> wxLANGUAGE_ARABIC_IRAQ,
> wxLANGUAGE_ARABIC_JORDAN,
> wxLANGUAGE_ARABIC_KUWAIT,
> wxLANGUAGE_ARABIC_LEBANON,
> wxLANGUAGE_ARABIC_LIBYA,
> wxLANGUAGE_ARABIC_MOROCCO,
> wxLANGUAGE_ARABIC_OMAN,
> wxLANGUAGE_ARABIC_QATAR,
> wxLANGUAGE_ARABIC_SAUDI_ARABIA,
> wxLANGUAGE_ARABIC_SUDAN,
> wxLANGUAGE_ARABIC_SYRIA,
> wxLANGUAGE_ARABIC_TUNISIA,
> wxLANGUAGE_ARABIC_UAE,
> wxLANGUAGE_ARABIC_YEMEN,
> wxLANGUAGE_ARMENIAN,
> wxLANGUAGE_ASSAMESE,
> wxLANGUAGE_AYMARA,
> wxLANGUAGE_AZERI,
> wxLANGUAGE_AZERI_CYRILLIC,
> wxLANGUAGE_AZERI_LATIN,
> wxLANGUAGE_BASHKIR,
> wxLANGUAGE_BASQUE,
> wxLANGUAGE_BELARUSIAN,
> wxLANGUAGE_BENGALI,
> wxLANGUAGE_BHUTANI,
> wxLANGUAGE_BIHARI,
> wxLANGUAGE_BISLAMA,
> wxLANGUAGE_BRETON,
> wxLANGUAGE_BULGARIAN,
> wxLANGUAGE_BURMESE,
> wxLANGUAGE_CAMBODIAN,
> wxLANGUAGE_CATALAN,
> wxLANGUAGE_CHINESE,
> wxLANGUAGE_CHINESE_SIMPLIFIED,
> wxLANGUAGE_CHINESE_TRADITIONAL,
> wxLANGUAGE_CHINESE_HONGKONG,
> wxLANGUAGE_CHINESE_MACAU,
> wxLANGUAGE_CHINESE_SINGAPORE,
> wxLANGUAGE_CHINESE_TAIWAN,
> wxLANGUAGE_CORSICAN,
> wxLANGUAGE_CROATIAN,
> wxLANGUAGE_CZECH,
> wxLANGUAGE_DANISH,
> wxLANGUAGE_DUTCH,
> wxLANGUAGE_DUTCH_BELGIAN,
> wxLANGUAGE_ENGLISH,
> wxLANGUAGE_ENGLISH_UK,
> wxLANGUAGE_ENGLISH_US,
> wxLANGUAGE_ENGLISH_AUSTRALIA,
> wxLANGUAGE_ENGLISH_BELIZE,
> wxLANGUAGE_ENGLISH_BOTSWANA,
> wxLANGUAGE_ENGLISH_CANADA,
> wxLANGUAGE_ENGLISH_CARIBBEAN,
> wxLANGUAGE_ENGLISH_DENMARK,
> wxLANGUAGE_ENGLISH_EIRE,
> wxLANGUAGE_ENGLISH_JAMAICA,
> wxLANGUAGE_ENGLISH_NEW_ZEALAND,
> wxLANGUAGE_ENGLISH_PHILIPPINES,
> wxLANGUAGE_ENGLISH_SOUTH_AFRICA,
> wxLANGUAGE_ENGLISH_TRINIDAD,
> wxLANGUAGE_ENGLISH_ZIMBABWE,
> wxLANGUAGE_ESPERANTO,
> wxLANGUAGE_ESTONIAN,
> wxLANGUAGE_FAEROESE,
> wxLANGUAGE_FARSI,
> wxLANGUAGE_FIJI,
> wxLANGUAGE_FINNISH,
> wxLANGUAGE_FRENCH,
> wxLANGUAGE_FRENCH_BELGIAN,
> wxLANGUAGE_FRENCH_CANADIAN,
> wxLANGUAGE_FRENCH_LUXEMBOURG,
> wxLANGUAGE_FRENCH_MONACO,
> wxLANGUAGE_FRENCH_SWISS,
> wxLANGUAGE_FRISIAN,
> wxLANGUAGE_GALICIAN,
> wxLANGUAGE_GEORGIAN,
> wxLANGUAGE_GERMAN,
> wxLANGUAGE_GERMAN_AUSTRIAN,
> wxLANGUAGE_GERMAN_BELGIUM,
> wxLANGUAGE_GERMAN_LIECHTENSTEIN,
> wxLANGUAGE_GERMAN_LUXEMBOURG,
> wxLANGUAGE_GERMAN_SWISS,
> wxLANGUAGE_GREEK,
> wxLANGUAGE_GREENLANDIC,
> wxLANGUAGE_GUARANI,
> wxLANGUAGE_GUJARATI,
> wxLANGUAGE_HAUSA,
> wxLANGUAGE_HEBREW,
> wxLANGUAGE_HINDI,
> wxLANGUAGE_HUNGARIAN,
> wxLANGUAGE_ICELANDIC,
> wxLANGUAGE_INDONESIAN,
> wxLANGUAGE_INTERLINGUA,
> wxLANGUAGE_INTERLINGUE,
> wxLANGUAGE_INUKTITUT,
> wxLANGUAGE_INUPIAK,
> wxLANGUAGE_IRISH,
> wxLANGUAGE_ITALIAN,
> wxLANGUAGE_ITALIAN_SWISS,
> wxLANGUAGE_JAPANESE,
> wxLANGUAGE_JAVANESE,
> wxLANGUAGE_KANNADA,
> wxLANGUAGE_KASHMIRI,
> wxLANGUAGE_KASHMIRI_INDIA,
> wxLANGUAGE_KAZAKH,
> wxLANGUAGE_KERNEWEK,
> wxLANGUAGE_KINYARWANDA,
> wxLANGUAGE_KIRGHIZ,
> wxLANGUAGE_KIRUNDI,
> wxLANGUAGE_KONKANI,
> wxLANGUAGE_KOREAN,
> wxLANGUAGE_KURDISH,
> wxLANGUAGE_LAOTHIAN,
> wxLANGUAGE_LATIN,
> wxLANGUAGE_LATVIAN,
> wxLANGUAGE_LINGALA,
> wxLANGUAGE_LITHUANIAN,
> wxLANGUAGE_MACEDONIAN,
> wxLANGUAGE_MALAGASY,
> wxLANGUAGE_MALAY,
> wxLANGUAGE_MALAYALAM,
> wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM,
> wxLANGUAGE_MALAY_MALAYSIA,
> wxLANGUAGE_MALTESE,
> wxLANGUAGE_MANIPURI,
> wxLANGUAGE_MAORI,
> wxLANGUAGE_MARATHI,
> wxLANGUAGE_MOLDAVIAN,
> wxLANGUAGE_MONGOLIAN,
> wxLANGUAGE_NAURU,
> wxLANGUAGE_NEPALI,
> wxLANGUAGE_NEPALI_INDIA,
> wxLANGUAGE_NORWEGIAN_BOKMAL,
> wxLANGUAGE_NORWEGIAN_NYNORSK,
> wxLANGUAGE_OCCITAN,
> wxLANGUAGE_ORIYA,
> wxLANGUAGE_OROMO,
> wxLANGUAGE_PASHTO,
> wxLANGUAGE_POLISH,
> wxLANGUAGE_PORTUGUESE,
> wxLANGUAGE_PORTUGUESE_BRAZILIAN,
> wxLANGUAGE_PUNJABI,
> wxLANGUAGE_QUECHUA,
> wxLANGUAGE_RHAETO_ROMANCE,
> wxLANGUAGE_ROMANIAN,
> wxLANGUAGE_RUSSIAN,
> wxLANGUAGE_RUSSIAN_UKRAINE,
> wxLANGUAGE_SAMOAN,
> wxLANGUAGE_SANGHO,
> wxLANGUAGE_SANSKRIT,
> wxLANGUAGE_SCOTS_GAELIC,
> wxLANGUAGE_SERBIAN,
> wxLANGUAGE_SERBIAN_CYRILLIC,
> wxLANGUAGE_SERBIAN_LATIN,
> wxLANGUAGE_SERBO_CROATIAN,
> wxLANGUAGE_SESOTHO,
> wxLANGUAGE_SETSWANA,
> wxLANGUAGE_SHONA,
> wxLANGUAGE_SINDHI,
> wxLANGUAGE_SINHALESE,
> wxLANGUAGE_SISWATI,
> wxLANGUAGE_SLOVAK,
> wxLANGUAGE_SLOVENIAN,
> wxLANGUAGE_SOMALI,
> wxLANGUAGE_SPANISH,
> wxLANGUAGE_SPANISH_ARGENTINA,
> wxLANGUAGE_SPANISH_BOLIVIA,
> wxLANGUAGE_SPANISH_CHILE,
> wxLANGUAGE_SPANISH_COLOMBIA,
> wxLANGUAGE_SPANISH_COSTA_RICA,
> wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC,
> wxLANGUAGE_SPANISH_ECUADOR,
> wxLANGUAGE_SPANISH_EL_SALVADOR,
> wxLANGUAGE_SPANISH_GUATEMALA,
> wxLANGUAGE_SPANISH_HONDURAS,
> wxLANGUAGE_SPANISH_MEXICAN,
> wxLANGUAGE_SPANISH_MODERN,
> wxLANGUAGE_SPANISH_NICARAGUA,
> wxLANGUAGE_SPANISH_PANAMA,
> wxLANGUAGE_SPANISH_PARAGUAY,
> wxLANGUAGE_SPANISH_PERU,
> wxLANGUAGE_SPANISH_PUERTO_RICO,
> wxLANGUAGE_SPANISH_URUGUAY,
> wxLANGUAGE_SPANISH_US,
> wxLANGUAGE_SPANISH_VENEZUELA,
> wxLANGUAGE_SUNDANESE,
> wxLANGUAGE_SWAHILI,
> wxLANGUAGE_SWEDISH,
> wxLANGUAGE_SWEDISH_FINLAND,
> wxLANGUAGE_TAGALOG,
> wxLANGUAGE_TAJIK,
> wxLANGUAGE_TAMIL,
> wxLANGUAGE_TATAR,
> wxLANGUAGE_TELUGU,
> wxLANGUAGE_THAI,
> wxLANGUAGE_TIBETAN,
> wxLANGUAGE_TIGRINYA,
> wxLANGUAGE_TONGA,
> wxLANGUAGE_TSONGA,
> wxLANGUAGE_TURKISH,
> wxLANGUAGE_TURKMEN,
> wxLANGUAGE_TWI,
> wxLANGUAGE_UIGHUR,
> wxLANGUAGE_UKRAINIAN,
> wxLANGUAGE_URDU,
> wxLANGUAGE_URDU_INDIA,
> wxLANGUAGE_URDU_PAKISTAN,
> wxLANGUAGE_UZBEK,
> wxLANGUAGE_UZBEK_CYRILLIC,
> wxLANGUAGE_UZBEK_LATIN,
> wxLANGUAGE_VIETNAMESE,
> wxLANGUAGE_VOLAPUK,
> wxLANGUAGE_WELSH,
> wxLANGUAGE_WOLOF,
> wxLANGUAGE_XHOSA,
> wxLANGUAGE_YIDDISH,
> wxLANGUAGE_YORUBA,
> wxLANGUAGE_ZHUANG,
> wxLANGUAGE_ZULU,
> // for custom, user-defined languages:
> wxLANGUAGE_USER_DEFINED

};
enum wxFontEncoding
{

> wxFONTENCODING_SYSTEM, // system default
> wxFONTENCODING_DEFAULT, // current default encoding
> // ISO8859 standard defines a number of single-byte charsets
> wxFONTENCODING_ISO8859_1, // West European (Latin1 );
> wxFONTENCODING_ISO8859_2, // Central and East European (Latin2 );
> wxFONTENCODING_ISO8859_3, // Esperanto (Latin3 );
> wxFONTENCODING_ISO8859_4, // Baltic (old) (Latin4 );
> wxFONTENCODING_ISO8859_5, // Cyrillic
> wxFONTENCODING_ISO8859_6, // Arabic
> wxFONTENCODING_ISO8859_7, // Greek
> wxFONTENCODING_ISO8859_8, // Hebrew
> wxFONTENCODING_ISO8859_9, // Turkish (Latin5 );
> wxFONTENCODING_ISO8859_10, // Variation of Latin4 (Latin6 );
> wxFONTENCODING_ISO8859_11, // Thai
> wxFONTENCODING_ISO8859_12, // doesn't exist currently, but put it
> // here anyhow to make all ISO8859
> // consecutive numbers
> wxFONTENCODING_ISO8859_13, // Baltic (Latin7 );
> wxFONTENCODING_ISO8859_14, // Latin8
> wxFONTENCODING_ISO8859_15, // Latin9 (a.k.a. Latin0, includes euro );
> wxFONTENCODING_ISO8859_MAX,
> // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html );
> wxFONTENCODING_KOI8, // KOI8 Russian
> wxFONTENCODING_KOI8_U, // KOI8 Ukrainian
> wxFONTENCODING_ALTERNATIVE, // same as MS-DOS CP866
> wxFONTENCODING_BULGARIAN, // used under Linux in Bulgaria
> // what would we do without Microsoft? They have their own encodings
> // for DOS
> wxFONTENCODING_CP437, // original MS-DOS codepage
> wxFONTENCODING_CP850, // CP437 merged with Latin1
> wxFONTENCODING_CP852, // CP437 merged with Latin2
> wxFONTENCODING_CP855, // another cyrillic encoding
> wxFONTENCODING_CP866, // and another one
> // and for Windows
> wxFONTENCODING_CP874, // WinThai
> wxFONTENCODING_CP932, // Japanese (shift-JIS );
> wxFONTENCODING_CP936, // Chinese simplified (GB );
> wxFONTENCODING_CP949, // Korean (Hangul charset );
> wxFONTENCODING_CP950, // Chinese (traditional - Big5 );
> wxFONTENCODING_CP1250, // WinLatin2
> wxFONTENCODING_CP1251, // WinCyrillic
> wxFONTENCODING_CP1252, // WinLatin1
> wxFONTENCODING_CP1253, // WinGreek (8859-7 );
> wxFONTENCODING_CP1254, // WinTurkish
> wxFONTENCODING_CP1255, // WinHebrew
> wxFONTENCODING_CP1256, // WinArabic
> wxFONTENCODING_CP1257, // WinBaltic (same as Latin 7 );
> wxFONTENCODING_CP12_MAX,
> wxFONTENCODING_UTF7, // UTF-7 Unicode encoding
> wxFONTENCODING_UTF8, // UTF-8 Unicode encoding
> wxFONTENCODING_EUC_JP, // Extended Unix Codepage for Japanese
> wxFONTENCODING_UTF16BE, // UTF-16 Big Endian Unicode encoding
> wxFONTENCODING_UTF16LE, // UTF-16 Little Endian Unicode encoding
> wxFONTENCODING_UTF32BE, // UTF-32 Big Endian Unicode encoding
> wxFONTENCODING_UTF32LE, // UTF-32 Little Endian Unicode encoding
> wxFONTENCODING_MACROMAN, // the standard mac encodings
> wxFONTENCODING_MACJAPANESE,
> wxFONTENCODING_MACCHINESETRAD,
> wxFONTENCODING_MACKOREAN,
> wxFONTENCODING_MACARABIC,
> wxFONTENCODING_MACHEBREW,
> wxFONTENCODING_MACGREEK,
> wxFONTENCODING_MACCYRILLIC,
> wxFONTENCODING_MACDEVANAGARI,
> wxFONTENCODING_MACGURMUKHI,
> wxFONTENCODING_MACGUJARATI,
> wxFONTENCODING_MACORIYA,
> wxFONTENCODING_MACBENGALI,
> wxFONTENCODING_MACTAMIL,
> wxFONTENCODING_MACTELUGU,
> wxFONTENCODING_MACKANNADA,
> wxFONTENCODING_MACMALAJALAM,
> wxFONTENCODING_MACSINHALESE,
> wxFONTENCODING_MACBURMESE,
> wxFONTENCODING_MACKHMER,
> wxFONTENCODING_MACTHAI,
> wxFONTENCODING_MACLAOTIAN,
> wxFONTENCODING_MACGEORGIAN,
> wxFONTENCODING_MACARMENIAN,
> wxFONTENCODING_MACCHINESESIMP,
> wxFONTENCODING_MACTIBETAN,
> wxFONTENCODING_MACMONGOLIAN,
> wxFONTENCODING_MACETHIOPIC,
> wxFONTENCODING_MACCENTRALEUR,
> wxFONTENCODING_MACVIATNAMESE,
> wxFONTENCODING_MACARABICEXT,
> wxFONTENCODING_MACSYMBOL,
> wxFONTENCODING_MACDINGBATS,
> wxFONTENCODING_MACTURKISH,
> wxFONTENCODING_MACCROATIAN,
> wxFONTENCODING_MACICELANDIC,
> wxFONTENCODING_MACROMANIAN,
> wxFONTENCODING_MACCELTIC,
> wxFONTENCODING_MACGAELIC,
> wxFONTENCODING_MACKEYBOARD,
> wxFONTENCODING_MAX, // highest enumerated encoding value
> wxFONTENCODING_MACMIN, //= wxFONTENCODING_MACROMAN ,
> wxFONTENCODING_MACMAX, //= wxFONTENCODING_MACKEYBOARD ,
> // aliases for endian-dependent UTF encodings
> wxFONTENCODING_UTF16, // native UTF-16
> wxFONTENCODING_UTF32, // native UTF-32
> // alias for the native Unicode encoding on this platform
> // (this is used by wxEncodingConverter and wxUTFFile only for now );
> wxFONTENCODING_UNICODE,
> // alternative names for Far Eastern encodings
> // Chinese
> wxFONTENCODING_GB2312, // Simplified Chinese
> wxFONTENCODING_BIG5, // Traditional Chinese
> // Japanese (see http://zsigri.tripod.com/fontboard/cjk/jis.html );
> wxFONTENCODING_SHIFT_JIS, // Shift JIS

};
enum wxLocaleCategory
{

> wxLOCALE_CAT_NUMBER, // (any) numbers
> wxLOCALE_CAT_DATE, // date/time
> wxLOCALE_CAT_MONEY, // monetary value
> wxLOCALE_CAT_MAX

};
enum wxLocaleInfo
{

> wxLOCALE_THOUSANDS_SEP, // the thounsands separator
> wxLOCALE_DECIMAL_POINT // the character used as decimal point

};
enum wxLocaleInitFlags
{

> wxLOCALE_LOAD_DEFAULT, // load wxwin.mo?
> wxLOCALE_CONV_ENCODING // convert encoding on the fly?

};
#if %wxchkver_2_8
enum wxLayoutDirection
{

> wxLayout_Default,
> wxLayout_LeftToRight,
> wxLayout_RightToLeft

};
#endif %wxchkver_2_8
struct %delete wxLanguageInfo
{

> wxLanguageInfo(); // you must set all the values by hand
> int Language; // wxLanguage id
> wxString CanonicalName; // Canonical name, e.g. fr_FR
> wxString Description; // human-readable name of the language
> %wxchkver_2_8 wxLayoutDirection LayoutDirection;

};
class %delete wxLocale
{

> // call Init() if you use this ctor
> wxLocale( );
> // the ctor has a side effect of changing current locale
> // name (for messages), dir prefix (for msg files), locale (for setlocale), preload wxstd.mo?, convert Win<->Unix if necessary?
> wxLocale(const wxString& szName, const wxString& szShort = "", const wxString& szLocale = "", bool bLoadDefault = true, bool bConvertEncoding = false );
> // wxLanguage id or custom language
> wxLocale(int language, int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING );
> // the same as a function (returns true on success );
> //bool Init(const wxChar *szName, const wxChar *szShort = (const wxChar *) NULL, const wxChar *szLocale = (const wxChar *) NULL, bool bLoadDefault = true, bool bConvertEncoding = false );
> bool Init(const wxString &szName, const wxString &szShort = "", const wxString &szLocale = "", bool bLoadDefault = true, bool bConvertEncoding = false );
> // same as second ctor (returns true on success );
> bool Init(int language = wxLANGUAGE_DEFAULT, int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING);
> // Try to get user's (or OS's) preferred language setting.
> // Return wxLANGUAGE_UNKNOWN if language-guessing algorithm failed
> static int GetSystemLanguage( );
> // get the encoding used by default for text on this system, returns
> // wxFONTENCODING_SYSTEM if it couldn't be determined
> static wxFontEncoding GetSystemEncoding();
> // get the string describing the system encoding, return empty string if
> // couldn't be determined
> static wxString GetSystemEncodingName();
> // get the values of the given locale-dependent datum: the current locale
> // is used, the US default value is returned if everything else fails
> static wxString GetInfo(wxLocaleInfo index, wxLocaleCategory cat);
> // return true if the locale was set successfully
> bool IsOk() const;
> // returns locale name
> wxString GetLocale() const;
> // return current locale wxLanguage value
> int GetLanguage() const;
> // return locale name to be passed to setlocale( );
> wxString GetSysName() const;
> // return 'canonical' name, i.e. in the form of xx[_YY], where xx is
> // language code according to ISO 639 and YY is country name
> // as specified by ISO 3166.
> wxString GetCanonicalName() const;
> // add a prefix to the catalog lookup path: the message catalog files will be
> // looked up under prefix/<lang>/LC_MESSAGES, prefix/LC_MESSAGES and prefix
> // (in this order).
> //
> // This only applies to subsequent invocations of AddCatalog()!
> static void AddCatalogLookupPathPrefix(const wxString& prefix);
> // add a catalog: it's searched for in standard places (current directory
> // first, system one after), but the you may prepend additional directories to
> // the search path with AddCatalogLookupPathPrefix().
> //
> // The loaded catalog will be used for message lookup by GetString().
> //
> // Returns 'true' if it was successfully loaded
> bool AddCatalog(const wxString& szDomain);
> bool AddCatalog(const wxString& szDomain, wxLanguage msgIdLanguage, const wxString& msgIdCharset);
> // check if the given locale is provided by OS and C run time
> %wxchkver_2_8 static bool IsAvailable(int lang);
> // check if the given catalog is loaded
> bool IsLoaded(const wxString& szDomain) const;
> // Retrieve the language info struct for the given language
> //
> // Returns NULL if no info found, pointer must *not* be deleted by caller
> static const wxLanguageInfo *GetLanguageInfo(int lang);
> // Returns language name in English or empty string if the language
> // is not in database
> static wxString GetLanguageName(int lang);
> // Find the language for the given locale string which may be either a
> // canonical ISO 2 letter language code ("xx"), a language code followed by
> // the country code ("xx_XX") or a Windows full language name ("Xxxxx..." );
> //
> // Returns NULL if no info found, pointer must *not* be deleted by caller
> static const wxLanguageInfo *FindLanguageInfo(const wxString& locale);
> // Add custom language to the list of known languages.
> // Notes: 1) wxLanguageInfo contains platform-specific data
> // 2) must be called before Init to have effect
> static void AddLanguage(const wxLanguageInfo& info);
> // retrieve the translation for a string in all loaded domains unless
> // the szDomain parameter is specified (and then only this domain is
> // searched );
> // n - additional parameter for PluralFormsParser
> //
> // return original string if translation is not available
> // (in this case an error message is generated the first time
> // a string is not found; use wxLogNull to suppress it );
> //
> // domains are searched in the last to first order, i.e. catalogs
> // added later override those added before.
> %wxchkver_2_9 virtual wxString GetString(const wxString& szOrigString, const wxString& szDomain = "") const;
> !%wxchkver_2_9 virtual wxString GetString(const wxString& szOrigString, const wxChar* szDomain = NULL) const;
> // plural form version of the same:
> %wxchkver_2_9 virtual wxString GetString(const wxString& szOrigString, const wxString& szOrigString2, size_t n, const wxString& szDomain = "") const;
> !%wxchkver_2_9 virtual wxString GetString(const wxString& szOrigString, const wxString& szOrigString2, size_t n, const wxChar* szDomain = NULL) const;
> // Returns the current short name for the locale
> const wxString& GetName() const;
> // return the contents of .po file header
> wxString GetHeaderValue( const wxString& szHeader, const wxString& szDomain = "" ) const;

};
wxLocale* wxGetLocale( );
%wxchkver_2_9 wxString wxGetTranslation(const wxString& sz, const wxString& domain = "" );
!%wxchkver_2_9 && %wxchkver_2_8 wxString wxGetTranslation(const wxString& sz, const wxChar* domain=NULL );
!%wxchkver_2_8 wxString wxGetTranslation(const wxString& sz );
%wxchkver_2_9 %rename wxGetTranslationPlural wxString wxGetTranslation(const wxString& sz1, const wxString& sz2, size_t n, const wxString& domain = "" );
!%wxchkver_2_9 && %wxchkver_2_8 %rename wxGetTranslationPlural wxString wxGetTranslation(const wxString& sz1, const wxString& sz2, size_t n, const wxChar* domain=NULL );
!%wxchkver_2_8 %rename wxGetTranslationPlural wxString wxGetTranslation(const wxString& sz1, const wxString& sz2, size_t n );
#endif //wxUSE_INTL

## wxwidgets/wxbase_file.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxFile, wxDir, wxFileName and file functions
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#include "wx/filefn.h"
#include "sys/stat.h"
// global functions from the wxWindow's functions docs
bool wxDirExists(const wxString& dirname );
bool wxFileExists(const wxString& filename );
// %override [new Lua string] wxDos2UnixFilename(Lua string );
// C++ Func: void wxDos2UnixFilename(wxChar *s );
!%wxchkver_2_9_0 wxString wxDos2UnixFilename(const wxString& s );
// %override wxDateTime wxFileModificationTime(const wxString& filename) (not overridden, just return wxDateTime );
// C++ Func: time_t wxFileModificationTime(const wxString& filename );
wxDateTime wxFileModificationTime(const wxString& filename );
//wxString wxFileNameFromPath(const wxString& path); // obsolete use wxFileName::SplitPath
wxString wxFindFirstFile(const wxString& spec, int flags = 0 );
wxString wxFindNextFile( );
// bool wxGetDiskSpace(const wxString& path, wxLongLong *total = NULL, wxLongLong *free = NULL );
//wxFileKind wxGetFileKind(FILE* fd );
wxString wxGetOSDirectory( );
bool wxIsAbsolutePath(const wxString& filename );
wxString wxPathOnly(const wxString& path );
// %override [new Lua string] wxUnix2DosFilename(Lua string );
// C++ Func: void wxUnix2DosFilename(wxChar *s );
!%wxchkver_2_9 wxString wxUnix2DosFilename(const wxString& s );
bool wxConcatFiles(const wxString& file1, const wxString& file2,const wxString& file3 );
bool wxCopyFile(const wxString& file1, const wxString& file2, bool overwrite = true );
wxString wxGetCwd( );
//char* wxGetTempFileName(const wxString& prefix); // obsolete use wxFileName::CreateTempFileName
bool wxIsWild(const wxString& pattern );
bool wxMatchWild(const wxString& pattern, const wxString& text, bool dot_special );
bool wxMkdir(const wxString& dir, int perm = 0777 );
//int wxParseCommonDialogsFilter(const wxString& wildCard, wxArrayString& descriptions, wxArrayString& filters );
%wxchkver_2_8 wxString wxRealPath(const wxString& path );
bool wxRemoveFile(const wxString& file );
!%wxchkver_2_8 bool wxRenameFile(const wxString& file1, const wxString& file2 );
%wxchkver_2_8 bool wxRenameFile(const wxString& file1, const wxString& file2, bool overwrite = true );
bool wxRmdir(const wxString& dir, int flags=0 );
bool wxSetWorkingDirectory(const wxString& dir );
%wxchkver_2_8 bool wxIsWritable(const wxString &path );
%wxchkver_2_8 bool wxIsReadable(const wxString &path );
%wxchkver_2_8 bool wxIsExecutable(const wxString &path );
// These two methods are for wxLua
// %override long wxFileSize(const wxString& fileName) - gets the filesize
long wxFileSize(const wxString& fileName );
// wxLua only has storage for wxChar* in bindings, wxFILE_SEP_XXX are #defined
// as wxChar wxT('.'), so we just redefine them to be wxT(".") or wxChar*
#define_wxstring wxFILE_SEP_EXT wxT("." );
#define_wxstring wxFILE_SEP_DSK wxT(":" );
#define_wxstring wxFILE_SEP_PATH_DOS wxT("\\" );
#define_wxstring wxFILE_SEP_PATH_UNIX wxT("/" );
#define_wxstring wxFILE_SEP_PATH_MAC wxT(":" );
#define_wxstring wxFILE_SEP_PATH_VMS wxT("."); // VMS also uses '[' and ']'
#define_wxstring wxFILE_SEP_PATH wxLua_FILE_SEP_PATH // hack to convert from wxChar wxT('') to wxChar* wxT("" );
#define_wxstring wxPATH_SEP_DOS // wxT(";" );
#define_wxstring wxPATH_SEP_UNIX // wxT(":" );
#define_wxstring wxPATH_SEP_MAC // wxT(";" );
#define_wxstring wxPATH_SEP // wxPATH_SEP_XXX
#define wxARE_FILENAMES_CASE_SENSITIVE // bool 1/0
//bool wxIsPathSeparator(wxChar c) FIXME
bool wxEndsWithPathSeparator(const wxString& pszFileName );
// ---------------------------------------------------------------------------
// wxStandardPaths
#if %wxchkver_2_8 && wxLUA_USE_wxStandardPaths
#include "wx/stdpaths.h"
enum wxStandardPaths::ResourceCat
{

> ResourceCat_None, // no special category
> ResourceCat_Messages, // message catalog resources
> ResourceCat_Max // end of enum marker

};
class wxStandardPaths // we ignore wxStandardPathsBase
{

> // No constructor - use static Get() function
> // return the global standard paths object
> // %override static wxStandardPaths& Get();
> // C++ Func: static wxStandardPathsBase& Get();
> // We pretend that there is no wxStandardPathsBase and just use the wxStandardPaths name
> static wxStandardPaths& Get();
> // These are only for the generic version, probably not ever needed
> //void SetInstallPrefix(const wxString& prefix );
> //wxString GetInstallPrefix() const;
> virtual wxString GetExecutablePath() const;
> virtual wxString GetConfigDir() const;
> virtual wxString GetUserConfigDir() const;
> virtual wxString GetDataDir() const;
> virtual wxString GetLocalDataDir() const;
> virtual wxString GetUserDataDir() const;
> virtual wxString GetUserLocalDataDir() const;
> virtual wxString GetPluginsDir() const;
> virtual wxString GetResourcesDir() const;
> virtual wxString GetLocalizedResourcesDir(const wxString& lang, wxStandardPaths::ResourceCat category = wxStandardPaths::ResourceCat_None) const;
> virtual wxString GetDocumentsDir() const;
> virtual wxString GetTempDir() const;

};
#endif // %wxchkver_2_8 && wxLUA_USE_wxStandardPaths
// ---------------------------------------------------------------------------
// wxPathList
#include "wx/filefn.h"
class %delete wxPathList : public wxArrayString
{

> wxPathList( );
> //wxPathList(const wxArrayString &arr );
> // Adds all paths in environment variable
> void AddEnvList(const wxString& envVariable );
> // Adds given path to this list
> !%wxchkver_2_8 void Add(const wxString& path );
> %wxchkver_2_8 bool Add(const wxString& path );
> %wxchkver_2_8 void Add(const wxArrayString& paths );
> // Find the first full path for which the file exists
> wxString FindValidPath(const wxString& filename) const;
> // Find the first full path for which the file exists; ensure it's an
> // absolute path that gets returned.
> wxString FindAbsoluteValidPath(const wxString& filename) const;
> // Given full path and filename, add path to list
> %not_overload !%wxchkver_2_8 void EnsureFileAccessible(const wxString& path );
> %not_overload %wxchkver_2_8 bool EnsureFileAccessible(const wxString& path );

};
// ---------------------------------------------------------------------------
// wxFileName
#if wxLUA_USE_wxFileName
#include "wx/filename.h"
#define wxPATH_GET_VOLUME
#define wxPATH_GET_SEPARATOR
#define wxPATH_MKDIR_FULL
#define wxFILE
#define wxDIR
enum wxPathFormat
{

> wxPATH_NATIVE,
> wxPATH_UNIX,
> wxPATH_MAC,
> wxPATH_DOS,
> wxPATH_VMS,
> wxPATH_BEOS,
> wxPATH_WIN,
> wxPATH_OS2,
> wxPATH_MAX

};
enum wxPathNormalize
{

> wxPATH_NORM_ENV_VARS,
> wxPATH_NORM_DOTS,
> wxPATH_NORM_TILDE,
> wxPATH_NORM_CASE,
> wxPATH_NORM_ABSOLUTE,
> wxPATH_NORM_LONG,
> wxPATH_NORM_SHORTCUT,
> wxPATH_NORM_ALL

};
class %delete wxFileName
{

> wxFileName( );
> wxFileName(const wxFileName& filename );
> wxFileName(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> wxFileName(const wxString& path, const wxString& name, wxPathFormat format = wxPATH_NATIVE );
> wxFileName(const wxString& volume, const wxString& path, const wxString& name, const wxString& ext, wxPathFormat format = wxPATH_NATIVE );
> void AppendDir(const wxString& dir );
> void Assign(const wxFileName& filepath );
> void Assign(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> void Assign(const wxString& volume, const wxString& path, const wxString& name, const wxString& ext, wxPathFormat format = wxPATH_NATIVE );
> void Assign(const wxString& path, const wxString& name, wxPathFormat format = wxPATH_NATIVE );
> void Assign(const wxString& path, const wxString& name, const wxString& ext, wxPathFormat format = wxPATH_NATIVE );
> void AssignCwd(const wxString& volume = "" );
> void AssignDir(const wxString& dir, wxPathFormat format = wxPATH_NATIVE );
> void AssignHomeDir( );
> !%wxchkver_2_8 void AssignTempFileName(const wxString& prefix, wxFile *fileTemp = NULL );
> %wxchkver_2_8&&(wxUSE_FILE||wxUSE_FFILE) void AssignTempFileName(const wxString& prefix );
> %wxchkver_2_8&&wxUSE_FILE void AssignTempFileName(const wxString& prefix, wxFile *fileTemp );
> //%wxchkver_2_8&&wxUSE_FFILE void AssignTempFileName(const wxString& prefix, wxFFile *fileTemp );
> void Clear( );
> void ClearExt( );
> // Use AssignTempFileName(...) equivalents
> //!%wxchkver_2_8 static wxString CreateTempFileName(const wxString& prefix, wxFile *fileTemp = NULL );
> //%wxchkver_2_8&&(wxUSE_FILE||wxUSE_FFILE) static wxString CreateTempFileName(const wxString& prefix );
> //%wxchkver_2_8&&wxUSE_FILE static wxString CreateTempFileName(const wxString& prefix, wxFile *fileTemp );
> //%wxchkver_2_8&&wxUSE_FFILE static wxString CreateTempFileName(const wxString& prefix, wxFFile *fileTemp);
> bool DirExists( );
> static bool DirExists(const wxString& dir );
> static wxFileName DirName(const wxString& dir );
> bool FileExists( );
> static bool FileExists(const wxString& file );
> static wxFileName FileName(const wxString& file );
> static wxString GetCwd(const wxString& volume = "" );
> int GetDirCount() const;
> // %override [Lua string table] wxFileName::GetDirs( );
> // C++ Func: const wxArrayString& GetDirs() const;
> const wxArrayString& GetDirs() const;
> wxString GetExt() const;
> static wxString GetForbiddenChars(wxPathFormat format = wxPATH_NATIVE );
> static wxPathFormat GetFormat(wxPathFormat format = wxPATH_NATIVE );
> wxString GetFullName() const;
> wxString GetFullPath(wxPathFormat format = wxPATH_NATIVE) const;
> static wxString GetHomeDir( );
> %wxchkver_2_8 wxString GetHumanReadableSize(const wxString &nullsize = "Not available", int precision = 1) const;
> //%wxchkver_2_8 wxString GetHumanReadableSize(const wxString &nullsize = wxGetTranslation(_T("Not available")), int precision = 1) const;
> //%wxchkver_2_8 static wxString GetHumanReadableSize(const wxULongLong &sz, const wxString &nullsize = wxGetTranslation(_T("Not available")), int precision = 1 );
> wxString GetLongPath() const;
> wxDateTime GetModificationTime() const;
> wxString GetName() const;
> wxString GetPath(int flags = 0, wxPathFormat format = wxPATH_NATIVE) const;
> static int GetPathSeparator(wxPathFormat format = wxPATH_NATIVE );
> static wxString GetPathSeparators(wxPathFormat format = wxPATH_NATIVE );
> static wxString GetPathTerminators(wxPathFormat format = wxPATH_NATIVE );
> wxString GetPathWithSep(wxPathFormat format = wxPATH_NATIVE ) const;
> wxString GetShortPath() const;
> #if %wxchkver_2_8
> wxULongLong GetSize() const;
> static wxULongLong GetSize(const wxString &file );
> #endif // %wxchkver_2_8
> // %override [bool, wxDateTime dtAccess, wxDateTime dtMod, wxDateTime dtCreate] wxFileName::GetTimes( );
> // C++ Func: bool GetTimes(wxDateTime* dtAccess, wxDateTime* dtMod, wxDateTime* dtCreate) const;
> bool GetTimes() const;
> wxString GetVolume() const;
> static wxString GetVolumeSeparator(wxPathFormat format = wxPATH_NATIVE );
> bool HasExt() const;
> bool HasName() const;
> bool HasVolume() const;
> void InsertDir(int before, const wxString& dir );
> bool IsAbsolute(wxPathFormat format = wxPATH_NATIVE );
> static bool IsCaseSensitive(wxPathFormat format = wxPATH_NATIVE );
> bool IsOk() const;
> static bool IsPathSeparator(int ch, wxPathFormat format = wxPATH_NATIVE );
> bool IsRelative(wxPathFormat format = wxPATH_NATIVE );
> bool IsDir() const;
> #if %wxchkver_2_8
> bool IsDirWritable() const;
> static bool IsDirWritable(const wxString &path );
> bool IsDirReadable() const;
> static bool IsDirReadable(const wxString &path );
> bool IsFileWritable() const;
> static bool IsFileWritable(const wxString &path );
> bool IsFileReadable() const;
> static bool IsFileReadable(const wxString &path );
> bool IsFileExecutable() const;
> static bool IsFileExecutable(const wxString &path );
> #endif // %wxchkver_2_8
> //static bool MacFindDefaultTypeAndCreator(const wxString& ext, wxUint32* type, wxUint32* creator );
> //bool MacSetDefaultTypeAndCreator( );
> bool MakeAbsolute(const wxString& cwd = "", wxPathFormat format = wxPATH_NATIVE );
> bool MakeRelativeTo(const wxString& pathBase = "", wxPathFormat format = wxPATH_NATIVE );
> bool Mkdir(int perm = 4095, int flags = 0 );
> static bool Mkdir(const wxString& dir, int perm = 4095, int flags = 0 );
> bool Normalize(int flags = wxPATH_NORM_ALL, const wxString& cwd = wxEmptyString, wxPathFormat format = wxPATH_NATIVE );
> void PrependDir(const wxString& dir );
> void RemoveDir(int pos );
> void RemoveLastDir( );
> bool Rmdir( );
> static bool Rmdir(const wxString& dir );
> bool SameAs(const wxFileName& filepath, wxPathFormat format = wxPATH_NATIVE) const;
> bool SetCwd( );
> static bool SetCwd(const wxString& cwd );
> void SetExt(const wxString& ext );
> void SetEmptyExt( );
> void SetFullName(const wxString& fullname );
> void SetName(const wxString& name );
> bool SetTimes(const wxDateTime* dtAccess, const wxDateTime* dtMod, const wxDateTime* dtCreate );
> void SetVolume(const wxString& volume );
> // %override [wxString path, wxString name, wxString ext] wxFileName::SplitPath(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> // C++ Func: static void SplitPath(const wxString& fullpath, wxString* path, wxString* name, wxString* ext, wxPathFormat format = wxPATH_NATIVE );
> static void SplitPath(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> // %override [wxString volume, wxString path, wxString name, wxString ext] wxFileName::SplitPathVolume(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> // C++ Func: static void SplitPath(const wxString& fullpath, wxString* volume, wxString* path, wxString* name, wxString* ext, wxPathFormat format = wxPATH_NATIVE );
> %rename SplitPathVolume static void SplitPath(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> // %override [wxString volume, wxString path] wxFileName::SplitVolume(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> // C++ Func: static void SplitVolume(const wxString& fullpath, wxString* volume, wxString* path, wxPathFormat format = wxPATH_NATIVE );
> static void SplitVolume(const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE );
> bool Touch( );
> wxFileName& operator=(const wxFileName& filename );
> bool operator==(const wxFileName& filename) const;

};
#endif //wxLUA_USE_wxFileName
// ---------------------------------------------------------------------------
// wxFile
#if wxLUA_USE_wxFile && wxUSE_FILE
#include "wx/file.h"
enum wxFile::OpenMode
{

> read,
> write,
> read_write,
> write_append,
> write_excl

};
enum wxFile::dummy
{

> fd_invalid, // = -1
> fd_stdin,
> fd_stdout,
> fd_stderr

};
enum wxSeekMode
{

> wxFromStart,
> wxFromCurrent,
> wxFromEnd,
> wxInvalidOffset

};
enum wxFileKind
{

> wxFILE_KIND_UNKNOWN,
> wxFILE_KIND_DISK,
> wxFILE_KIND_TERMINAL,
> wxFILE_KIND_PIPE

};
#define wxS_IRUSR
#define wxS_IWUSR
#define wxS_IXUSR
#define wxS_IRGRP
#define wxS_IWGRP
#define wxS_IXGRP
#define wxS_IROTH
#define wxS_IWOTH
#define wxS_IXOTH
#define wxS_DEFAULT
class %delete wxFile
{

> wxFile( );
> wxFile(const wxString& filename, wxFile::OpenMode mode = wxFile::read );
> static bool Access(const wxString& name, wxFile::OpenMode mode );
> void Attach(int fd );
> void Close( );
> bool Create(const wxString& filename, bool overwrite = false, int access = wxS_DEFAULT );
> void Detach( );
> int fd() const;
> bool Eof() const;
> static bool Exists(const wxString& name );
> bool Flush( );
> wxFileKind GetKind() const;
> bool IsOpened() const;
> wxFileOffset Length() const;
> bool Open(const wxString& filename, wxFile::OpenMode mode = wxFile::read );
> // %override [size_t count, Lua string] wxFile::Read(unsigned int count );
> // C++ Func: size_t Read(void* buffer, unsigned int count );
> size_t Read(unsigned int count );
> wxFileOffset Seek(wxFileOffset offset, wxSeekMode mode = wxFromStart );
> wxFileOffset SeekEnd(wxFileOffset offset = 0 );
> wxFileOffset Tell() const;
> // %override size_t wxFile::Write(Lua string, unsigned int count );
> // C++ Func: size_t Write(const void* buffer, unsigned int count );
> size_t Write(const wxString& buffer, unsigned int count );
> size_t Write(const wxString &str); //, const wxMBConv& conv = wxConvUTF8 );

};
// ---------------------------------------------------------------------------
// wxTempFile
#include "wx/file.h"
class %delete wxTempFile
{

> wxTempFile( );
> // associates the temp file with the file to be replaced and opens it
> wxTempFile(const wxString& strName );
> // open the temp file (strName is the name of file to be replaced );
> bool Open(const wxString& strName );
> // is the file opened?
> bool IsOpened() const;
> // get current file length
> wxFileOffset Length() const;
> // move ptr ofs bytes related to start/current offset/end of file
> wxFileOffset Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart );
> // get current offset
> wxFileOffset Tell() const;
> // I/O (both functions return true on success, false on failure );
> //bool Write(const void *p, size_t n );
> bool Write(const wxString& str); //, const wxMBConv& conv = wxConvUTF8 );
> // validate changes and delete the old file of name m_strName
> bool Commit( );
> // discard changes
> void Discard();

};
#endif //wxLUA_USE_wxFile && wxUSE_FILE
// ---------------------------------------------------------------------------
// wxDir
#if wxLUA_USE_wxDir
#include "wx/dir.h"
#define wxDIR_FILES
#define wxDIR_DIRS
#define wxDIR_HIDDEN
#define wxDIR_DOTDOT
%wxchkver_2_9_5 #define wxDIR_NO_FOLLOW
#define wxDIR_DEFAULT
#if %wxchkver_2_9_4
// these constants are possible return value of wxDirTraverser::OnDir()
enum wxDirTraverseResult
{

> wxDIR_IGNORE, // ignore this directory but continue with others
> wxDIR_STOP, // stop traversing
> wxDIR_CONTINUE // continue into this directory

};
#endif //%wxchkver_2_9_4
class %delete wxDir
{

> wxDir( );
> wxDir(const wxString& dir );
> static bool Exists(const wxString& dir );
> // %override [unsigned int, Lua string table] wxDir::GetAllFiles(const wxString& dirname, const wxString& filespec = "", int flags = wxDIR_DEFAULT );
> // C++ Func: static unsigned int GetAllFiles(const wxString& dirname, wxArrayString *files, const wxString& filespec = "", int flags = wxDIR_DEFAULT );
> static unsigned int GetAllFiles(const wxString& dirname, const wxString& filespec = "", int flags = wxDIR_DEFAULT );
> // %override [bool, string filename] wxDir::GetFirst(const wxString& filespec = "", int flags = wxDIR_DEFAULT );
> // C++ Func: bool GetFirst(wxString * filename, const wxString& filespec = "", int flags = wxDIR_DEFAULT) const;
> bool GetFirst(const wxString& filespec = "", int flags = wxDIR_DEFAULT) const;
> wxString GetName() const;
> // %override [bool, string filename] wxDir::GetNext( );
> // C++ Func: bool GetNext(wxString * filename) const;
> bool GetNext() const;
> bool HasFiles(const wxString& filespec = "" );
> bool HasSubDirs(const wxString& dirspec = "" );
> bool IsOpened() const;
> bool Open(const wxString& dir );
> #if %wxchkver_2_8
> static wxString FindFirst(const wxString& dirname, const wxString& filespec, int flags = wxDIR_DEFAULT );
> static wxULongLong GetTotalSize(const wxString &dir); //, wxArrayString *filesSkipped = NULL) FIXME override
> #endif // %wxchkver_2_8
> // We don't need wxDirTraverser, just use wxDir methods GetFirst, GetNext.
> //size_t Traverse(wxDirTraverser& sink, const wxString& filespec = wxEmptyString, int flags = wxDIR_DEFAULT );

};
#endif //wxLUA_USE_wxDir
// ---------------------------------------------------------------------------
// wxFileTypeInfo
#include "wx/mimetype.h"
class %delete wxFileTypeInfo
{

> // the ... parameters form a NULL terminated list of extensions
> //wxFileTypeInfo(const wxChar *mimeType, const wxChar *openCmd, const wxChar *printCmd, const wxChar *desc, ... );
> // the array elements correspond to the parameters of the ctor above in the same order
> wxFileTypeInfo(const wxArrayString& sArray );
> // invalid item - use this to terminate the array passed to wxMimeTypesManager::AddFallbacks
> wxFileTypeInfo( );
> bool IsValid() const;
> void SetIcon(const wxString& iconFile, int iconIndex = 0 );
> void SetShortDesc(const wxString& shortDesc );
> wxString GetMimeType() const;
> wxString GetOpenCommand() const;
> wxString GetPrintCommand() const;
> wxString GetShortDesc() const;
> wxString GetDescription() const;
> wxArrayString GetExtensions() const;
> size_t GetExtensionsCount() const;
> wxString GetIconFile() const;
> int GetIconIndex() const;

};
// ---------------------------------------------------------------------------
// wxIconLocation
#include "wx/iconloc.h"
class %delete wxIconLocation
{

> // ctor takes the name of the file where the icon is
> !%msw wxIconLocation(const wxString& filename = "" );
> %msw wxIconLocation(const wxString& file = "", int num = 0 );
> // returns true if this object is valid/initialized
> bool IsOk() const;
> // set/get the icon file name
> void SetFileName(const wxString& filename );
> const wxString& GetFileName() const;
> // set/get the icon index
> %msw void SetIndex(int num );
> %msw int GetIndex() const;

};
// ---------------------------------------------------------------------------
// wxFileType::MessageParameters
class %delete wxFileType::MessageParameters
{

> //wxFileType::MessageParameters( );
> wxFileType::MessageParameters(const wxString& filename, const wxString& mimetype = "" );
> // accessors (called by GetOpenCommand );
> wxString GetFileName() const;
> wxString GetMimeType() const;
> // override this function in derived class
> virtual wxString GetParamValue(const wxString& name) const;

};
// ---------------------------------------------------------------------------
// wxFileType
class %delete wxFileType
{

> wxFileType(const wxFileTypeInfo& ftInfo );
> // accessors: all of them return true if the corresponding information
> // could be retrieved/found, false otherwise (and in this case all [out] parameters are unchanged );
> // return the MIME type for this file type
> //bool GetMimeType(wxString *mimeType) const;
> bool GetMimeTypes(wxArrayString& mimeTypes) const;
> bool GetExtensions(wxArrayString& extensions);
> // get the icon corresponding to this file type and of the given size
> bool GetIcon(wxIconLocation *iconloc) const;
> //bool GetIcon(wxIconLocation *iconloc, const wxFileType::MessageParameters& params) const;
> // get a brief file type description ("*.txt" => "text document" );
> // %override [bool Lua string] wxFileType::GetDescription() const;
> // C++ Func: bool GetDescription(wxString *desc) const;
> bool GetDescription() const;
> // get the command to be used to open/print the given file.
> //bool GetOpenCommand(wxString *openCmd, const wxFileType::MessageParameters& params) const;
> // a simpler to use version of GetOpenCommand() -- it only takes the
> // filename and returns an empty string on failure
> wxString GetOpenCommand(const wxString& filename) const;
> // get the command to print the file of given type
> // %override [bool Lua string] wxFileType::GetPrintCommand(const wxFileType::MessageParameters& params) const;
> // C++ Func: bool GetPrintCommand(wxString *printCmd, const wxFileType::MessageParameters& params) const;
> bool GetPrintCommand(const wxFileType::MessageParameters& params) const;
> // return the number of commands defined for this file type, 0 if none
> size_t GetAllCommands(wxArrayString *verbs, wxArrayString *commands, const wxFileType::MessageParameters& params) const;
> // set an arbitrary command, ask confirmation if it already exists and overwriteprompt is true
> bool SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt = true );
> bool SetDefaultIcon(const wxString& cmd = "", int index = 0 );
> // remove the association for this filetype from the system MIME database:
> // notice that it will only work if the association is defined in the user
> // file/registry part, we will never modify the system-wide settings
> bool Unassociate();
> // expand a string in the format of GetOpenCommand (which may contain
> // '%s' and '%t' format specificators for the file name and mime type
> // and %{param} constructions).
> static wxString ExpandCommand(const wxString& command, const wxFileType::MessageParameters& params);

};
// ---------------------------------------------------------------------------
// wxMimeTypesManager
class wxMimeTypesManager
{

> #define_pointer wxTheMimeTypesManager
> // wxMimeTypesManager(); - Use pointer wxTheMimeTypesManager
> // check if the given MIME type is the same as the other one: the
> // second argument may contain wildcards ('*'), but not the first. If
> // the types are equal or if the mimeType matches wildcard the function
> // returns true, otherwise it returns false
> static bool IsOfType(const wxString& mimeType, const wxString& wildcard);
> // NB: the following 2 functions are for Unix only and don't do anything elsewhere
> // loads data from standard files according to the mailcap styles
> // specified: this is a bitwise OR of wxMailcapStyle values
> //
> // use the extraDir parameter if you want to look for files in another
> // directory
> void Initialize(int mailcapStyle = wxMAILCAP_ALL, const wxString& extraDir = "");
> // and this function clears all the data from the manager
> void ClearData();
> // Database lookup: all functions return a pointer to wxFileType object
> // whose methods may be used to query it for the information you're
> // interested in. If the return value is !NULL, caller is responsible for
> // deleting it.
> // get file type from file extension
> wxFileType *GetFileTypeFromExtension(const wxString& ext);
> // get file type from MIME type (in format <category>/<format> );
> wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
> !%wxchkver_2_9 bool ReadMailcap(const wxString& filename, bool fallback = false);
> // read in additional file in mime.types format
> !%wxchkver_2_9 bool ReadMimeTypes(const wxString& filename);
> // enumerate all known MIME types returns the number of retrieved file types
> size_t EnumAllFileTypes(wxArrayString& mimetypes);
> // The filetypes array should be terminated by either NULL entry or an
> // invalid wxFileTypeInfo (i.e. the one created with default ctor );
> //void AddFallbacks(const wxFileTypeInfo *filetypes);
> void AddFallback(const wxFileTypeInfo& ft );
> // create a new association using the fields of wxFileTypeInfo (at least
> // the MIME type and the extension should be set );
> // if the other fields are empty, the existing values should be left alone
> wxFileType *Associate(const wxFileTypeInfo& ftInfo );
> // undo Associate( );
> bool Unassociate(wxFileType *ft );

};
// ---------------------------------------------------------------------------
// wxStreamBase
#if wxUSE_STREAMS
#include "wx/stream.h"
#include "wx/txtstrm.h"
enum wxEOL
{

> wxEOL_NATIVE,
> wxEOL_UNIX,
> wxEOL_MAC,
> wxEOL_DOS

};
enum wxStreamError
{

> wxSTREAM_NO_ERROR,
> wxSTREAM_EOF,
> wxSTREAM_WRITE_ERROR,
> wxSTREAM_READ_ERROR

};
// ---------------------------------------------------------------------------
// wxStreamBase
class wxStreamBase
{

> // wxStreamBase() this is only a base class
> %wxchkver_2_6 wxFileOffset GetLength() const;
> wxStreamError GetLastError() const;
> size_t GetSize() const;
> bool IsOk() const;
> bool IsSeekable() const;
> void Reset( );

};
// ---------------------------------------------------------------------------
// wxInputStream
class wxInputStream : public wxStreamBase
{

> // wxInputStream() this is only a base class
> bool CanRead() const;
> char GetC( );
> bool Eof( );
> size_t LastRead() const;
> char Peek( );
> // %override [Lua string] wxInputStream::Read(size_t size );
> // C++ Func: wxInputStream& Read(void *buffer, size_t size );
> wxString Read(size_t size );
> wxInputStream& Read(wxOutputStream& stream_in );
> wxFileOffset SeekI(wxFileOffset pos, wxSeekMode mode = wxFromStart );
> wxFileOffset TellI() const;
> // %override size_t wxInputStream::Ungetch(Lua string, size_t size );
> // C++ Func: size_t Ungetch(const char* buffer, size_t size );
> %override_name wxLua_wxInputStream_UngetchString size_t Ungetch(const wxString& str, size_t size );
> bool Ungetch(char c );

};
// ---------------------------------------------------------------------------
// wxOutputStream
class wxOutputStream : public wxStreamBase
{

> // wxOutputStream() this is only a base class
> bool Close( );
> size_t LastWrite() const;
> void PutC(char c );
> wxFileOffset SeekO(wxFileOffset pos, wxSeekMode mode = wxFromStart );
> wxFileOffset TellO() const;
> // %override wxOutputStream& wxOutputStream::Write(Lua string, size_t size );
> // C++ Func: wxOutputStream& Write(const void *buffer, size_t size );
> wxOutputStream& Write(const wxString& buffer, size_t size );
> wxOutputStream& Write(wxInputStream& stream_in );

};
// ---------------------------------------------------------------------------
// wxFileInputStream
#include "wx/wfstream.h"
class %delete wxFileInputStream : public wxInputStream
{

> wxFileInputStream(const wxString& fileName );
> wxFileInputStream(wxFile& file );
> //wxFileInputStream(int fd );
> bool Ok() const;

};
// ---------------------------------------------------------------------------
// wxFileOutputStream
class %delete wxFileOutputStream : public wxOutputStream
{

> wxFileOutputStream(const wxString& fileName );
> wxFileOutputStream(wxFile& file );
> //wxFileOutputStream(int fd );
> bool Ok() const;

};
// ---------------------------------------------------------------------------
// wxMemoryInputStream
#include "wx/mstream.h"
class %delete wxMemoryInputStream : public wxInputStream
{

> wxMemoryInputStream(const char *data, size_t length );
> //wxMemoryInputStream(const wxMemoryOutputStream& stream );

};
// ---------------------------------------------------------------------------
// wxMemoryOutputStream
//%include "wx/mstream.h"
//class %delete wxMemoryInputStream : public wxInputStream
//{
// wxMemoryOutputStream(void *data, size_t length );
// wxMemoryInputStream(const wxMemoryOutputStream& stream );
//};
// ---------------------------------------------------------------------------
// wxDataInputStream
#include "wx/datstrm.h"
class %delete wxDataInputStream
{

> // wxDataInputStream(wxInputStream& s, const wxMBConv& conv = wxConvAuto());
> wxDataInputStream(wxInputStream& s );
> bool IsOk( );
> //#if wxHAS_INT64
> // wxUint64 Read64( );
> //#endif
> //#if wxUSE_LONGLONG
> // wxLongLong ReadLL( );
> //#endif
> wxUint32 Read32( );
> wxUint16 Read16( );
> wxUint8 Read8( );
> double ReadDouble( );
> wxString ReadString( );
> //#if wxHAS_INT64
> // void Read64(wxUint64 *buffer, size_t size );
> // void Read64(wxInt64 *buffer, size_t size );
> //#endif
> //#if defined(wxLongLong_t) && wxUSE_LONGLONG
> // void Read64(wxULongLong *buffer, size_t size );
> // void Read64(wxLongLong *buffer, size_t size );
> //#endif
> //#if wxUSE_LONGLONG
> // void ReadLL(wxULongLong *buffer, size_t size );
> // void ReadLL(wxLongLong *buffer, size_t size );
> //#endif
> //void Read32(wxUint32 *buffer, size_t size );
> //void Read16(wxUint16 *buffer, size_t size );
> //void Read8(wxUint8 *buffer, size_t size );
> //void ReadDouble(double *buffer, size_t size );
> void BigEndianOrdered(bool be_order );

};
// ---------------------------------------------------------------------------
// wxDataOutputStream
#include "wx/datstrm.h"
class %delete wxDataOutputStream
{

> // wxDataOutputStream(wxOutputStream& s, const wxMBConv& conv = wxConvAuto());
> wxDataOutputStream(wxOutputStream& s);
> bool IsOk( );
> //#if wxHAS_INT64
> // void Write64(wxUint64 i);
> // void Write64(wxInt64 i);
> //#endif
> //#if wxUSE_LONGLONG
> // void WriteLL(const wxLongLong &ll);
> // void WriteLL(const wxULongLong &ll);
> //#endif
> void Write32(wxUint32 i );
> void Write16(wxUint16 i );
> void Write8(wxUint8 i );
> void WriteDouble(double d );
> void WriteString(const wxString& string );
> //#if wxHAS_INT64
> // void Write64(const wxUint64 *buffer, size_t size);
> // void Write64(const wxInt64 *buffer, size_t size);
> //#endif
> //#if defined(wxLongLong_t) && wxUSE_LONGLONG
> // void Write64(const wxULongLong *buffer, size_t size);
> // void Write64(const wxLongLong *buffer, size_t size);
> //#endif
> //#if wxUSE_LONGLONG
> // void WriteLL(const wxULongLong *buffer, size_t size);
> // void WriteLL(const wxLongLong *buffer, size_t size);
> //#endif
> //void Write32(const wxUint32 *buffer, size_t size);
> //void Write16(const wxUint16 *buffer, size_t size);
> //void Write8(const wxUint8 *buffer, size_t size);
> //void WriteDouble(const double *buffer, size_t size);
> void BigEndianOrdered(bool be_order );

};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// wxFSFile
#if wxUSE_FILESYSTEM // already has wxUSE_STREAMS
#include "wx/filesys.h"
class %delete wxFSFile : public wxObject
{

> wxFSFile(%ungc wxInputStream *stream, const wxString& loc, const wxString& mimetype, const wxString& anchor, wxDateTime modif );
> // returns stream. This doesn't give away ownership of the stream object.
> wxInputStream *GetStream() const;
> // gives away the ownership of the current stream.
> %gc wxInputStream *DetachStream( );
> // deletes the current stream and takes ownership of another.
> void SetStream(%ungc wxInputStream *stream );
> // returns file's mime type
> wxString GetMimeType() const;
> // returns the original location (aka filename) of the file
> wxString GetLocation() const;
> wxString GetAnchor() const;
> wxDateTime GetModificationTime() const;

};
// ---------------------------------------------------------------------------
// wxFileSystemHandler
class %delete wxFileSystemHandler : public wxObject
{

> // wxFileSystemHandler(); // no constructor since it has abstract functions
> // returns true if this handler is able to open given location
> virtual bool CanOpen(const wxString& location); //= 0;
> // opens given file and returns pointer to input stream.
> // Returns NULL if opening failed.
> // The location is always absolute path.
> virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location); //= 0;
> // Finds first/next file that matches spec wildcard. flags can be wxDIR for restricting
> // the query to directories or wxFILE for files only or 0 for either.
> // Returns filename or empty string if no more matching file exists
> virtual wxString FindFirst(const wxString& spec, int flags = 0);
> virtual wxString FindNext();

};
// ---------------------------------------------------------------------------
// wxLocalFSHandler
class %delete wxLocalFSHandler : public wxFileSystemHandler
{

> wxLocalFSHandler( );
> // wxLocalFSHandler will prefix all filenames with 'root' before accessing
> // files on disk. This effectively makes 'root' the top-level directory
> // and prevents access to files outside this directory.
> // (This is similar to Unix command 'chroot'. );
> static void Chroot(const wxString& root );

};
// ---------------------------------------------------------------------------
// wxFileSystem
enum
{
wxFS_READ, // Open for reading
wxFS_SEEKABLE // Returned stream will be seekable
};
class %delete wxFileSystem : public wxObject
{

> wxFileSystem( );
> // sets the current location. Every call to OpenFile is
> // relative to this location.
> // NOTE !!
> // unless is_dir = true 'location' is *not* the directory but
> // file contained in this directory
> // (so ChangePathTo("dir/subdir/xh.htm") sets m_Path to "dir/subdir/" );
> void ChangePathTo(const wxString& location, bool is_dir = false);
> wxString GetPath() const;
> // opens given file and returns pointer to input stream.
> // Returns NULL if opening failed.
> // It first tries to open the file in relative scope
> // (based on ChangePathTo()'s value) and then as an absolute
> // path.
> %gc wxFSFile* OpenFile(const wxString& location, int flags = wxFS_READ);
> // Finds first/next file that matches spec wildcard. flags can be wxDIR for restricting
> // the query to directories or wxFILE for files only or 0 for either.
> // Returns filename or empty string if no more matching file exists
> wxString FindFirst(const wxString& spec, int flags = 0);
> wxString FindNext();
> // find a file in a list of directories, returns false if not found
> // %override [bool, Lua string full_path] bool FindFileInPath(const wxString& path, const wxString& file);
> // C++ Func: bool FindFileInPath(wxString *pStr, const wxChar *path, const wxChar *file);
> bool FindFileInPath(const wxString& path, const wxString& file);
> // Adds FS handler.
> // In fact, this class is only front-end to the FS handlers :- );
> static void AddHandler(%ungc wxFileSystemHandler *handler);
> // Removes FS handler
> static %gc wxFileSystemHandler* RemoveHandler(wxFileSystemHandler *handler);
> // Returns true if there is a handler which can open the given location.
> static bool HasHandlerForPath(const wxString& location);
> // remove all items from the m_Handlers list
> static void CleanUpHandlers();
> // Returns the native path for a file URL
> static wxFileName URLToFileName(const wxString& url);
> // Returns the file URL for a native path
> static wxString FileNameToURL(const wxFileName& filename);

};
// ---------------------------------------------------------------------------
// wxArchiveFSHandler
#include "wx/fs_arc.h"
class %delete wxArchiveFSHandler : public wxFileSystemHandler
{

> wxArchiveFSHandler( );

};
// ---------------------------------------------------------------------------
// wxZipFSHandler - is just a typedef to wxArchiveFSHandler
//%include "wx/fs_zip.h"
//#if wxUSE_FS_ZIP
// typedef wxArchiveFSHandler wxZipFSHandler;
//#endif
// ---------------------------------------------------------------------------
// wxFilterFSHandler
#include "wx/fs_filter.h"
class %delete wxFilterFSHandler : public wxFileSystemHandler
{

> wxFilterFSHandler( );

};
// ---------------------------------------------------------------------------
// wxInternetFSHandler
#if wxUSE_FS_INET && wxUSE_SOCKETS // already has wxUSE_STREAMS && wxUSE_FILESYSTEM
#include "wx/fs_inet.h"
class %delete wxInternetFSHandler : public wxFileSystemHandler
{

> wxInternetFSHandler( );

};
#endif //wxUSE_FS_INET && wxUSE_SOCKETS
// ---------------------------------------------------------------------------
// wxMemoryFSHandler - See wxcore_core.i for this since it requires wxImage & wxBitmap.
#endif // wxUSE_FILESYSTEM
#endif // wxUSE_STREAMS
// ---------------------------------------------------------------------------
// wxFileSystemWatcher classes
#if wxUSE_FSWATCHER && %wxchkver_2_9_4
#include "wx/fswatcher.h"
enum
{
wxFSW_EVENT_CREATE, // = 0x01,
wxFSW_EVENT_DELETE, // = 0x02,
wxFSW_EVENT_RENAME, // = 0x04,
wxFSW_EVENT_MODIFY, // = 0x08,
wxFSW_EVENT_ACCESS, // = 0x10,
wxFSW_EVENT_ATTRIB, // = 0x20, // Currently this is wxGTK-only
// error events
wxFSW_EVENT_WARNING, // = 0x40,
wxFSW_EVENT_ERROR, // = 0x80,
wxFSW_EVENT_ALL, // = wxFSW_EVENT_CREATE | wxFSW_EVENT_DELETE |
// wxFSW_EVENT_RENAME | wxFSW_EVENT_MODIFY |
// wxFSW_EVENT_ACCESS | wxFSW_EVENT_ATTRIB |
// wxFSW_EVENT_WARNING | wxFSW_EVENT_ERROR
#if defined(wxHAS_INOTIFY)
wxFSW_EVENT_UNMOUNT, // = 0x2000
#endif
};
// Type of the path watched, used only internally for now.
enum wxFSWPathType
{

> wxFSWPath_None, // Invalid value for an initialized watch.
> wxFSWPath_File, // Plain file.
> wxFSWPath_Dir, // Watch a directory and the files in it.
> wxFSWPath_Tree // Watch a directory and all its children recursively.

};
// Type of the warning for the events notifying about them.
enum wxFSWWarningType
{

> wxFSW_WARNING_NONE,
> wxFSW_WARNING_GENERAL,
> wxFSW_WARNING_OVERFLOW

};
// ---------------------------------------------------------------------------
// wxFileSystemWatcherEvent
class %delete wxFileSystemWatcherEvent: public wxEvent
{

> public:
> %wxEventType wxEVT_FSWATCHER // EVT_FSWATCHER(winid, func);
> wxFileSystemWatcherEvent(int changeType = 0, int watchid = wxID_ANY);
> wxFileSystemWatcherEvent(int changeType, wxFSWWarningType warningType, const wxString& errorMsg = "", int watchid = wxID_ANY);
> wxFileSystemWatcherEvent(int changeType, const wxFileName& path, const wxFileName& newPath, int watchid = wxID_ANY);
> const wxFileName& GetPath() const;
> void SetPath(const wxFileName& path);
> const wxFileName& GetNewPath() const;
> void SetNewPath(const wxFileName& path);
> int GetChangeType() const;
> //virtual wxEvent* Clone() const;
> //virtual wxEventCategory GetEventCategory() const;
> bool IsError() const;
> wxString GetErrorDescription() const;
> wxFSWWarningType GetWarningType() const;
> wxString ToString() const;

};
// ---------------------------------------------------------------------------
// wxFileSystemWatcher
class wxFileSystemWatcher : public wxEvtHandler
{

> public:
> wxFileSystemWatcher();
> virtual bool Add(const wxFileName& path, int events = wxFSW_EVENT_ALL);
> bool AddAny(const wxFileName& path, int events, wxFSWPathType type, const wxString& filespec = "");
> virtual bool AddTree(const wxFileName& path, int events = wxFSW_EVENT_ALL, const wxString& filespec = wxEmptyString);
> virtual bool Remove(const wxFileName& path);
> virtual bool RemoveTree(const wxFileName& path);
> virtual bool RemoveAll();
> int GetWatchedPathsCount() const;
> int GetWatchedPaths(wxArrayString* paths) const;
> wxEvtHandler* GetOwner() const;
> void SetOwner(wxEvtHandler* handler);

};
#endif // wxUSE_FSWATCHER && %wxchkver_2_9_4

## wxwidgets/wxcore_appframe.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxApp and wxFrame
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxApp
#if wxLUA_USE_wxApp
#include "wx/app.h"
// %override wxApp* wxGetApp( );
// C++ func: wxApp* wxGetApp() - use wxTheApp* since this requires IMPLEMENT_APP( );
wxApp* wxGetApp( );
class wxApp : public wxEvtHandler
{

> // wxApp() NO CONSTRUCTOR! the wxApp is created in C++, use wxGetApp( );
> // These two are pushed into Lua by C++ at startup as table arg = { argv }
> // int wxApp::argc
> // wxChar** wxApp::argv
> //!%wxchkver_2_6|%wxcompat_2_4 virtual wxLog* CreateLogTarget( );
> void Dispatch( );
> void ExitMainLoop( );
> // virtual int FilterEvent(wxEvent& event) too dangerous, use ConnectEvent
> wxString GetAppName() const;
> //!%wxchkver_2_6&%win bool GetAuto3D() const;
> wxString GetClassName() const;
> bool GetExitOnFrameDelete() const;
> // static wxAppConsole *GetInstance() FIXME
> wxWindow* GetTopWindow() const;
> bool GetUseBestVisual() const;
> wxString GetVendorName() const;
> bool IsActive() const;
> static bool IsMainLoopRunning( );
> // bool Initialized() obsolete in wxWidgets
> // %override int wxApp::MainLoop( );
> // C++ Func: int MainLoop( );
> // Only calls it if (!IsMainLoopRuinning() && !wxLuaState::sm_wxAppMainLoop_will_run), returns 0 if not called.
> int MainLoop( );
> // virtual int OnExit() nothing we can do here
> // virtual bool OnInit() nothing we can do here
> // virtual int OnRun() nothing we can do here
> bool Pending( );
> // !%wxchkver_2_6 bool SendIdleEvents( );
> %wxchkver_2_6 && !%wxchkver_2_9_2 bool SendIdleEvents(wxWindow* win, wxIdleEvent& event );
> void SetAppName(const wxString& name );
> //!%wxchkver_2_4&(%win|%mac) void SetAuto3D(const bool auto3D );
> void SetClassName(const wxString& name );
> void SetExitOnFrameDelete(bool flag );
> // static void SetInstance(wxAppConsole* app) nothing we can do here
> void SetTopWindow(wxWindow* window );
> void SetVendorName(const wxString& name );
> //virtual wxIcon GetStdIcon(int which) const;
> void SetUseBestVisual(bool flag );

};
#endif //wxLUA_USE_wxApp
// ---------------------------------------------------------------------------
// wxTopLevelWindow
#if wxLUA_USE_wxFrame|wxLUA_USE_wxDialog
#include "wx/toplevel.h"
enum
{
wxUSER_ATTENTION_INFO,
wxUSER_ATTENTION_ERROR
};
enum
{
wxFULLSCREEN_NOMENUBAR,
wxFULLSCREEN_NOTOOLBAR,
wxFULLSCREEN_NOSTATUSBAR,
wxFULLSCREEN_NOBORDER,
wxFULLSCREEN_NOCAPTION,
wxFULLSCREEN_ALL
};
class wxTopLevelWindow : public wxWindow
{

> // No constructors, virtual base class, use wxFrame or wxDialog
> bool CanSetTransparent( );
> bool EnableCloseButton(bool enable = true );
> %wxchkver_2_8 wxWindow* GetDefaultItem() const;
> wxIcon GetIcon() const;
> //const wxIconBundle& GetIcons() const;
> wxString GetTitle() const;
> %wxchkver_2_8 wxWindow* GetTmpDefaultItem() const;
> bool IsActive() const;
> bool IsAlwaysMaximized() const;
> void Iconize(bool iconize );
> bool IsFullScreen() const;
> bool IsIconized() const;
> bool IsMaximized() const;
> void Maximize(bool maximize );
> void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO );
> %wxchkver_2_8 wxWindow* SetDefaultItem(wxWindow *win );
> void SetIcon(const wxIcon& icon );
> void SetIcons(const wxIconBundle& icons );
> //void SetLeftMenu(int id = wxID_ANY, const wxString& label = wxEmptyString, wxMenu * subMenu = NULL); // for phones
> //void SetRightMenu(int id = wxID_ANY, const wxString& label = wxEmptyString, wxMenu * subMenu = NULL );
> void SetMaxSize(const wxSize& size );
> void SetMinSize(const wxSize& size );
> void SetSizeHints(int minW, int minH, int maxW=-1, int maxH=-1, int incW=-1, int incH=-1 );
> void SetSizeHints(const wxSize& minSize, const wxSize& maxSize=wxDefaultSize, const wxSize& incSize=wxDefaultSize );
> bool SetShape(const wxRegion& region );
> virtual void SetTitle(const wxString& title );
> virtual bool SetTransparent(int alpha );
> //virtual bool ShouldPreventAppExit() const; // must be overridden
> %wxchkver_2_8 wxWindow* SetTmpDefaultItem(wxWindow *win );
> bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL );

};
#endif //wxLUA_USE_wxFrame|wxLUA_USE_wxDialog
// ---------------------------------------------------------------------------
// wxFrame
#if wxLUA_USE_wxFrame
#include "wx/frame.h"
#define wxDEFAULT_FRAME_STYLE
#define wxICONIZE
#define wxCAPTION
#define wxMINIMIZE
#define wxMINIMIZE_BOX
#define wxMAXIMIZE
#define wxMAXIMIZE_BOX
%wxchkver_2_6 #define wxCLOSE_BOX
#define wxSTAY_ON_TOP
#define wxSYSTEM_MENU
//#define wxSIMPLE_BORDER see wxWindow defines
#define wxRESIZE_BORDER
#define wxFRAME_TOOL_WINDOW
#define wxFRAME_NO_TASKBAR
#define wxFRAME_FLOAT_ON_PARENT
#define wxFRAME_EX_CONTEXTHELP
%wxchkver_2_6 #define wxFRAME_SHAPED
%wxchkver_2_6 #define wxFRAME_EX_METAL
// #define wxTHICK_FRAME %wxcompat_2_6 use %wxchkver_2_6
class wxFrame : public wxTopLevelWindow
{

> wxFrame( );
> wxFrame(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxFrame" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxFrame" );
> // void Centre(int direction = wxBOTH) - see wxWindow
> virtual wxStatusBar* CreateStatusBar(int number = 1, long style = 0, wxWindowID id = wxID_ANY, const wxString& name = "wxStatusBar" );
> virtual wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL, wxWindowID id = wxID_ANY, const wxString& name = "wxToolBar" );
> wxPoint GetClientAreaOrigin() const;
> wxMenuBar* GetMenuBar() const;
> wxStatusBar* GetStatusBar() const;
> int GetStatusBarPane( );
> wxToolBar* GetToolBar() const;
> %wxchkver_2_4 void ProcessCommand(int id );
> //!%wxchkver_2_4 void Command(int id );
> void SendSizeEvent( );
> void SetMenuBar(wxMenuBar* menuBar );
> void SetStatusBar(wxStatusBar* statusBar );
> void SetStatusBarPane(int n );
> virtual void SetStatusText(const wxString& text, int number = 0 );
> // void wxFrame::SetStatusWidths(Lua table with number indexes and values );
> // C++ Func: virtual void SetStatusWidths(int n, int *widths );
> virtual void SetStatusWidths(IntArray_FromLuaTable intTable );
> void SetToolBar(wxToolBar* toolBar );

};
// ---------------------------------------------------------------------------
// wxMiniFrame
#if wxLUA_USE_wxMiniFrame
#include "wx/minifram.h"
#define wxTINY_CAPTION_HORIZ
#define wxTINY_CAPTION_VERT
class wxMiniFrame : public wxFrame
{

> wxMiniFrame( );
> wxMiniFrame(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxMiniFrame" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxMiniFrame" );

};
#endif //wxLUA_USE_wxMiniFrame
#endif //wxLUA_USE_wxFrame
// ---------------------------------------------------------------------------
// wxStatusBar
#if wxLUA_USE_wxStatusBar && wxUSE_STATUSBAR
#include "wx/statusbr.h"
#define wxST_SIZEGRIP
#define wxSB_NORMAL
#define wxSB_FLAT
#define wxSB_RAISED
class wxStatusBar : public wxWindow
{

> wxStatusBar( );
> wxStatusBar(wxWindow* parent, wxWindowID id, long style = wxST_SIZEGRIP, const wxString& name = "wxStatusBar" );
> bool Create(wxWindow *parent, wxWindowID id, long style = wxST_SIZEGRIP, const wxString& name = "wxStatusBar" );
> virtual bool GetFieldRect(int i, wxRect& rect) const;
> int GetFieldsCount() const;
> virtual wxString GetStatusText(int ir = 0) const;
> void PopStatusText(int field = 0 );
> void PushStatusText(const wxString& string, int field = 0 );
> // %override void wxStatusBar::SetFieldsCount(either a single number or a Lua table with number indexes and values );
> // C++ Func: virtual void SetFieldsCount(int number = 1, int* widths = NULL );
> virtual void SetFieldsCount(LuaTable intTable );
> void SetMinHeight(int height );
> virtual void SetStatusText(const wxString& text, int i = 0 );
> // void wxStatusBar::SetStatusWidths(Lua table with number indexes and values );
> // C++ Func: virtual void SetStatusWidths(int n, int *widths );
> virtual void SetStatusWidths(IntArray_FromLuaTable intTable );
> // void wxStatusBar::SetStatusStyles(Lua table with number indexes and values );
> // C++ Func: virtual void SetStatusStyles(int n, int *styles );
> virtual void SetStatusStyles(IntArray_FromLuaTable intTable );

};
#endif //wxLUA_USE_wxStatusBar && wxUSE_STATUSBAR

## wxwidgets/wxcore_clipdrag.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxClipboard and drag & drop and their wxDataFormat
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxClipboard
#if wxLUA_USE_wxClipboard && wxUSE_CLIPBOARD
#include "wx/clipbrd.h"
class wxClipboard : public wxObject
{

> !%wxchkver_2_6 #define_pointer wxTheClipboard
> %wxchkver_2_6 static wxClipboard *Get( );
> // No constructor, use global clipboard from static Get() function only
> bool AddData( %ungc wxDataObject *data );
> void Clear( );
> void Close( );
> bool Flush( );
> bool GetData( wxDataObject& data );
> bool IsOpened() const;
> bool IsSupported( const wxDataFormat& format );
> bool Open( );
> bool SetData( %ungc wxDataObject *data );
> void UsePrimarySelection( bool primary = true );

};
// ---------------------------------------------------------------------------
// wxClipboardLocker
class %delete wxClipboardLocker
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxClipboardLocker(wxClipboard *clipboard = NULL );
> bool operator!() const;

};
// ---------------------------------------------------------------------------
// wxClipboardTextEvent
#if %wxchkver_2_8
#include "wx/event.h"
class %delete wxClipboardTextEvent : public wxCommandEvent
{

> %wxEventType wxEVT_COMMAND_TEXT_COPY // EVT_TEXT_COPY(winid, func );
> %wxEventType wxEVT_COMMAND_TEXT_CUT // EVT_TEXT_CUT(winid, func );
> %wxEventType wxEVT_COMMAND_TEXT_PASTE // EVT_TEXT_PASTE(winid, func );
> wxClipboardTextEvent(wxEventType type = wxEVT_NULL, wxWindowID winid = 0 );

};
#endif //%wxchkver_2_8
#endif //wxLUA_USE_wxClipboard && wxUSE_CLIPBOARD
// ---------------------------------------------------------------------------
// wxDataFormat
#if wxLUA_USE_wxDataObject && wxUSE_DATAOBJ
#include "wx/dataobj.h"
enum wxDataFormatId
{

> wxDF_INVALID,
> wxDF_TEXT,
> wxDF_BITMAP,
> wxDF_METAFILE,
> wxDF_SYLK,
> wxDF_DIF,
> wxDF_TIFF,
> wxDF_OEMTEXT,
> wxDF_DIB,
> wxDF_PALETTE,
> wxDF_PENDATA,
> wxDF_RIFF,
> wxDF_WAVE,
> wxDF_UNICODETEXT,
> wxDF_ENHMETAFILE,
> wxDF_FILENAME,
> wxDF_LOCALE,
> wxDF_PRIVATE,
> wxDF_HTML,
> wxDF_MAX

};
class %delete wxDataFormat
{

> #define_object wxFormatInvalid
> wxDataFormat(wxDataFormatId format = wxDF_INVALID );
> wxDataFormat(const wxString &format );
> wxString GetId() const;
> int GetType() const; // returns wxDataFormatId, but it's just an int and msw differs
> void SetId(const wxString &format );
> void SetType(wxDataFormatId format );
> bool operator==(const wxDataFormat& format) const;

};
// ---------------------------------------------------------------------------
// wxDataObject
class wxDataObject
{

> enum Direction
> {
> Get,
> Set
> };
> //wxDataObject() this is a base class, use simplified derived classes
> // %override [Lua table of wxDataFormat objects] wxDataObject::GetAllFormats(wxDataObject::Direction dir = wxDataObject );
> // C++ Func: virtual void GetAllFormats(wxDataFormat *formats, wxDataObject::Direction dir = wxDataObject::Get) const;
> virtual void GetAllFormats(wxDataObject::Direction dir = wxDataObject::Get) const;
> // %override [bool, Lua string] wxDataObject::GetDataHere(const wxDataFormat& format );
> // C++ Func: virtual bool GetDataHere(const wxDataFormat& format, void *buf) const;
> virtual bool GetDataHere(const wxDataFormat& format) const;
> virtual int GetDataSize(const wxDataFormat& format) const;
> virtual int GetFormatCount(wxDataObject::Direction dir = wxDataObject::Get) const;
> virtual wxDataFormat GetPreferredFormat(wxDataObject::Direction dir = wxDataObject::Get) const;
> // %override bool wxDataObject::SetData(const wxDataFormat& format, Lua string );
> // C++ Func: virtual bool SetData(const wxDataFormat& format, int len, const void *buf );
> virtual bool SetData(const wxDataFormat& format, const wxString& str );

};
// ---------------------------------------------------------------------------
// wxDataObjectSimple
class %delete wxDataObjectSimple : public wxDataObject
{

> wxDataObjectSimple(const wxDataFormat& format = wxFormatInvalid );
> const wxDataFormat& GetFormat() const;
> void SetFormat(const wxDataFormat& format );
> // This must be overridden in wxLuaDataObjectSimple, this function returns 0.
> virtual size_t GetDataSize() const;
> // This must be overridden in wxLuaDataObjectSimple, this function returns false.
> virtual bool GetDataHere() const;
> // This must be overridden in wxLuaDataObjectSimple, this function returns false.
> virtual bool SetData(const wxString& str );

};
// ---------------------------------------------------------------------------
// wxLuaDataObjectSimple
class %delete wxLuaDataObjectSimple : public wxDataObjectSimple
{

> wxLuaDataObjectSimple(const wxDataFormat& format = wxFormatInvalid );
> // The functions below are all virtual functions that you MUST override in Lua
> // for this class to work.
> // Override this function to return the size of the data for GetDataHere().
> //virtual size_t GetDataSize() const;
> // Create a Lua function that returns a [bool, Lua string (of exact length GetDataSize())].
> // %override [bool, Lua string] wxLuaDataObjectSimple::GetDataHere( );
> // C++ Func: virtual bool GetDataHere(void *buf) const;
> //virtual bool GetDataHere() const;
> // Create a Lua function that takes a Lua string as the input data.
> // %override bool wxLuaDataObjectSimple::SetData(Lua string );
> // C++ Func: virtual bool SetData(size_t len, const void *buf );
> //virtual bool SetData(const wxString& str );

};
// ---------------------------------------------------------------------------
// wxDataObjectComposite
class %delete wxDataObjectComposite : public wxDataObject
{

> wxDataObjectComposite( );
> void Add(%ungc wxDataObjectSimple *dataObject, bool preferred = false );
> %wxchkver_2_8 wxDataFormat GetReceivedFormat() const;

};
// ---------------------------------------------------------------------------
// wxFileDataObject
class %delete wxFileDataObject : public wxDataObjectSimple
{

> wxFileDataObject( );
> virtual void AddFile(const wxString& file );
> wxArrayString GetFilenames() const;

};
// ---------------------------------------------------------------------------
// wxTextDataObject
class %delete wxTextDataObject : public wxDataObjectSimple
{

> wxTextDataObject(const wxString& text = "" );
> virtual size_t GetTextLength() const;
> virtual wxString GetText() const;
> virtual void SetText(const wxString& text );

};
// ---------------------------------------------------------------------------
// wxBitmapDataObject
class %delete wxBitmapDataObject : public wxDataObjectSimple
{

> wxBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap );
> virtual wxBitmap GetBitmap() const;
> virtual void SetBitmap(const wxBitmap& bitmap );

};
// ---------------------------------------------------------------------------
// wxCustomDataObject - FIXME implement this?
//class wxCustomDataObject : public wxDataObjectSimple
//{
// wxCustomDataObject(const wxDataFormat& format = wxFormatInvalid );
//
// virtual void *Alloc(size_t size );
// virtual void Free( );
// virtual size_t GetSize() const;
// virtual void *GetData() const;
// virtual void SetData(size_t size, const void *data );
// virtual void TakeData( size_t size, void *data );
//};
// ---------------------------------------------------------------------------
// wxURLDataObject - is simply wxTextDataObject with a different name
#if %wxchkver_2_8
class %delete wxURLDataObject : public wxTextDataObject
{

> wxURLDataObject(const wxString& url = "" );
> wxString GetURL() const;
> void SetURL(const wxString& url );

};
#endif //%wxchkver_2_8
#endif //wxLUA_USE_wxDataObject && wxUSE_DATAOBJ
// ---------------------------------------------------------------------------
// wxDropTarget
#if wxLUA_USE_wxDragDrop && wxUSE_DRAG_AND_DROP
#include "wx/dnd.h"
enum
{
wxDrag_CopyOnly,
wxDrag_AllowMove,
wxDrag_DefaultMove
};
enum wxDragResult
{

> wxDragError,
> wxDragNone,
> wxDragCopy,
> wxDragMove,
> wxDragLink,
> wxDragCancel

};
bool wxIsDragResultOk(wxDragResult res );
class wxDropTarget
{

> //wxDropTarget(wxDataObject* data = NULL) pure virtual functions in MSW
> virtual bool GetData( );
> //virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def );
> //virtual bool OnDrop(wxCoord x, wxCoord y );
> //virtual wxDragResult OnEnter(wxCoord x, wxCoord y, wxDragResult def );
> //virtual wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def );
> //virtual void OnLeave( );
> wxDataObject *GetDataObject() const;
> void SetDataObject(%ungc wxDataObject* data );
> wxDragResult GetDefaultAction();
> void SetDefaultAction(wxDragResult action );

};
// ---------------------------------------------------------------------------
// wxFileDropTarget - Base class only, use a wxLuaFileDropTarget and override the virtuals
class wxFileDropTarget : public wxDropTarget
{

> //wxFileDropTarget( );
> //virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
> //virtual bool OnDrop(long x, long y, const void *data, size_t size);
> //virtual bool OnDropFiles(wxCoord x, wxCoord y,const wxArrayString& filenames);

};
// ---------------------------------------------------------------------------
// wxLuaFileDropTarget
class wxLuaFileDropTarget : public wxFileDropTarget
{

> wxLuaFileDropTarget( );
> // Create a Lua function that returns a wxDragResult.
> // %override wxDragResult wxLuaFileDropTarget::OnData(wxCoord x, wxCoord y, wxDragResult def);
> // C++ Func: virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
> virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
> // Create a Lua function that returns a bool.
> // %override bool OnDropFiles(wxCoord x, wxCoord y,const wxArrayString& filenames);
> // C++ Func: virtual bool OnDropFiles(wxCoord x, wxCoord y,const wxArrayString& filenames);
> virtual bool OnDropFiles(wxCoord x, wxCoord y,const wxArrayString& filenames);

};
// ---------------------------------------------------------------------------
// wxTextDropTarget - Base class only, use a wxLuaTextDropTarget and override the virtuals
class wxTextDropTarget : public wxDropTarget
{

> //wxTextDropTarget( );
> //virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& text);
> //virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);

};
// ---------------------------------------------------------------------------
// wxLuaTextDropTarget
class wxLuaTextDropTarget : public wxTextDropTarget
{

> wxLuaTextDropTarget( );
> // Create a Lua function that returns a wxDragResult.
> // %override wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
> // C++ Func: virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
> virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def );
> // Create a Lua function that returns a bool.
> // %override bool OnDropText(wxCoord x, wxCoord y, const wxString& text);
> // C++ Func: virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& text);
> virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& text);

};
// ---------------------------------------------------------------------------
// wxLuaURLDropTarget - wxLua added class, see wxWidgets/samples/dnd
class wxLuaURLDropTarget : public wxDropTarget
{

> wxLuaURLDropTarget( );
> // Create a Lua function that returns a wxDragResult.
> // %override wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
> // C++ Func: virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
> virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def );
> // Create a Lua function that returns a bool.
> // %override bool OnDropURL(wxCoord x, wxCoord y, const wxString& text);
> // C++ Func: virtual bool OnDropURL(wxCoord x, wxCoord y, const wxString& text);
> virtual bool OnDropURL(wxCoord x, wxCoord y, const wxString& text);

};
// ---------------------------------------------------------------------------
// wxDropSource
class %delete wxDropSource // FIXME implement virtual
{

> %win|%mac wxDropSource(wxWindow* win = NULL, const wxCursor& cursorCopy = wxNullCursor, const wxCursor& cursorMove = wxNullCursor, const wxCursor& cursorStop = wxNullCursor );
> %gtk wxDropSource(wxWindow* win = NULL, const wxIcon& iconCopy = wxNullIcon, const wxIcon& iconMove = wxNullIcon, const wxIcon& iconStop = wxNullIcon );
> %win wxDropSource(wxDataObject& data, wxWindow* win = NULL, const wxCursor& cursorCopy = wxNullCursor, const wxCursor& cursorMove = wxNullCursor, const wxCursor& cursorStop = wxNullCursor );
> %gtk wxDropSource(wxDataObject& data, wxWindow* win = NULL, const wxIcon& iconCopy = wxNullIcon, const wxIcon& iconMove = wxNullIcon, const wxIcon& iconStop = wxNullIcon );
> void SetData(wxDataObject& data );
> virtual wxDragResult DoDragDrop(int flags = wxDrag_CopyOnly );
> wxDataObject* GetDataObject( );
> virtual bool GiveFeedback(wxDragResult effect );
> void SetCursor(wxDragResult res, const wxCursor& cursor );

};
// ---------------------------------------------------------------------------
// wxDropFilesEvent
#include "wx/event.h"
class %delete wxDropFilesEvent : public wxEvent
{

> %wxEventType wxEVT_DROP_FILES // EVT_DROP_FILES(func );
> // wxDropFilesEvent(WXTYPE id = 0, int noFiles = 0, wxString* files = NULL) only handle this event
> // %override [Lua table of strings] wxDropFilesEvent::GetFiles( );
> // C++ Func: wxString* GetFiles() const;
> wxString* GetFiles() const;
> int GetNumberOfFiles() const;
> wxPoint GetPosition() const;

};
#endif //wxLUA_USE_wxDragDrop && wxUSE_DRAG_AND_DROP
// ---------------------------------------------------------------------------
// wxMetafile
#if wxLUA_USE_wxMetafile && wxUSE_METAFILE && (%msw|%mac|%os2 );
#include "wx/metafile.h"
//bool wxMakeMetafilePlaceable(const wxString& filename, int minX, int minY, int maxX, int maxY, float scale = 1.0 );
class %delete wxMetafile : public wxObject
{

> wxMetafile(const wxString& filename = "" );
> bool Ok( );
> bool Play(wxDC *dc );
> bool SetClipboard(int width = 0, int height = 0 );

};
// ---------------------------------------------------------------------------
// wxMetafileDC
class %delete wxMetafileDC : public wxDC
{

> wxMetafileDC(const wxString& filename = "" );
> %win %gc wxMetafile* Close( );

};
#endif
#endif //wxLUA_USE_wxMetafile && wxUSE_METAFILE && (%msw|%mac|%os2 );

## wxwidgets/wxcore_controls.i - Lua table = 'wx'

// ===========================================================================
// Purpose: GUI controls like buttons, combos, etc
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// FIXME - handle WX_DECLARE_CONTROL_CONTAINER ?
// ---------------------------------------------------------------------------
// wxButton
#if wxLUA_USE_wxButton && wxUSE_BUTTON
#include "wx/button.h"
#define wxBU_LEFT
#define wxBU_RIGHT
#define wxBU_TOP
#define wxBU_BOTTOM
#define wxBU_EXACTFIT
%wxchkver_2_6 #define wxBU_AUTODRAW
class wxButton : public wxControl
{

> wxButton( );
> wxButton(wxWindow *parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxButton" );
> bool Create(wxWindow *parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxButton" );
> static wxSize GetDefaultSize(); // static is ok, use on existing button
> void SetDefault( );
> //wxString GetLabel() const; // in wxWindow
> //void SetLabel(const wxString& label); // in wxWindow

};
// ---------------------------------------------------------------------------
// wxBitmapButton
#if wxLUA_USE_wxBitmapButton && wxUSE_BMPBUTTON
#include "wx/bmpbuttn.h"
class wxBitmapButton : public wxButton
{

> wxBitmapButton( );
> wxBitmapButton( wxWindow* parent, wxWindowID id, const wxBitmap& bitmap, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxBitmapButton" );
> bool Create(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap, const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxBitmapButton" );
> wxBitmap GetBitmapDisabled() const;
> wxBitmap GetBitmapFocus() const;
> %wxchkver_2_8 wxBitmap GetBitmapHover() const;
> wxBitmap GetBitmapLabel() const;
> wxBitmap GetBitmapSelected() const;
> void SetBitmapDisabled(const wxBitmap& bitmap );
> void SetBitmapFocus(const wxBitmap& bitmap );
> %wxchkver_2_8 void SetBitmapHover(const wxBitmap& hover );
> void SetBitmapLabel(const wxBitmap& bitmap );
> void SetBitmapSelected(const wxBitmap& bitmap );

};
#endif //wxLUA_USE_wxBitmapButton && wxUSE_BMPBUTTON
#endif //wxLUA_USE_wxButton && wxUSE_BUTTON
// ---------------------------------------------------------------------------
// wxToggleButton
#if wxLUA_USE_wxToggleButton && wxUSE_TOGGLEBTN
#include "wx/tglbtn.h"
class wxToggleButton : public wxControl
{

> wxToggleButton( );
> wxToggleButton(wxWindow *parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxToggleButton" );
> bool Create(wxWindow *parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxToggleButton" );
> void SetValue(bool state );
> bool GetValue() const;
> //wxString GetLabel() const; // in wxWindow
> //void SetLabel(const wxString& label); // in wxWindow

};
#endif //wxLUA_USE_wxToggleButton && wxUSE_TOGGLEBTN
// ---------------------------------------------------------------------------
// wxCheckBox
#if wxLUA_USE_wxCheckBox && wxUSE_CHECKBOX
#include "wx/checkbox.h"
#define wxCHK_2STATE
#define wxCHK_3STATE
#define wxCHK_ALLOW_3RD_STATE_FOR_USER
enum wxCheckBoxState
{

> wxCHK_UNCHECKED,
> wxCHK_CHECKED,
> wxCHK_UNDETERMINED

};
class wxCheckBox : public wxControl
{

> wxCheckBox( );
> wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& val = wxDefaultValidator, const wxString& name = "wxCheckBox" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& val = wxDefaultValidator, const wxString& name = "wxCheckBox" );
> bool GetValue() const;
> wxCheckBoxState Get3StateValue() const;
> bool Is3rdStateAllowedForUser() const;
> bool Is3State() const;
> bool IsChecked() const;
> void SetValue(const bool state );
> void Set3StateValue(const wxCheckBoxState state );

};
#endif //wxLUA_USE_wxCheckBox && wxUSE_CHECKBOX
// ---------------------------------------------------------------------------
// wxItemContainerImmutable
#if (wxLUA_USE_wxChoice|wxLUA_USE_wxComboBox|wxLUA_USE_wxListBox) && wxUSE_CONTROLS
#include "wx/ctrlsub.h"
class wxItemContainerImmutable
{

> // no constructor, used only as a base class
> virtual unsigned int GetCount() const;
> virtual bool IsEmpty() const;
> virtual wxString GetString(unsigned int n); // = 0;
> wxArrayString GetStrings() const;
> virtual void SetString(unsigned int n, const wxString& s); // = 0;
> virtual int FindString(const wxString& s, bool bCase = false) const;
> virtual void SetSelection(int n); //= 0;
> virtual int GetSelection() const; //= 0;
> bool SetStringSelection(const wxString& s );
> wxString GetStringSelection() const;
> void Select(int n );

};
// ---------------------------------------------------------------------------
// wxItemContainer
#include "wx/ctrlsub.h"
class wxItemContainer : public wxItemContainerImmutable
{

> // no constructor, used only as base class
> int Append(const wxString& item );
> int Append(const wxString& item, voidptr_long number); // C++ is (void *clientData) You can put a number here
> int Append(const wxString& item, wxClientData *clientData );
> void AppendString( const wxString& item );
> void Append(const wxArrayString& strings);
> int Insert(const wxString& item, unsigned int pos );
> int Insert(const wxString& item, unsigned int pos, voidptr_long number); // C++ is (void *clientData) You can put a number here
> int Insert(const wxString& item, unsigned int pos, wxClientData *clientData);
> virtual void Clear(); //= 0;
> virtual void Delete(unsigned int n); //= 0;
> void SetClientData(unsigned int n, voidptr_long number); // C++ is (void *clientData) You can put a number here
> voidptr_long GetClientData(unsigned int n) const; // C++ returns (void *) You get a number here
> void SetClientObject(unsigned int n, wxClientData* clientData );
> wxClientData* GetClientObject(unsigned int n) const;
> bool HasClientObjectData() const;
> bool HasClientUntypedData() const;

};
#endif
// ---------------------------------------------------------------------------
// wxControlWithItems
#include "wx/ctrlsub.h"
class wxControlWithItems : public wxControl, public wxItemContainer
{

> // no constructor, this is just a base class
> virtual bool ShouldInheritColours() const;

};
#endif //(wxLUA_USE_wxChoice|wxLUA_USE_wxComboBox|wxLUA_USE_wxListBox) && wxUSE_CONTROLS
// ---------------------------------------------------------------------------
// wxChoice
#if wxLUA_USE_wxChoice && wxUSE_CHOICE
#include "wx/choice.h"
class wxChoice : public wxControlWithItems
{

> wxChoice( );
> wxChoice(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxChoice" );
> bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxChoice" );
> int GetCurrentSelection() const;
> //int GetColumns() const; // Motif only but returns 1 otherwise
> //void SetColumns(int n = 1 );
> void Command(wxCommandEvent& event );

};
#endif //wxLUA_USE_wxChoice && wxUSE_CHOICE
// ---------------------------------------------------------------------------
// wxComboBox
#if wxLUA_USE_wxComboBox && wxUSE_COMBOBOX
#include "wx/combobox.h"
#define wxCB_DROPDOWN
#define wxCB_READONLY
#define wxCB_SIMPLE
#define wxCB_SORT
class wxComboBox : public wxControl, public wxItemContainer
{

> wxComboBox( );
> wxComboBox(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxComboBox" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxComboBox" );
> bool CanCopy() const;
> bool CanCut() const;
> bool CanPaste() const;
> bool CanRedo() const;
> bool CanUndo() const;
> void Copy( );
> void Cut( );
> %wxchkver_2_8 virtual int GetCurrentSelection() const;
> long GetInsertionPoint() const;
> long GetLastPosition() const;
> wxString GetValue() const;
> void Paste( );
> void Redo( );
> void Replace(long from, long to, const wxString& text );
> void Remove(long from, long to );
> void SetInsertionPoint(long pos );
> void SetInsertionPointEnd( );
> void SetSelection(long from, long to );
> void SetValue(const wxString& text );
> void Undo( );

};
#endif //wxLUA_USE_wxComboBox && wxUSE_COMBOBOX
// ---------------------------------------------------------------------------
// wxGauge
#if wxLUA_USE_wxGauge && wxUSE_GAUGE
#include "wx/gauge.h"
#define wxGA_HORIZONTAL
%wxcompat_2_6 #define wxGA_PROGRESSBAR
#define wxGA_SMOOTH
#define wxGA_VERTICAL
class wxGauge : public wxControl
{

> wxGauge( );
> wxGauge(wxWindow* parent, wxWindowID id, int range, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxGA_HORIZONTAL, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxGauge" );
> bool Create(wxWindow* parent, wxWindowID id, int range, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxGA_HORIZONTAL, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxGauge" );
> int GetBezelFace() const;
> int GetRange() const;
> int GetShadowWidth() const;
> int GetValue() const;
> bool IsVertical() const;
> %wxchkver_2_8 void Pulse( );
> void SetBezelFace(int width );
> void SetRange(int range );
> void SetShadowWidth(int width );
> void SetValue(int pos );

};
#endif //wxLUA_USE_wxGauge && wxUSE_GAUGE
// ---------------------------------------------------------------------------
// wxListBox
#if wxLUA_USE_wxListBox && wxUSE_LISTBOX
#include "wx/listbox.h"
#define wxLB_SINGLE
#define wxLB_MULTIPLE
#define wxLB_EXTENDED
#define wxLB_HSCROLL
#define wxLB_ALWAYS_SB
#define wxLB_NEEDED_SB
#define wxLB_SORT
#define wxLB_OWNERDRAW
class wxListBox : public wxControlWithItems
{

> wxListBox( );
> wxListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxListBox" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxListBox" );
> void Deselect(int n );
> // %override [Lua table of int selections] wxListBox::GetSelections( );
> // C++ Func: int GetSelections(wxArrayInt& selections) const;
> int GetSelections() const;
> %wxchkver_2_8 int HitTest(const wxPoint& point) const;
> //void InsertItems(int nItems, const wxString items[], int pos );
> void InsertItems(const wxArrayString& items, int pos );
> bool IsSelected(int n) const;
> //void Set(int n, const wxString* choices );
> void Set(const wxArrayString& choices );
> void SetFirstItem(int n );
> void SetSelection(int n, bool select = true );
> void SetStringSelection(const wxString& string, bool select = true );

};
// ---------------------------------------------------------------------------
// wxCheckListBox
#if wxLUA_USE_wxCheckListBox && wxUSE_CHECKLISTBOX
#include "wx/checklst.h"
class wxCheckListBox : public wxListBox
{

> wxCheckListBox( );
> wxCheckListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxCheckListBox" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxCheckListBox" );
> void Check(int item, bool check = true );
> bool IsChecked(int item) const;

};
#endif //wxLUA_USE_wxCheckListBox && wxUSE_CHECKLISTBOX
#endif //wxLUA_USE_wxListBox && wxUSE_LISTBOX
// ---------------------------------------------------------------------------
// wxListCtrl - See wxLuaListCtrl to use the wxLC_VIRTUAL style.
#if wxLUA_USE_wxListCtrl && wxUSE_LISTCTRL
#include "wx/listctrl.h"
#define wxLC_ALIGN_LEFT
#define wxLC_ALIGN_TOP
#define wxLC_AUTOARRANGE
#define wxLC_EDIT_LABELS
#define wxLC_HRULES
#define wxLC_ICON
#define wxLC_LIST
#define wxLC_NO_HEADER
#define wxLC_NO_SORT_HEADER
#define wxLC_REPORT
#define wxLC_SINGLE_SEL
#define wxLC_SMALL_ICON
#define wxLC_SORT_ASCENDING
#define wxLC_SORT_DESCENDING
//#define wxLC_USER_TEXT - deprecated - use wxLC_VIRTUAL
#define wxLC_VIRTUAL
#define wxLC_VRULES
#define wxLC_MASK_TYPE // (wxLC_ICON | wxLC_SMALL_ICON | wxLC_LIST | wxLC_REPORT );
#define wxLC_MASK_ALIGN // (wxLC_ALIGN_TOP | wxLC_ALIGN_LEFT );
#define wxLC_MASK_SORT // (wxLC_SORT_ASCENDING | wxLC_SORT_DESCENDING );
#define wxLIST_ALIGN_DEFAULT
#define wxLIST_ALIGN_LEFT
#define wxLIST_ALIGN_SNAP_TO_GRID
#define wxLIST_ALIGN_TOP
#define wxLIST_AUTOSIZE
#define wxLIST_AUTOSIZE_USEHEADER
#define wxLIST_FIND_DOWN
#define wxLIST_FIND_LEFT
#define wxLIST_FIND_RIGHT
#define wxLIST_FIND_UP
#define wxLIST_HITTEST_ABOVE
#define wxLIST_HITTEST_BELOW
#define wxLIST_HITTEST_NOWHERE
#define wxLIST_HITTEST_ONITEM
#define wxLIST_HITTEST_ONITEMICON
#define wxLIST_HITTEST_ONITEMLABEL
#define wxLIST_HITTEST_ONITEMRIGHT
#define wxLIST_HITTEST_ONITEMSTATEICON
#define wxLIST_HITTEST_TOLEFT
#define wxLIST_HITTEST_TORIGHT
#define wxLIST_MASK_DATA
#define wxLIST_MASK_FORMAT
#define wxLIST_MASK_IMAGE
#define wxLIST_MASK_STATE
#define wxLIST_MASK_TEXT
#define wxLIST_MASK_WIDTH
#define wxLIST_NEXT_ABOVE
#define wxLIST_NEXT_ALL
#define wxLIST_NEXT_BELOW
#define wxLIST_NEXT_LEFT
#define wxLIST_NEXT_RIGHT
#define wxLIST_RECT_BOUNDS
#define wxLIST_RECT_ICON
#define wxLIST_RECT_LABEL
#define wxLIST_SET_ITEM
#define wxLIST_STATE_CUT
#define wxLIST_STATE_DONTCARE
#define wxLIST_STATE_DROPHILITED
#define wxLIST_STATE_FOCUSED
#define wxLIST_STATE_SELECTED
%wxchkver_2_8 #define wxLIST_GETSUBITEMRECT_WHOLEITEM
class wxListCtrl : public wxControl
{

> wxListCtrl( );
> wxListCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxListCtrl" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxListCtrl" );
> bool Arrange(int flag = wxLIST_ALIGN_DEFAULT );
> void AssignImageList(%ungc wxImageList *imageList, int which );
> void ClearAll( );
> bool DeleteAllItems( );
> bool DeleteColumn(int col );
> bool DeleteItem(long item );
> void EditLabel(long item );
> bool EnsureVisible(long item );
> long FindItem(long start, const wxString& str, const bool partial = false );
> long FindItem(long start, long data );
> long FindItem(long start, const wxPoint& pt, int direction );
> bool GetColumn(int col, wxListItem& item) const;
> int GetColumnCount() const;
> int GetColumnWidth(int col) const;
> int GetCountPerPage() const;
> %win|%wxchkver_2_8 wxTextCtrl* GetEditControl() const;
> wxImageList* GetImageList(int which) const;
> bool GetItem(wxListItem& info) const;
> int GetItemCount() const;
> long GetItemData(long item) const;
> wxFont GetItemFont(long item) const;
> bool GetItemPosition(long item, wxPoint& pos) const;
> bool GetItemRect(long item, wxRect& rect, int code = wxLIST_RECT_BOUNDS) const;
> !%wxchkver_2_6 int GetItemSpacing(bool isSmall) const;
> %wxchkver_2_6 wxSize GetItemSpacing() const;
> int GetItemState(long item, long stateMask) const;
> wxString GetItemText(long item) const;
> long GetNextItem(long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE) const;
> int GetSelectedItemCount() const;
> wxColour GetTextColour() const;
> long GetTopItem() const;
> wxRect GetViewRect() const;
> // %override [long, int flags] wxListCtrl::HitTest(const wxPoint& point );
> // C++ Func: long HitTest(const wxPoint& point, int& flags );
> long HitTest(const wxPoint& point );
> long InsertColumn(long col, wxListItem& info );
> long InsertColumn(long col, const wxString& heading, int format = wxLIST_FORMAT_LEFT, int width = -1 );
> long InsertItem(wxListItem& info );
> long InsertItem(long index, const wxString& label );
> long InsertItem(long index, int imageIndex );
> long InsertItem(long index, const wxString& label, int imageIndex );
> //virtual wxListItemAttr * OnGetItemAttr(long item) const;
> //virtual int OnGetItemImage(long item );
> //virtual wxString OnGetItemText(long item, long column) const;
> //void RefreshItem(long item );
> //void RefreshItems(long itemFrom, long itemTo );
> bool ScrollList(int dx, int dy );
> //void SetBackgroundColour(const wxColour& col) - see wxWindow
> bool SetColumn(int col, wxListItem& item );
> bool SetColumnWidth(int col, int width );
> void SetImageList(wxImageList* imageList, int which );
> bool SetItem(wxListItem& info );
> long SetItem(long index, int col, const wxString& label, int imageId = -1 );
> void SetItemBackgroundColour(long item, const wxColour& col );
> bool SetItemColumnImage(long item, long column, int image );
> //void SetItemCount(long count );
> bool SetItemData(long item, long data );
> bool SetItemImage(long item, int image); // int selImage) selImage is deprecated and isn't used anyway
> bool SetItemPosition(long item, const wxPoint& pos );
> bool SetItemState(long item, long state, long stateMask );
> void SetItemText(long item, const wxString& text );
> void SetItemTextColour(long item, const wxColour& col );
> void SetSingleStyle(long style, const bool add = true );
> void SetTextColour(const wxColour& col );
> //void SetWindowStyleFlag(long style) - see wxWindow
> // %override bool SortItems(Lua function(long item1, long item2, long data) returning int, long data );
> // C++ Func: bool SortItems(wxListCtrlCompare fnSortCallBack, long data );
> // Note: the data can only be a number, but you can create a table where the data is
> // an index of it if you need more information.
> // Also, the item1 and item2 are NOT the indexes in the wxListCtrl, but are the
> // client data associated with the item. see SetItemData(item, data) and again
> // you may want to make this "data" equal to an index in a table where you
> // store more information needed for sorting.
> // Your Lua function should return 1, 0, -1 for item1 > item2, item1 == item2, item1 < item2
> bool SortItems(LuaFunction fnSortCallBack, long data );

};
// ---------------------------------------------------------------------------
// wxLuaListCtrl - A wxListCtrl for the wxLC_VIRTUAL style.
class wxLuaListCtrl : public wxListCtrl
{

> // %override - the C++ function takes the wxLuaState as the first param
> wxLuaListCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxLC_REPORT|wxLC_VIRTUAL, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxLuaListCtrl");
> // SetItemCount is needed for wxLC_VIRTUAL
> void SetItemCount(long count );
> // This function must be overridden
> // virtual wxString OnGetItemText (long item, long column) const;
> // This function must be overridden if there is an image list
> // virtual int OnGetItemImage (long item) const;
> // These functions may be overridden
> // virtual wxListItemAttr * OnGetItemAttr(long item) const;
> // virtual wxListItemAttr * OnGetItemColumnAttr(long item, long column) const;
> // virtual int OnGetItemColumnImage(long item, long column) const;
> // %wxchkver_3_0 && %msw virtual int OnGetItemColumnAttr(long item, long column) const;

};
// ---------------------------------------------------------------------------
// wxListItemAttr - wxListCtrl
class %delete wxListItemAttr
{

> wxListItemAttr(const wxColour& colText = wxNullColour, const wxColour& colBack = wxNullColour, const wxFont& font = wxNullFont );
> %wxchkver_2_8 void AssignFrom(const wxListItemAttr& source );
> wxColour GetBackgroundColour( );
> wxFont GetFont( );
> wxColour GetTextColour( );
> bool HasBackgroundColour( );
> bool HasFont( );
> bool HasTextColour( );
> void SetBackgroundColour(const wxColour& colBack );
> void SetFont(const wxFont& font );
> void SetTextColour(const wxColour& colText );

};
// ---------------------------------------------------------------------------
// wxListItem - wxListCtrl
enum wxListColumnFormat
{

> wxLIST_FORMAT_LEFT,
> wxLIST_FORMAT_RIGHT,
> wxLIST_FORMAT_CENTRE,
> wxLIST_FORMAT_CENTER

};
class %delete wxListItem : public wxObject
{

> wxListItem( );
> wxListItem(const wxListItem& item );
> void Clear( );
> void ClearAttributes( );
> wxListColumnFormat GetAlign( );
> wxListItemAttr *GetAttributes( );
> wxColour GetBackgroundColour() const;
> int GetColumn( );
> long GetData( );
> wxFont GetFont() const;
> long GetId( );
> int GetImage( );
> long GetMask( );
> long GetState( );
> wxString GetText( );
> wxColour GetTextColour() const;
> int GetWidth( );
> bool HasAttributes( );
> void SetAlign(wxListColumnFormat align );
> void SetBackgroundColour(const wxColour& colBack );
> void SetColumn(int col );
> void SetData(long data );
> void SetFont(const wxFont& font );
> void SetId(long id );
> void SetImage(int image );
> void SetMask(long mask );
> void SetState(long state );
> void SetStateMask(long stateMask );
> void SetText(const wxString& text );
> void SetTextColour(const wxColour& colText );
> void SetWidth(int width );

};
// ---------------------------------------------------------------------------
// wxListEvent - wxListCtrl
class %delete wxListEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_COMMAND_LIST_BEGIN_DRAG // EVT_LIST_BEGIN_DRAG(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_BEGIN_RDRAG // EVT_LIST_BEGIN_RDRAG(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT // EVT_LIST_BEGIN_LABEL_EDIT(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_COL_CLICK // EVT_LIST_COL_CLICK(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS // EVT_LIST_DELETE_ALL_ITEMS(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_DELETE_ITEM // EVT_LIST_DELETE_ITEM(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_END_LABEL_EDIT // EVT_LIST_END_LABEL_EDIT(id, fn );
> !%wxchkver_2_6 %wxEventType wxEVT_COMMAND_LIST_GET_INFO // EVT_LIST_GET_INFO(id, fn );
> !%wxchkver_2_6 %wxEventType wxEVT_COMMAND_LIST_SET_INFO // EVT_LIST_SET_INFO(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_INSERT_ITEM // EVT_LIST_INSERT_ITEM(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_ITEM_ACTIVATED // EVT_LIST_ITEM_ACTIVATED(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_ITEM_DESELECTED // EVT_LIST_ITEM_DESELECTED(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK // EVT_LIST_ITEM_MIDDLE_CLICK(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK // EVT_LIST_ITEM_RIGHT_CLICK(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_ITEM_SELECTED // EVT_LIST_ITEM_SELECTED(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_KEY_DOWN // EVT_LIST_KEY_DOWN(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_CACHE_HINT // EVT_LIST_CACHE_HINT(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_COL_RIGHT_CLICK // EVT_LIST_COL_RIGHT_CLICK(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_COL_BEGIN_DRAG // EVT_LIST_COL_BEGIN_DRAG(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_COL_DRAGGING // EVT_LIST_COL_DRAGGING(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_COL_END_DRAG // EVT_LIST_COL_END_DRAG(id, fn );
> %wxEventType wxEVT_COMMAND_LIST_ITEM_FOCUSED // EVT_LIST_ITEM_FOCUSED(id, fn );
> wxListEvent(wxEventType commandType = 0, int id = 0 );
> //long GetCacheFrom() const; // - only useful for virtual controls
> //long GetCacheTo() const;
> int GetKeyCode() const;
> long GetIndex() const;
> int GetColumn() const;
> wxPoint GetPoint() const;
> const wxString& GetLabel() const;
> const wxString& GetText() const;
> int GetImage() const;
> long GetData() const;
> long GetMask() const;
> const wxListItem& GetItem() const;
> bool IsEditCancelled() const;

};
// ---------------------------------------------------------------------------
// wxListView
class wxListView : public wxListCtrl
{

> wxListView( );
> wxListView(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxListView" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxLC_ICON, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxListView" );
> void ClearColumnImage(int col );
> void Focus(long index );
> long GetFirstSelected() const;
> long GetFocusedItem() const;
> long GetNextSelected(long item) const;
> bool IsSelected(long index );
> void Select(long n, bool on = true );
> void SetColumnImage(int col, int image );

};
#endif //wxLUA_USE_wxListCtrl && wxUSE_LISTCTRL
// ---------------------------------------------------------------------------
// wxRadioBox
#if wxLUA_USE_wxRadioBox && wxUSE_RADIOBOX
#include "wx/radiobox.h"
#define wxRA_VERTICAL
#define wxRA_HORIZONTAL
#define wxRA_SPECIFY_COLS
#define wxRA_SPECIFY_ROWS
// #define wxRA_USE_CHECKBOX - only for palm os
class wxRadioBox : public wxControl
{

> wxRadioBox( );
> wxRadioBox(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& point = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, int majorDimension = 0, long style = wxRA_SPECIFY_COLS, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxRadioBox" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& point = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, int majorDimension = 0, long style = wxRA_SPECIFY_COLS, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxRadioBox" );
> // these are marked deprecated in 2.6, use wxWindow::Get/SetLabel and Get/SetString below
> // wxString GetLabel() const; // - see wxWindow
> // void SetLabel(const wxString& label); // - see wxWindow
> // wxString GetLabel(int n) const;
> // void SetLabel(int n, const wxString& label );
> void Enable(bool enable );
> void Enable(int n, bool enable );
> int FindString(const wxString& string) const;
> int GetCount() const;
> int GetSelection() const;
> wxString GetStringSelection() const;
> wxString GetString(int n) const;
> void SetString(int n, const wxString &label );
> void SetSelection(int n );
> void SetStringSelection(const wxString& string );
> //bool Show(bool show = true); // see wxWindow
> bool Show(int item, bool show); // must specify both for overload

};
#endif //wxLUA_USE_wxRadioBox && wxUSE_RADIOBOX
// ---------------------------------------------------------------------------
// wxRadioButton
#if wxLUA_USE_wxRadioButton && wxUSE_RADIOBTN
#include "wx/radiobut.h"
#define wxRB_GROUP
#define wxRB_SINGLE
// #define wxRB_USE_CHECKBOX - only for palm os
class wxRadioButton : public wxControl
{

> wxRadioButton( );
> wxRadioButton(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxRadioButton" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxRadioButton" );
> bool GetValue() const;
> void SetValue(const bool value );

};
#endif //wxLUA_USE_wxRadioButton && wxUSE_RADIOBTN
// ---------------------------------------------------------------------------
// wxScrollBar
#if wxLUA_USE_wxScrollBar && wxUSE_SCROLLBAR
#include "wx/scrolbar.h"
#define wxSB_HORIZONTAL
#define wxSB_VERTICAL
class wxScrollBar : public wxControl
{

> wxScrollBar( );
> wxScrollBar(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSB_HORIZONTAL, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxScrollBar" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSB_HORIZONTAL, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxScrollBar" );
> int GetRange() const;
> int GetPageSize() const;
> int GetThumbPosition() const;
> int GetThumbSize() const;
> void SetThumbPosition(int viewStart );
> virtual void SetScrollbar(int position, int thumbSize, int range, int pageSize, const bool refresh = true );

};
#endif //wxLUA_USE_wxScrollBar && wxUSE_SCROLLBAR
// ---------------------------------------------------------------------------
// wxSlider
#if wxLUA_USE_wxSlider && wxUSE_SLIDER
#include "wx/slider.h"
#define wxSL_AUTOTICKS
#define wxSL_BOTH
#define wxSL_BOTTOM
#define wxSL_HORIZONTAL
#define wxSL_LABELS
#define wxSL_LEFT
// #define wxSL_NOTIFY_DRAG %wxcompat_2_6 obsolete
#define wxSL_RIGHT
#define wxSL_SELRANGE
#define wxSL_TOP
#define wxSL_VERTICAL
class wxSlider : public wxControl
{

> wxSlider( );
> wxSlider(wxWindow* parent, wxWindowID id, int value , int minValue, int maxValue, const wxPoint& point = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSL_HORIZONTAL, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxSlider" );
> bool Create(wxWindow* parent, wxWindowID id, int value , int minValue, int maxValue, const wxPoint& point = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSL_HORIZONTAL, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxSlider" );
> void ClearSel( );
> void ClearTicks( );
> int GetLineSize() const;
> int GetMax() const;
> int GetMin() const;
> int GetPageSize() const;
> int GetSelEnd() const;
> int GetSelStart() const;
> int GetThumbLength() const;
> int GetTickFreq() const;
> int GetValue() const;
> void SetLineSize(int lineSize );
> void SetPageSize(int pageSize );
> void SetRange(int minValue, int maxValue );
> void SetSelection(int startPos, int endPos );
> void SetThumbLength(int len );
> void SetTick(int tickPos );
> void SetTickFreq(int n, int pos );
> void SetValue(int value );

};
#endif //wxLUA_USE_wxSlider && wxUSE_SLIDER
// ---------------------------------------------------------------------------
// wxSpinButton
#if wxLUA_USE_wxSpinButton && wxUSE_SPINBTN
#include "wx/spinbutt.h"
#define wxSP_HORIZONTAL
#define wxSP_VERTICAL
#define wxSP_ARROW_KEYS
#define wxSP_WRAP
class wxSpinButton : public wxControl
{

> wxSpinButton( );
> wxSpinButton(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSP_VERTICAL | wxSP_ARROW_KEYS, const wxString& name = "wxSpinButton" );
> bool Create(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSP_VERTICAL | wxSP_ARROW_KEYS, const wxString& name = "wxSpinButton" );
> int GetMax() const;
> int GetMin() const;
> int GetValue() const;
> void SetRange(int min, int max );
> void SetValue(int value );

};
// ---------------------------------------------------------------------------
// wxSpinEvent - for wxSpinButton
#include "wx/spinbutt.h"
#include "wx/spinctrl.h"
class %delete wxSpinEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_SCROLL_LINEUP // EVT_SPIN_UP(winid, func );
> %wxEventType wxEVT_SCROLL_LINEDOWN // EVT_SPIN_DOWN(winid, func );
> %wxEventType wxEVT_SCROLL_THUMBTRACK // EVT_SPIN(winid, func );
> //%wxEventType wxEVT_COMMAND_SPINCTRL_UPDATED - actually a wxCommandEvent is sent
> wxSpinEvent(wxEventType commandType = wxEVT_NULL, int id = 0 );
> int GetPosition() const;
> void SetPosition(int pos );

};
#endif //wxLUA_USE_wxSpinButton && wxUSE_SPINBTN
// ---------------------------------------------------------------------------
// wxSpinCtrl
#if wxLUA_USE_wxSpinCtrl && wxUSE_SPINCTRL
#include "wx/spinctrl.h"
//#define wxSP_ARROW_KEYS see wxSpinButton
//#define wxSP_WRAP see wxSpinButton
class wxSpinCtrl : public wxControl
{

> wxSpinCtrl( );
> wxSpinCtrl(wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSP_ARROW_KEYS, int min = 0, int max = 100, int initial = 0, const wxString& name = "wxSpinCtrl" );
> bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& value = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSP_ARROW_KEYS, int min = 0, int max = 100, int initial = 0, const wxString& name = "wxSpinCtrl" );
> int GetMax() const;
> int GetMin() const;
> int GetValue() const;
> void SetRange(int minVal, int maxVal );
> void SetSelection(long from, long to );
> void SetValue(const wxString& text );
> void SetValue(int iValue );

};
#endif //wxLUA_USE_wxSpinCtrl && wxUSE_SPINCTRL
// ---------------------------------------------------------------------------
// wxTextCtrl
#if wxLUA_USE_wxTextCtrl && wxUSE_TEXTCTRL
#include "wx/textctrl.h"
#define wxTE_PROCESS_ENTER
#define wxTE_PROCESS_TAB
#define wxTE_MULTILINE
#define wxTE_PASSWORD
#define wxTE_READONLY
#define wxTE_RICH
#define wxTE_RICH2
#define wxTE_AUTO_URL
#define wxTE_NOHIDESEL
#define wxTE_LEFT
#define wxTE_CENTRE
#define wxTE_RIGHT
#define wxTE_DONTWRAP
// #define wxTE_LINEWRAP %wxcompat_2_6 obsolete use wxTE_CHARWRAP
#define wxTE_CHARWRAP
#define wxTE_WORDWRAP
#define wxTE_BESTWRAP
#define wxTE_CAPITALIZE
#define wxTE_AUTO_SCROLL
#define wxTE_NO_VSCROLL
enum wxTextCtrlHitTestResult
{

> wxTE_HT_UNKNOWN,
> wxTE_HT_BEFORE,
> wxTE_HT_ON_TEXT,
> wxTE_HT_BELOW,
> wxTE_HT_BEYOND

};
typedef long wxTextCoord
#define wxOutOfRangeTextCoord
#define wxInvalidTextCoord
class wxTextCtrl : public wxControl
{

> wxTextCtrl( );
> wxTextCtrl(wxWindow *parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxTextCtrl" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxTextCtrl" );
> void AppendText(const wxString& text );
> virtual bool CanCopy( );
> virtual bool CanCut( );
> virtual bool CanPaste( );
> virtual bool CanRedo( );
> virtual bool CanUndo( );
> virtual void ChangeValue(const wxString& value );
> virtual void Clear( );
> virtual void Copy( );
> virtual void Cut( );
> void DiscardEdits( );
> bool EmulateKeyPress(const wxKeyEvent& event );
> const wxTextAttr& GetDefaultStyle() const;
> virtual long GetInsertionPoint() const;
> virtual long GetLastPosition() const;
> int GetLineLength(long lineNo) const;
> wxString GetLineText(long lineNo) const;
> int GetNumberOfLines() const;
> virtual wxString GetRange(long from, long to) const;
> // %override [long from, long to] wxTextCtrl::GetSelection( );
> // C++ Func: virtual void GetSelection(long* from, long* to) const;
> virtual void GetSelection() const;
> virtual wxString GetStringSelection( );
> bool GetStyle(long position, wxTextAttr& style );
> wxString GetValue() const;
> // %override [wxTextCtrlHitTestResult, int col, int row] wxTextCtrl::HitTest(const wxPoint& pt );
> // C++ Func: wxTextCtrlHitTestResult HitTest(const wxPoint& pt, wxTextCoord *col, wxTextCoord *row) const;
> wxTextCtrlHitTestResult HitTest(const wxPoint& pt) const;
> // %override [wxTextCtrlHitTestResult, int pos] wxTextCtrl::HitTestPos(const wxPoint& pt );
> // C++ Func: wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const;
> %rename HitTestPos wxTextCtrlHitTestResult HitTest(const wxPoint& pt) const;
> bool IsEditable() const;
> bool IsModified() const;
> bool IsMultiLine() const;
> bool IsSingleLine() const;
> bool LoadFile(const wxString& filename );
> void MarkDirty( );
> //void OnDropFiles(wxDropFilesEvent& event );
> virtual void Paste( );
> // %override [bool, int x, int y] wxTextCtrl::PositionToXY(pos );
> // C++ Func: bool PositionToXY(long pos, long *x, long *y) const;
> bool PositionToXY(long pos) const;
> virtual void Redo( );
> virtual void Remove(long from, long to );
> virtual void Replace(long from, long to, const wxString& value );
> bool SaveFile(const wxString& filename );
> bool SetDefaultStyle(const wxTextAttr& style );
> virtual void SetEditable(bool editable );
> virtual void SetInsertionPoint(long pos );
> virtual void SetInsertionPointEnd( );
> virtual void SetMaxLength(unsigned long value );
> virtual void SetSelection(long from, long to );
> bool SetStyle(long start, long end, const wxTextAttr& style );
> virtual void SetValue(const wxString& value );
> void ShowPosition(long pos );
> virtual void Undo( );
> void WriteText(const wxString& text );
> long XYToPosition(long x, long y );

};
enum wxTextAttrAlignment
{

> wxTEXT_ALIGNMENT_DEFAULT,
> wxTEXT_ALIGNMENT_LEFT,
> wxTEXT_ALIGNMENT_CENTRE,
> wxTEXT_ALIGNMENT_CENTER,
> wxTEXT_ALIGNMENT_RIGHT,
> wxTEXT_ALIGNMENT_JUSTIFIED

};
#define wxTEXT_ATTR_TEXT_COLOUR
#define wxTEXT_ATTR_BACKGROUND_COLOUR
#define wxTEXT_ATTR_FONT_FACE
#define wxTEXT_ATTR_FONT_SIZE
#define wxTEXT_ATTR_FONT_WEIGHT
#define wxTEXT_ATTR_FONT_ITALIC
#define wxTEXT_ATTR_FONT_UNDERLINE
#define wxTEXT_ATTR_FONT
#define wxTEXT_ATTR_ALIGNMENT
#define wxTEXT_ATTR_LEFT_INDENT
#define wxTEXT_ATTR_RIGHT_INDENT
#define wxTEXT_ATTR_TABS
class %delete wxTextAttr
{

> //wxTextAttr( );
> wxTextAttr(const wxColour& colText = wxNullColour, const wxColour& colBack = wxNullColour, const wxFont& font = wxNullFont, wxTextAttrAlignment alignment = wxTEXT_ALIGNMENT_DEFAULT );
> wxTextAttrAlignment GetAlignment() const;
> wxColour GetBackgroundColour() const;
> long GetFlags() const;
> wxFont GetFont() const;
> long GetLeftIndent() const;
> long GetLeftSubIndent() const;
> long GetRightIndent() const;
> const wxArrayInt& GetTabs() const;
> wxColour GetTextColour() const;
> bool HasAlignment() const;
> bool HasBackgroundColour() const;
> bool HasFlag(long flag) const;
> bool HasFont() const;
> bool HasLeftIndent() const;
> bool HasRightIndent() const;
> bool HasTabs() const;
> bool HasTextColour() const;
> bool IsDefault() const;
> void SetAlignment(wxTextAttrAlignment alignment );
> void SetBackgroundColour(const wxColour& colBack );
> void SetFlags(long flags );
> void SetFont(const wxFont& font, long flags = wxTEXT_ATTR_FONT );
> void SetLeftIndent(int indent, int subIndent = 0 );
> void SetRightIndent(int indent );
> void SetTabs(const wxArrayInt& tabs );
> void SetTextColour(const wxColour& colText );

};
// ---------------------------------------------------------------------------
// wxTextUrlEvent
class %delete wxTextUrlEvent : public wxCommandEvent
{

> %wxchkver_2_8_0 %wxEventType wxEVT_COMMAND_TEXT_URL // EVT_TEXT_URL(id, fn );
> wxTextUrlEvent(int winid, const wxMouseEvent& evtMouse, long start, long end );
> const wxMouseEvent& GetMouseEvent() const;
> long GetURLStart() const;
> long GetURLEnd() const;

};
#endif //wxLUA_USE_wxTextCtrl && wxUSE_TEXTCTRL
// ---------------------------------------------------------------------------
// wxTreeCtrl
#if wxLUA_USE_wxTreeCtrl && wxUSE_TREECTRL
#include "wx/treectrl.h"
#define wxTR_NO_BUTTONS
#define wxTR_HAS_BUTTONS
#define wxTR_TWIST_BUTTONS
#define wxTR_NO_LINES
#define wxTR_SINGLE
#define wxTR_MULTIPLE
#define wxTR_EXTENDED
#define wxTR_EDIT_LABELS
#define wxTR_LINES_AT_ROOT
#define wxTR_HIDE_ROOT
#define wxTR_ROW_LINES
#define wxTR_HAS_VARIABLE_ROW_HEIGHT
#define wxTR_FULL_ROW_HIGHLIGHT
#define wxTR_DEFAULT_STYLE
//#define wxTR_MAC_BUTTONS both deprecated
//#define wxTR_AQUA_BUTTONS
enum wxTreeItemIcon
{

> wxTreeItemIcon_Normal,
> wxTreeItemIcon_Selected,
> wxTreeItemIcon_Expanded,
> wxTreeItemIcon_SelectedExpanded,
> wxTreeItemIcon_Max

};
#define wxTREE_HITTEST_ABOVE
#define wxTREE_HITTEST_BELOW
#define wxTREE_HITTEST_NOWHERE
#define wxTREE_HITTEST_ONITEMBUTTON
#define wxTREE_HITTEST_ONITEMICON
#define wxTREE_HITTEST_ONITEMINDENT
#define wxTREE_HITTEST_ONITEMLABEL
#define wxTREE_HITTEST_ONITEMRIGHT
#define wxTREE_HITTEST_ONITEMSTATEICON
#define wxTREE_HITTEST_TOLEFT
#define wxTREE_HITTEST_TORIGHT
#define wxTREE_HITTEST_ONITEMUPPERPART
#define wxTREE_HITTEST_ONITEMLOWERPART
#define wxTREE_HITTEST_ONITEM
%wxchkver_2_9 #define wxTREE_ITEMSTATE_NONE // not state (no display state image)
%wxchkver_2_9 #define wxTREE_ITEMSTATE_NEXT // cycle to the next state
%wxchkver_2_9 #define wxTREE_ITEMSTATE_PREV // cycle to the previous state
class wxTreeCtrl : public wxControl
{

> wxTreeCtrl( );
> wxTreeCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTR_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxTreeCtrl" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTR_HAS_BUTTONS, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxTreeCtrl" );
> wxTreeItemId AddRoot(const wxString& text, int image = -1, int selImage = -1, %ungc wxLuaTreeItemData* data = NULL );
> wxTreeItemId AppendItem(const wxTreeItemId& parent, const wxString& text, int image = -1, int selImage = -1, %ungc wxLuaTreeItemData* data = NULL );
> //void AssignButtonsImageList(wxImageList* imageList );
> void AssignImageList(%ungc wxImageList* imageList );
> void AssignStateImageList(%ungc wxImageList* imageList );
> void Collapse(const wxTreeItemId& item );
> void CollapseAll( );
> void CollapseAllChildren(const wxTreeItemId& item );
> void CollapseAndReset(const wxTreeItemId& item );
> void Delete(const wxTreeItemId& item );
> void DeleteAllItems( );
> void DeleteChildren(const wxTreeItemId& item );
> void EditLabel(const wxTreeItemId& item );
> %win void EndEditLabel(const wxTreeItemId& item, bool discardChanges = false );
> void EnsureVisible(const wxTreeItemId& item );
> void Expand(const wxTreeItemId& item );
> void ExpandAll( );
> void ExpandAllChildren(const wxTreeItemId& item );
> bool GetBoundingRect(const wxTreeItemId& item, wxRect& rect, bool textOnly = false) const;
> //wxImageList* GetButtonsImageList() const;
> size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = true) const;
> int GetCount() const;
> //wxTextCtrl* GetEditControl() const; // MSW only
> // %override [wxTreeItemId, wxTreeItemIdValue cookie] wxTreeCtrl::GetFirstChild(const wxTreeItemId& item );
> // C++ Func: wxTreeItemId GetFirstChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
> wxTreeItemId GetFirstChild(const wxTreeItemId& item) const;
> wxTreeItemId GetFirstVisibleItem() const;
> wxImageList* GetImageList() const;
> int GetIndent() const;
> wxColour GetItemBackgroundColour(const wxTreeItemId& item) const;
> wxLuaTreeItemData* GetItemData(const wxTreeItemId& item) const;
> wxFont GetItemFont(const wxTreeItemId& item) const;
> int GetItemImage(const wxTreeItemId& item, wxTreeItemIcon which = wxTreeItemIcon_Normal) const;
> wxString GetItemText(const wxTreeItemId& item) const;
> wxColour GetItemTextColour(const wxTreeItemId& item) const;
> wxTreeItemId GetLastChild(const wxTreeItemId& item) const;
> // %override [wxTreeItemId, wxTreeItemIdValue cookie] wxTreeCtrl::GetNextChild(const wxTreeItemId& item, long cookie );
> // C++ Func: wxTreeItemId GetNextChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
> wxTreeItemId GetNextChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
> wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
> wxTreeItemId GetNextVisible(const wxTreeItemId& item) const;
> %wxchkver_2_4 wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
> wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
> wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const;
> wxTreeItemId GetRootItem() const;
> bool GetQuickBestSize() const;
> //!%wxchkver_2_6|%wxcompat_2_4 int GetItemSelectedImage(const wxTreeItemId& item) const; // obsolete function
> wxTreeItemId GetSelection() const;
> // %override [size_t, Lua table of wxTreeItemIds] wxTreeCtrl::GetSelections( );
> // C++ Func: size_t GetSelections(wxArrayTreeItemIds& selection) const;
> size_t GetSelections() const;
> wxImageList* GetStateImageList() const;
> // %override [wxTreeItemId, int flags] wxTreeCtrl::HitTest(const wxPoint& point );
> // C++ Func: wxTreeItemId HitTest(const wxPoint& point, int& flags );
> wxTreeItemId HitTest(const wxPoint& point );
> wxTreeItemId InsertItem(const wxTreeItemId& parent, const wxTreeItemId& previous, const wxString& text, int image = -1, int selImage = -1, %ungc wxLuaTreeItemData* data = NULL );
> wxTreeItemId InsertItem(const wxTreeItemId& parent, size_t before, const wxString& text, int image = -1, int selImage = -1, %ungc wxLuaTreeItemData* data = NULL );
> bool IsBold(const wxTreeItemId& item) const;
> bool IsEmpty() const;
> bool IsExpanded(const wxTreeItemId& item) const;
> bool IsSelected(const wxTreeItemId& item) const;
> bool IsVisible(const wxTreeItemId& item) const;
> bool ItemHasChildren(const wxTreeItemId& item) const;
> //int OnCompareItems(const wxTreeItemId& item1, const wxTreeItemId& item2 );
> wxTreeItemId PrependItem(const wxTreeItemId& parent, const wxString& text, int image = -1, int selImage = -1, %ungc wxLuaTreeItemData* data = NULL );
> void ScrollTo(const wxTreeItemId& item );
> void SelectItem(const wxTreeItemId& item, bool select = true );
> //void SetButtonsImageList(wxImageList* imageList );
> void SetIndent(int indent );
> void SetImageList(wxImageList* imageList );
> void SetItemBackgroundColour(const wxTreeItemId& item, const wxColour& col );
> void SetItemBold(const wxTreeItemId& item, bool bold = true );
> void SetItemData(const wxTreeItemId& item, %ungc wxLuaTreeItemData* data );
> void SetItemDropHighlight(const wxTreeItemId& item, boolhighlight = true );
> void SetItemFont(const wxTreeItemId& item, const wxFont& font );
> void SetItemHasChildren(const wxTreeItemId& item, bool hasChildren = true );
> void SetItemImage(const wxTreeItemId& item, int image, wxTreeItemIcon which = wxTreeItemIcon_Normal );
> %wxchkver_2_9 void SetItemState(const wxTreeItemId& item, int state);
> void SetItemText(const wxTreeItemId& item, const wxString& text );
> void SetItemTextColour(const wxTreeItemId& item, const wxColour& col );
> void SetQuickBestSize(bool quickBestSize );
> void SetStateImageList(wxImageList* imageList );
> // void SetWindowStyle(long styles) - see wxWindow
> void SortChildren(const wxTreeItemId& item );
> void Toggle(const wxTreeItemId& item );
> void ToggleItemSelection(const wxTreeItemId& item );
> void Unselect( );
> void UnselectAll( );
> void UnselectItem(const wxTreeItemId& item );

};
// ---------------------------------------------------------------------------
// wxTreeItemAttr - wxTreeCtrl
// This is only used internally in wxWidgets with no public accessors to them.
/*
class %delete wxTreeItemAttr
{

> wxTreeItemAttr(const wxColour& colText = wxNullColour, const wxColour& colBack = wxNullColour, const wxFont& font = wxNullFont );
> wxColour GetBackgroundColour() const;
> wxFont GetFont() const;
> wxColour GetTextColour() const;
> bool HasBackgroundColour( );
> bool HasFont( );
> bool HasTextColour( );
> void SetBackgroundColour(const wxColour& colBack );
> void SetFont(const wxFont& font );
> void SetTextColour(const wxColour& colText );

};
*/
// ---------------------------------------------------------------------------
// wxTreeItemIdValue - wxTreeCtrl
// FAKE typedef, actually typedef void* wxTreeItemIdValue
// Since we override the functions that use it we handle it as a pointer.
typedef double wxTreeItemIdValue
// ---------------------------------------------------------------------------
// wxTreeItemId - wxTreeCtrl
class %delete wxTreeItemId
{

> wxTreeItemId( );
> wxTreeItemId(const wxTreeItemId& id );
> bool IsOk( );
> wxTreeItemIdValue GetValue() const; // get a pointer to the internal data to use as a reference in a Lua table
> wxTreeItemId& operator=(const wxTreeItemId& otherId );
> bool operator==(const wxTreeItemId& otherId) const;

};
// ---------------------------------------------------------------------------
// wxArrayTreeItemIds - wxTreeCtrl
// This is only used by the function wxTreeCtrl::GetSelections(wxArrayTreeItemIds& arr );
// which we have overridden to return a table. This is not necessary.
//
// Note: This is actually an array of the internal wxTreeItemIdValue data
// which is a void* pointer. This is why we use long.
// See wxLua's wxTreeItemId::GetValue() function
/*
class %delete wxArrayTreeItemIds
{

> wxArrayTreeItemIds( );
> wxArrayTreeItemIds(const wxArrayTreeItemIds& array );
> void Add(const wxTreeItemId& id );
> void Alloc(size_t nCount );
> void Clear( );
> void Empty( );
> int GetCount() const;
> int Index(wxTreeItemIdValue treeItemIdValue, bool bFromEnd = false );
> //void Insert(wxTreeItemId& str, int nIndex, size_t copies = 1 );
> bool IsEmpty( );
> wxTreeItemId Item(size_t nIndex) const;
> wxTreeItemId Last( );
> void Remove(wxTreeItemIdValue treeItemIdValue );
> void RemoveAt(size_t nIndex, size_t count = 1 );
> void Shrink( );

};
*/
// ---------------------------------------------------------------------------
// wxTreeItemData - wxTreeCtrl, see also wxLuaTreeItemData
//
// No %delete since the wxTreeCtrl will delete it when set as the data for an item.
// Only create a wxTreeItemData if you're going to attach it to a wxTreeCtrl item to avoid memory leaks.
class %delete wxTreeItemData : public wxClientData
{

> wxTreeItemData( );
> wxTreeItemId GetId( );
> void SetId(const wxTreeItemId& id );

};
// ---------------------------------------------------------------------------
// wxLuaTreeItemData -
//
// No %delete since the wxTreeCtrl will delete it when set as the data for an item.
// Only create a wxLuaTreeItemData if you're going to attach it to a wxTreeCtrl item to avoid memory leaks.
#include "wxbind/include/wxcore_wxlcore.h"
class %delete wxLuaTreeItemData : public wxTreeItemData
{

> wxLuaTreeItemData( );
> // %override wxLuaTreeItemData(any );
> // C++ Func: wxLuaTreeItemData(wxLuaObject* obj );
> wxLuaTreeItemData(any );
> // %override any wxLuaTreeItemData::GetData() const;
> // C++ Func: wxLuaObject* GetData() const;
> any GetData() const;
> // %override void wxLuaTreeItemData::SetData(any );
> // C++ Func: void SetData(wxLuaObject* obj );
> void SetData(any);

};
// ---------------------------------------------------------------------------
// wxTreeEvent - wxTreeCtrl
class %delete wxTreeEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_COMMAND_TREE_BEGIN_DRAG // EVT_TREE_BEGIN_DRAG(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT // EVT_TREE_BEGIN_LABEL_EDIT(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_BEGIN_RDRAG // EVT_TREE_BEGIN_RDRAG(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_DELETE_ITEM // EVT_TREE_DELETE_ITEM(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_END_DRAG // EVT_TREE_END_DRAG(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_END_LABEL_EDIT // EVT_TREE_END_LABEL_EDIT(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_GET_INFO // EVT_TREE_GET_INFO(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_ACTIVATED // EVT_TREE_ITEM_ACTIVATED(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_COLLAPSED // EVT_TREE_ITEM_COLLAPSED(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_COLLAPSING // EVT_TREE_ITEM_COLLAPSING(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_EXPANDED // EVT_TREE_ITEM_EXPANDED(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_EXPANDING // EVT_TREE_ITEM_EXPANDING(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK // EVT_TREE_ITEM_MIDDLE_CLICK(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK // EVT_TREE_ITEM_RIGHT_CLICK(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_KEY_DOWN // EVT_TREE_KEY_DOWN(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_SEL_CHANGED // EVT_TREE_SEL_CHANGED(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_SEL_CHANGING // EVT_TREE_SEL_CHANGING(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_SET_INFO // EVT_TREE_SET_INFO(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_MENU // EVT_TREE_ITEM_MENU(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK // EVT_TREE_STATE_IMAGE_CLICK(id, fn );
> %wxEventType wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP // EVT_TREE_ITEM_GETTOOLTIP(id, fn );
> wxTreeEvent(wxEventType commandType = wxEVT_NULL, int id = 0 );
> int GetKeyCode() const;
> wxTreeItemId GetItem() const;
> wxKeyEvent GetKeyEvent() const;
> const wxString& GetLabel() const;
> wxTreeItemId GetOldItem() const;
> wxPoint GetPoint() const;
> bool IsEditCancelled() const;
> void SetToolTip(const wxString& tooltip );

};
#endif //wxLUA_USE_wxTreeCtrl && wxUSE_TREECTRL
// ---------------------------------------------------------------------------
// wxGenericDirCtrl
#if wxLUA_USE_wxGenericDirCtrl && wxUSE_DIRDLG
#include "wx/dirctrl.h"
enum
{
wxDIRCTRL_DIR_ONLY,
wxDIRCTRL_SELECT_FIRST,
wxDIRCTRL_SHOW_FILTERS,
wxDIRCTRL_3D_INTERNAL,
wxDIRCTRL_EDIT_LABELS
};
%wxchkver_2_9_0 #define_string wxDirDialogDefaultFolderStr
!%wxchkver_2_9_0 #define_wxstring wxDirDialogDefaultFolderStr
class wxGenericDirCtrl : public wxControl
{

> wxGenericDirCtrl( );
> wxGenericDirCtrl(wxWindow *parent, const wxWindowID id = wxID_ANY, const wxString &dir = wxDirDialogDefaultFolderStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER, const wxString& filter = "", int defaultFilter = 0, const wxString& name = "wxGenericDirCtrl" );
> bool Create(wxWindow *parent, const wxWindowID id = wxID_ANY, const wxString &dir = wxDirDialogDefaultFolderStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER, const wxString& filter = "", int defaultFilter = 0, const wxString& name = "wxGenericDirCtrl" );
> void CollapseTree( );
> bool ExpandPath(const wxString& path );
> wxString GetDefaultPath() const;
> wxString GetPath() const;
> wxString GetFilePath() const;
> wxString GetFilter() const;
> int GetFilterIndex() const;
> //wxDirFilterListCtrl* GetFilterListCtrl() const;
> wxTreeItemId GetRootId( );
> wxTreeCtrl* GetTreeCtrl() const;
> void ReCreateTree( );
> void SetDefaultPath(const wxString& path );
> void SetFilter(const wxString& filter );
> void SetFilterIndex(int n );
> void SetPath(const wxString& path );
> void ShowHidden( bool show );
> bool GetShowHidden( );
> //wxTreeItemId FindChild(wxTreeItemId parentId, const wxString& path, bool& done );

};
#endif //wxLUA_USE_wxGenericDirCtrl && wxUSE_DIRDLG
// ---------------------------------------------------------------------------
// wxInfoBar
#if wxUSE_INFOBAR && %wxchkver_2_9_1
#include "wx/infobar.h"
class wxInfoBar : public wxControl
{

> wxInfoBar( );
> wxInfoBar(wxWindow *parent, wxWindowID id );
> bool Create(wxWindow *parent, wxWindowID id );
> void AddButton(wxWindowID btnid, const wxString &label = wxEmptyString );
> void Dismiss( );
> void RemoveButton(wxWindowID btnid );
> void ShowMessage(const wxString &msg, int flags = wxICON_INFORMATION );

};
#endif //wxUSE_INFOBAR && %wxchkver_2_9_1

## wxwidgets/wxcore_core.i - Lua table = 'wx'

// ===========================================================================
// Purpose: Various wxCore classes
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxLog && wxUSE_LOG
// C++ Func: void wxLogStatus(wxFrame *frame, const char *formatString, ... );
// void wxLogStatus(const char *formatString, ...); // this just uses the toplevel frame, use wx.NULL for the frame
void wxLogStatus(wxFrame *frame, const wxString& message );
// ---------------------------------------------------------------------------
// wxLogGui - wxWidgets creates and installs one of these at startup,
// just treat it as a wxLog.
#if wxUSE_LOGGUI
class %delete wxLogGui : public wxLog
{

> wxLogGui( );

};
#endif // wxUSE_LOGGUI
// ---------------------------------------------------------------------------
// wxLogTextCtrl
#if wxLUA_USE_wxTextCtrl && wxUSE_TEXTCTRL
class %delete wxLogTextCtrl : public wxLog
{

> wxLogTextCtrl(wxTextCtrl* textCtrl);

};
#endif // wxLUA_USE_wxTextCtrl && wxUSE_TEXTCTRL
// ---------------------------------------------------------------------------
// wxLogWindow
#if wxLUA_USE_wxLogWindow && wxUSE_LOGWINDOW
class %delete wxLogWindow : public wxLogPassThrough
{

> wxLogWindow(wxWindow *pParent, const wxString& szTitle, bool bShow = true, bool bPassToOld = true);
> void Show(bool show = true );
> wxFrame* GetFrame() const;
> //virtual void OnFrameCreate(wxFrame *frame );
> //virtual bool OnFrameClose(wxFrame *frame );
> //virtual void OnFrameDelete(wxFrame *frame );

};
#endif // wxLUA_USE_wxLogWindow && wxUSE_LOGWINDOW
#endif // wxLUA_USE_wxLog && wxUSE_LOG
// ---------------------------------------------------------------------------
// wxSystemSettings
#if wxLUA_USE_wxSystemSettings
#include "wx/settings.h"
enum wxSystemScreenType
{

> wxSYS_SCREEN_NONE,
> wxSYS_SCREEN_TINY,
> wxSYS_SCREEN_PDA,
> wxSYS_SCREEN_SMALL,
> wxSYS_SCREEN_DESKTOP

};
enum wxSystemMetric
{

> wxSYS_MOUSE_BUTTONS,
> wxSYS_BORDER_X,
> wxSYS_BORDER_Y,
> wxSYS_CURSOR_X,
> wxSYS_CURSOR_Y,
> wxSYS_DCLICK_X,
> wxSYS_DCLICK_Y,
> wxSYS_DRAG_X,
> wxSYS_DRAG_Y,
> wxSYS_EDGE_X,
> wxSYS_EDGE_Y,
> wxSYS_HSCROLL_ARROW_X,
> wxSYS_HSCROLL_ARROW_Y,
> wxSYS_HTHUMB_X,
> wxSYS_ICON_X,
> wxSYS_ICON_Y,
> wxSYS_ICONSPACING_X,
> wxSYS_ICONSPACING_Y,
> wxSYS_WINDOWMIN_X,
> wxSYS_WINDOWMIN_Y,
> wxSYS_SCREEN_X,
> wxSYS_SCREEN_Y,
> wxSYS_FRAMESIZE_X,
> wxSYS_FRAMESIZE_Y,
> wxSYS_SMALLICON_X,
> wxSYS_SMALLICON_Y,
> wxSYS_HSCROLL_Y,
> wxSYS_VSCROLL_X,
> wxSYS_VSCROLL_ARROW_X,
> wxSYS_VSCROLL_ARROW_Y,
> wxSYS_VTHUMB_Y,
> wxSYS_CAPTION_Y,
> wxSYS_MENU_Y,
> wxSYS_NETWORK_PRESENT,
> wxSYS_PENWINDOWS_PRESENT,
> wxSYS_SHOW_SOUNDS,
> wxSYS_SWAP_BUTTONS

};
enum wxSystemFeature
{

> wxSYS_CAN_DRAW_FRAME_DECORATIONS,
> wxSYS_CAN_ICONIZE_FRAME

};
enum wxSystemColour
{

> wxSYS_COLOUR_SCROLLBAR,
> wxSYS_COLOUR_BACKGROUND,
> wxSYS_COLOUR_DESKTOP,
> wxSYS_COLOUR_ACTIVECAPTION,
> wxSYS_COLOUR_INACTIVECAPTION,
> wxSYS_COLOUR_MENU,
> wxSYS_COLOUR_WINDOW,
> wxSYS_COLOUR_WINDOWFRAME,
> wxSYS_COLOUR_MENUTEXT,
> wxSYS_COLOUR_WINDOWTEXT,
> wxSYS_COLOUR_CAPTIONTEXT,
> wxSYS_COLOUR_ACTIVEBORDER,
> wxSYS_COLOUR_INACTIVEBORDER,
> wxSYS_COLOUR_APPWORKSPACE,
> wxSYS_COLOUR_HIGHLIGHT,
> wxSYS_COLOUR_HIGHLIGHTTEXT,
> wxSYS_COLOUR_BTNFACE,
> wxSYS_COLOUR_3DFACE,
> wxSYS_COLOUR_BTNSHADOW,
> wxSYS_COLOUR_3DSHADOW,
> wxSYS_COLOUR_GRAYTEXT,
> wxSYS_COLOUR_BTNTEXT,
> wxSYS_COLOUR_INACTIVECAPTIONTEXT,
> wxSYS_COLOUR_BTNHIGHLIGHT,
> wxSYS_COLOUR_BTNHILIGHT,
> wxSYS_COLOUR_3DHIGHLIGHT,
> wxSYS_COLOUR_3DHILIGHT,
> wxSYS_COLOUR_3DDKSHADOW,
> wxSYS_COLOUR_3DLIGHT,
> wxSYS_COLOUR_INFOTEXT,
> wxSYS_COLOUR_INFOBK,
> wxSYS_COLOUR_LISTBOX,
> wxSYS_COLOUR_HOTLIGHT,
> wxSYS_COLOUR_GRADIENTACTIVECAPTION,
> wxSYS_COLOUR_GRADIENTINACTIVECAPTION,
> wxSYS_COLOUR_MENUHILIGHT,
> wxSYS_COLOUR_MENUBAR,
> wxSYS_COLOUR_MAX

};
enum wxSystemFont
{

> wxSYS_OEM_FIXED_FONT,
> wxSYS_ANSI_FIXED_FONT,
> wxSYS_ANSI_VAR_FONT,
> wxSYS_SYSTEM_FONT,
> wxSYS_DEVICE_DEFAULT_FONT,
> wxSYS_DEFAULT_PALETTE,
> wxSYS_SYSTEM_FIXED_FONT,
> wxSYS_DEFAULT_GUI_FONT

};
class wxSystemSettings
{

> //wxSystemSettings(); // No constructor, all members static
> static wxColour GetColour(wxSystemColour index );
> static wxFont GetFont(wxSystemFont index );
> static int GetMetric(wxSystemMetric index, wxWindow* win = NULL );
> static bool HasFeature(wxSystemFeature index );
> static wxSystemScreenType GetScreenType( );
> static void SetScreenType( wxSystemScreenType screen );

};
#endif //wxLUA_USE_wxSystemSettings
// ---------------------------------------------------------------------------
// wxValidator
#if wxLUA_USE_wxValidator && wxUSE_VALIDATORS
#include "wx/validate.h"
class wxValidator : public wxEvtHandler
{

> #define_object wxDefaultValidator
> // No constructor as this is a base class
> static bool IsSilent( );
> wxWindow* GetWindow() const;
> static void SetBellOnError(bool doIt = true );
> void SetWindow(wxWindow* window );
> virtual bool TransferFromWindow( );
> virtual bool TransferToWindow( );
> virtual bool Validate(wxWindow* parent );

};
// ---------------------------------------------------------------------------
// wxTextValidator
#if wxLUA_USE_wxTextValidator
#include "wx/valtext.h"
#define wxFILTER_NONE
#define wxFILTER_ASCII
#define wxFILTER_ALPHA
#define wxFILTER_ALPHANUMERIC
#define wxFILTER_NUMERIC
#define wxFILTER_INCLUDE_LIST
#define wxFILTER_EXCLUDE_LIST
#define wxFILTER_INCLUDE_CHAR_LIST
#define wxFILTER_EXCLUDE_CHAR_LIST
class %delete wxTextValidator : public wxValidator
{

> // %override wxTextValidator(long style = wxFILTER_NONE, wxLuaObject* obj );
> // C++ Func: wxTextValidator(long style = wxFILTER_NONE, wxString *valPtr = NULL );
> wxTextValidator(long style = wxFILTER_NONE, wxLuaObject* stringObj = NULL );
> %wxchkver_2_6 wxArrayString& GetExcludes( );
> %wxchkver_2_6 wxArrayString& GetIncludes( );
> long GetStyle() const;
> void SetStyle(long style );
> %wxchkver_2_6 void SetIncludes(const wxArrayString& includes );
> %wxchkver_2_6 void SetExcludes(const wxArrayString& excludes );
> //!%wxchkver_2_6|%wxcompat_2_4 wxStringList& GetExcludeList() const;
> //!%wxchkver_2_6|%wxcompat_2_4 wxStringList& GetIncludeList() const;
> //!%wxchkver_2_6|%wxcompat_2_4 void SetExcludeList(const wxStringList& stringList );
> //!%wxchkver_2_6|%wxcompat_2_4 void SetIncludeList(const wxStringList& stringList );

};
#endif //wxLUA_USE_wxTextValidator
// ---------------------------------------------------------------------------
// wxGenericValidator
#if wxLUA_USE_wxGenericValidator
#include "wx/valgen.h"
class %delete wxGenericValidator : public wxValidator
{

> // See the validator.wx.Lua sample for usage of this class
> // %override wxGenericValidatorBool(wxLuaObject* boolObj );
> // C++ Func: wxGenericValidator(bool *boolPtr );
> // for wxCheckBox and wxRadioButton
> %rename wxGenericValidatorBool wxGenericValidator(wxLuaObject* boolObj );
> // %override wxGenericValidatorString(wxLuaObject* stringObj );
> // C++ Func: wxGenericValidator(wxString *valPtr );
> // for wxButton and wxComboBox, wxStaticText and wxTextCtrl
> %rename wxGenericValidatorString wxGenericValidator(wxLuaObject* stringObj );
> // %override wxGenericValidatorInt(wxLuaObject* intObj );
> // C++ Func: wxGenericValidator(int *valPtr );
> // for wxGauge, wxScrollBar, wxRadioBox, wxSpinButton, wxChoice
> %rename wxGenericValidatorInt wxGenericValidator(wxLuaObject* intObj );
> // %override wxGenericValidatorArrayInt(wxLuaObject* intTableObj );
> // C++ Func: wxGenericValidator(wxArrayInt *valPtr );
> // for wxListBox and wxCheckListBox
> %rename wxGenericValidatorArrayInt wxGenericValidator(wxLuaObject* intTableObj );

};
#endif //wxLUA_USE_wxGenericValidator
#endif //wxLUA_USE_wxValidator && wxUSE_VALIDATORS
// ---------------------------------------------------------------------------
// wxMemoryFSHandler - See also wxbase_file.i for other wxFileSystemHandlers
#if wxUSE_STREAMS && wxUSE_FILESYSTEM
#include "wx/fs_mem.h"
class %delete wxMemoryFSHandler : public wxFileSystemHandler
{

> wxMemoryFSHandler( );
> // Remove file from memory FS and free occupied memory
> static void RemoveFile(const wxString& filename);
> static void AddFile(const wxString& filename, const wxString& textdata);
> //static void AddFile(const wxString& filename, const void *binarydata, size_t size );
> #if %wxchkver_2_8_5
> static void AddFileWithMimeType(const wxString& filename, const wxString& textdata, const wxString& mimetype);
> //static void AddFileWithMimeType(const wxString& filename, const void *binarydata, size_t size, const wxString& mimetype );
> #endif // %wxchkver_2_8_5
> #if wxUSE_IMAGE
> static void AddFile(const wxString& filename, const wxImage& image, wxBitmapType type);
> static void AddFile(const wxString& filename, const wxBitmap& bitmap, wxBitmapType type);
> #endif // wxUSE_IMAGE

};
#endif // wxUSE_STREAMS && wxUSE_FILESYSTEM

## wxwidgets/wxcore_defsutils.i - Lua table = 'wx'

// ===========================================================================
// Purpose: enums, defines from wx/defs.h and other places
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#include "wx/defs.h"
#include "wx/utils.h"
// This list of global functions is taken from the wxWindow's manual
// ---------------------------------------------------------------------------
// Application initialization and termination
void wxInitAllImageHandlers( );
bool wxSafeYield(wxWindow* win = NULL, bool onlyIfNeeded = false );
bool wxYield( );
void wxWakeUpIdle( );
// ---------------------------------------------------------------------------
// wxProcess
#if wxLUA_USE_wxProcess
enum
{
wxEXEC_ASYNC,
wxEXEC_SYNC,
wxEXEC_NOHIDE,
wxEXEC_MAKE_GROUP_LEADER,
wxEXEC_NODISABLE
};
enum
{
wxPROCESS_DEFAULT,
wxPROCESS_REDIRECT
};
enum wxSignal
{

> wxSIGNONE,
> wxSIGHUP,
> wxSIGINT,
> wxSIGQUIT,
> wxSIGILL,
> wxSIGTRAP,
> wxSIGABRT,
> wxSIGEMT,
> wxSIGFPE,
> wxSIGKILL,
> wxSIGBUS,
> wxSIGSEGV,
> wxSIGSYS,
> wxSIGPIPE,
> wxSIGALRM,
> wxSIGTERM

};
enum wxKillError
{

> wxKILL_OK,
> wxKILL_BAD_SIGNAL,
> wxKILL_ACCESS_DENIED,
> wxKILL_NO_PROCESS,
> wxKILL_ERROR

};
enum wxKillFlags
{

> wxKILL_NOCHILDREN,
> wxKILL_CHILDREN

};
class %delete wxProcess : public wxEvtHandler
{

> wxProcess(wxEvtHandler *parent = NULL, int nId = wxID_ANY );
> //wxProcess(int flags );
> void Detach( );
> static wxKillError Kill(int pid, wxSignal sig = wxSIGTERM, int flags = wxKILL_NOCHILDREN );
> static bool Exists(int pid );
> //virtual void OnTerminate(int pid, int status) just handle the event instead
> static wxProcess *Open(const wxString& cmd, int flags = wxEXEC_ASYNC );
> void Redirect( );
> bool IsRedirected( );
> #if wxUSE_STREAMS
> void CloseOutput( );
> wxInputStream *GetErrorStream() const;
> wxInputStream *GetInputStream() const;
> wxOutputStream *GetOutputStream() const;
> bool IsErrorAvailable() const;
> bool IsInputAvailable() const;
> bool IsInputOpened() const;
> void SetPipeStreams(wxInputStream *outStream, wxOutputStream *inStream, wxInputStream *errStream );
> #endif // wxUSE_STREAMS

};
#endif //wxLUA_USE_wxProcess
// ---------------------------------------------------------------------------
// Process control functions
!%wxchkver_2_6 long wxExecute(const wxString& command, bool sync = false, wxProcess *callback = NULL );
%wxchkver_2_6 long wxExecute(const wxString& command, int flags = wxEXEC_ASYNC, wxProcess *process = NULL );
// %override [long, Lua table of output strings] wxExecuteStdout(const wxString& command, int flags = 0 );
%rename wxExecuteStdout long wxExecute(const wxString& command, wxArrayString& output, int flags = 0 );
// %override [long, Lua table of output strings, Lua table of error strings] wxExecuteStdoutStderr(const wxString& command, int flags = 0 );
%rename wxExecuteStdoutStderr long wxExecute(const wxString& command, wxArrayString& output, wxArrayString& errors, int flags = 0 );
void wxExit( );
// %override [int, wxKillError rc] wxKill(long pid, wxSignal sig = wxSIGTERM, int flags = 0 );
// C++ Func: int wxKill(long pid, wxSignal sig = wxSIGTERM, wxKillError *rc = NULL, int flags = 0 );
int wxKill(long pid, wxSignal sig = wxSIGTERM, int flags = 0 );
unsigned long wxGetProcessId( );
bool wxShell(const wxString& command = "" );
enum wxShutdownFlags
{

> wxSHUTDOWN_POWEROFF,
> wxSHUTDOWN_REBOOT

};
bool wxShutdown(wxShutdownFlags flags );
// ---------------------------------------------------------------------------
// File functions - see file.i
// ---------------------------------------------------------------------------
// Network, user, and OS functions - see wxbase_base.i
// ---------------------------------------------------------------------------
// String functions - nothing useful here
// ---------------------------------------------------------------------------
// Dialog functions - see dialogs.i
//void wxBeginBusyCursor(wxCursor *cursor = wxLua_wxHOURGLASS_CURSOR );
//void wxBell( );
//void wxEndBusyCursor( );
//bool wxIsBusy( );
// ---------------------------------------------------------------------------
// Math functions - nothing useful here
// ---------------------------------------------------------------------------
// GDI functions
// %override [int x, int y, int width, int height] wxClientDisplayRect( );
// void wxClientDisplayRect(int *x, int *y, int *width, int *height );
void wxClientDisplayRect( );
wxRect wxGetClientDisplayRect( );
bool wxColourDisplay( );
int wxDisplayDepth( );
// %override [int width, int height] wxDisplaySize( );
// void wxDisplaySize(int *width, int *height );
void wxDisplaySize( );
wxSize wxGetDisplaySize( );
// %override [int width, int height] wxDisplaySizeMM( );
// void wxDisplaySizeMM(int *width, int *height );
void wxDisplaySizeMM( );
wxSize wxGetDisplaySizeMM( );
void wxSetCursor(const wxCursor &cursor );
// wxIconOrCursor wxDROP_ICON(wxString name );
// ---------------------------------------------------------------------------
// Printer settings - are marked obsolete
// ---------------------------------------------------------------------------
// Clipboard functions - are marked obsolete
// ---------------------------------------------------------------------------
// Miscellaneous functions
bool wxGetKeyState(wxKeyCode key );
long wxNewId( );
void wxRegisterId(long id );
void wxEnableTopLevelWindows(bool enable = true );
int wxFindMenuItemId(wxFrame *frame, const wxString& menuString, const wxString& itemString );
wxWindow* wxFindWindowByLabel(const wxString& label, wxWindow *parent=NULL );
wxWindow* wxFindWindowByName(const wxString& name, wxWindow *parent=NULL );
wxWindow* wxFindWindowAtPoint(const wxPoint& pt );
wxWindow* wxFindWindowAtPointer(wxPoint& pt );
%wxchkver_2_8_4 wxWindow* wxGetActiveWindow( );
// wxBatteryState wxGetBatteryState( );
// X only wxString wxGetDisplayName( );
// X only void wxSetDisplayName(const wxString& displayName );
// wxPowerType wxGetPowerType( );
wxPoint wxGetMousePosition( );
#if %wxchkver_2_8
// This is in wxWidgets 2.6 docs, but it's only in >=2.7
class %delete wxMouseState
{

> wxMouseState( );
> wxCoord GetX( );
> wxCoord GetY( );
> bool LeftDown( );
> bool MiddleDown( );
> bool RightDown( );
> bool ControlDown( );
> bool ShiftDown( );
> bool AltDown( );
> bool MetaDown( );
> bool CmdDown( );
> void SetX(wxCoord x );
> void SetY(wxCoord y );
> void SetLeftDown(bool down );
> void SetMiddleDown(bool down );
> void SetRightDown(bool down );
> void SetControlDown(bool down );
> void SetShiftDown(bool down );
> void SetAltDown(bool down );
> void SetMetaDown(bool down );

};
wxMouseState wxGetMouseState( );
#endif
// bool wxGetResource(const wxString& section, const wxString& entry, const wxString& *value, const wxString& file = "" );
// bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file = "" );
// wxString wxGetStockLabel(wxWindowID id, bool withCodes = true, wxString accelerator = wxEmptyString );
wxWindow* wxGetTopLevelParent(wxWindow *win );
bool wxLaunchDefaultBrowser(const wxString& sUrl );
//%win wxString wxLoadUserResource(const wxString& resourceName, const wxString& resourceType="TEXT" );
void wxPostEvent(wxEvtHandler *dest, wxEvent& event );
// ---------------------------------------------------------------------------
// Byte order macros - nothing useful
// ---------------------------------------------------------------------------
// RTTI functions - nothing useful, see wxObject:DynamicCast
// ---------------------------------------------------------------------------
// Log functions - FIXME maybe useful?
// ---------------------------------------------------------------------------
// Time functions - see datetime.i
// ---------------------------------------------------------------------------
// Debugging macros and functions - nothing useful
// ---------------------------------------------------------------------------
// Environmental access functions - see wxbase_base.i
// ---------------------------------------------------------------------------
// wxWidgets window IDs - copied from wx/defs.h
#if wxLUA_USE_wxID_XXX
#define wxID_NONE
#define wxID_SEPARATOR
#define wxID_ANY
#define wxID_LOWEST
#define wxID_OPEN
#define wxID_CLOSE
#define wxID_NEW
#define wxID_SAVE
#define wxID_SAVEAS
#define wxID_REVERT
#define wxID_EXIT
#define wxID_UNDO
#define wxID_REDO
#define wxID_HELP
#define wxID_PRINT
#define wxID_PRINT_SETUP
%wxchkver_2_8 #define wxID_PAGE_SETUP
#define wxID_PREVIEW
#define wxID_ABOUT
#define wxID_HELP_CONTENTS
%wxchkver_2_8 #define wxID_HELP_INDEX
%wxchkver_2_8 #define wxID_HELP_SEARCH
#define wxID_HELP_COMMANDS
#define wxID_HELP_PROCEDURES
#define wxID_HELP_CONTEXT
#define wxID_CLOSE_ALL
#define wxID_PREFERENCES
%wxchkver_2_8 #define wxID_EDIT
#define wxID_CUT
#define wxID_COPY
#define wxID_PASTE
#define wxID_CLEAR
#define wxID_FIND
#define wxID_DUPLICATE
#define wxID_SELECTALL
#define wxID_DELETE
#define wxID_REPLACE
#define wxID_REPLACE_ALL
#define wxID_PROPERTIES
#define wxID_VIEW_DETAILS
#define wxID_VIEW_LARGEICONS
#define wxID_VIEW_SMALLICONS
#define wxID_VIEW_LIST
#define wxID_VIEW_SORTDATE
#define wxID_VIEW_SORTNAME
#define wxID_VIEW_SORTSIZE
#define wxID_VIEW_SORTTYPE
%wxchkver_2_8 #define wxID_FILE
#define wxID_FILE1
#define wxID_FILE2
#define wxID_FILE3
#define wxID_FILE4
#define wxID_FILE5
#define wxID_FILE6
#define wxID_FILE7
#define wxID_FILE8
#define wxID_FILE9
#define wxID_OK
#define wxID_CANCEL
#define wxID_APPLY
#define wxID_YES
#define wxID_NO
#define wxID_STATIC
#define wxID_FORWARD
#define wxID_BACKWARD
#define wxID_DEFAULT
#define wxID_MORE
#define wxID_SETUP
#define wxID_RESET
#define wxID_CONTEXT_HELP
#define wxID_YESTOALL
#define wxID_NOTOALL
#define wxID_ABORT
#define wxID_RETRY
#define wxID_IGNORE
#define wxID_ADD
#define wxID_REMOVE
#define wxID_UP
#define wxID_DOWN
#define wxID_HOME
#define wxID_REFRESH
#define wxID_STOP
#define wxID_INDEX
#define wxID_BOLD
#define wxID_ITALIC
#define wxID_JUSTIFY_CENTER
#define wxID_JUSTIFY_FILL
#define wxID_JUSTIFY_RIGHT
#define wxID_JUSTIFY_LEFT
#define wxID_UNDERLINE
#define wxID_INDENT
#define wxID_UNINDENT
#define wxID_ZOOM_100
#define wxID_ZOOM_FIT
#define wxID_ZOOM_IN
#define wxID_ZOOM_OUT
#define wxID_UNDELETE
#define wxID_REVERT_TO_SAVED
#define wxID_SYSTEM_MENU
#define wxID_CLOSE_FRAME
#define wxID_MOVE_FRAME
#define wxID_RESIZE_FRAME
#define wxID_MAXIMIZE_FRAME
#define wxID_ICONIZE_FRAME
#define wxID_RESTORE_FRAME
// #define wxID_FILEDLGG - probably not useful
#define wxID_HIGHEST
#endif //wxLUA_USE_wxID_XXX
// ---------------------------------------------------------------------------
// Generic defines and enums
#define wxBACKINGSTORE
#define wxBACKWARD
#define wxCANCEL
#define wxCENTER
#define wxCENTER_FRAME
#define wxCENTER_ON_SCREEN
#define wxCENTRE
#define wxCENTRE_ON_SCREEN
#define wxCOLOURED
//#define wxED_BUTTONS_BOTTOM // for wxExtDialog? not used?
//#define wxED_BUTTONS_RIGHT
//#define wxED_CLIENT_MARGIN
//#define wxED_STATIC_LINE
#define wxFIXED_LENGTH
#define wxFORWARD
#define wxHELP
#define wxMORE
#define wxNO
#define wxNO_BORDER
#define wxNO_DEFAULT
#define wxOK
// #define wxPASSWORD %wxcompat_2_6 use wxTE_PASSWORD
// #define wxPROCESS_ENTER %wxcompat_2_6 use wxTE_PROCESS_ENTER
#define wxRESET
// #define wxRESIZE_BOX %wxcompat_2_6 use wxMAXIMIZE_BOX
#define wxRETAINED
#define wxSETUP
#define wxSIZE_ALLOW_MINUS_ONE
#define wxSIZE_AUTO
#define wxSIZE_AUTO_HEIGHT
#define wxSIZE_AUTO_WIDTH
#define wxSIZE_NO_ADJUSTMENTS
#define wxSIZE_USE_EXISTING
//#define wxUSER_COLOURS deprecated use wxNO_3D %wxcompat_2_6
#define wxYES
#define wxYES_DEFAULT
#define wxYES_NO
enum wxOrientation
{

> wxHORIZONTAL,
> wxVERTICAL,
> wxBOTH

};
enum wxDirection
{

> wxLEFT,
> wxRIGHT,
> wxUP,
> wxDOWN,
> wxTOP,
> wxBOTTOM,
> wxNORTH,
> wxSOUTH,
> wxWEST,
> wxEAST,
> wxALL

};
enum wxAlignment
{

> wxALIGN_NOT,
> wxALIGN_CENTER_HORIZONTAL,
> wxALIGN_CENTRE_HORIZONTAL,
> wxALIGN_LEFT,
> wxALIGN_TOP,
> wxALIGN_RIGHT,
> wxALIGN_BOTTOM,
> wxALIGN_CENTER_VERTICAL,
> wxALIGN_CENTRE_VERTICAL,
> wxALIGN_CENTER,
> wxALIGN_CENTRE,
> wxALIGN_MASK

};
enum wxStretch
{

> wxSTRETCH_NOT,
> wxSHRINK,
> wxGROW,
> wxEXPAND,
> wxSHAPED,
> wxTILE,
> wxADJUST_MINSIZE, // deprecated after 2.4 and takes the value of 0
> %wxchkver_2_8_8 wxFIXED_MINSIZE,
> %wxchkver_2_8_8 wxRESERVE_SPACE_EVEN_IF_HIDDEN

};
enum wxBorder
{

> wxBORDER_DEFAULT,
> wxBORDER_NONE,
> wxBORDER_STATIC,
> wxBORDER_SIMPLE,
> wxBORDER_RAISED,
> wxBORDER_SUNKEN,
> wxBORDER_DOUBLE,
> wxBORDER_MASK

};
enum wxBackgroundStyle
{

> wxBG_STYLE_SYSTEM,
> wxBG_STYLE_COLOUR,
> wxBG_STYLE_CUSTOM

};
enum wxKeyModifier
{

> wxMOD_NONE,
> wxMOD_ALT,
> wxMOD_CONTROL,
> wxMOD_ALTGR,
> wxMOD_SHIFT,
> wxMOD_META,
> wxMOD_WIN,
> wxMOD_CMD,
> wxMOD_ALL

};
// ---------------------------------------------------------------------------
// wxBusyCursor
#if wxLUA_USE_wxBusyCursor
#include "wx/utils.h"
class %delete wxBusyCursor
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxBusyCursor(wxCursor* cursor = wxHOURGLASS_CURSOR );

};
// ---------------------------------------------------------------------------
// wxBusyCursorSuspender - we don't wrap this since Lua's garbage collector doesn't
// automatically collect items when they go out of scope so you would have to
// delete() this anyway which is just as easy as wxBegin/EndBusyCursor
//class %delete wxBusyCursorSuspender
//{
// NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
// wxBusyCursorSuspender( );
//};
#endif //wxLUA_USE_wxBusyCursor
// ---------------------------------------------------------------------------
// wxBusyInfo
#if wxLUA_USE_wxBusyInfo && wxUSE_BUSYINFO
#include "wx/busyinfo.h"
class %delete wxBusyInfo : public wxObject
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxBusyInfo(const wxString& message, wxWindow *parent = NULL );

};
#endif //wxLUA_USE_wxBusyInfo && wxUSE_BUSYINFO
// ---------------------------------------------------------------------------
// wxTimer
#if wxLUA_USE_wxTimer && wxUSE_TIMER
#include "wx/timer.h"
#define wxTIMER_CONTINUOUS
#define wxTIMER_ONE_SHOT
class %delete wxTimer : public wxEvtHandler
{

> wxTimer(wxEvtHandler *owner, int id = -1 );
> int GetInterval() const;
> bool IsOneShot() const;
> bool IsRunning() const;
> void Notify( );
> void SetOwner(wxEvtHandler *owner, int id = -1 );
> bool Start(int milliseconds = -1, bool oneShot = false );
> void Stop( );

};
// ---------------------------------------------------------------------------
// wxTimerEvent
#include "wx/timer.h"
class %delete wxTimerEvent : public wxEvent
{

> %wxEventType wxEVT_TIMER // EVT_TIMER(id, fn );
> int GetInterval() const;

};
#endif //wxLUA_USE_wxTimer && wxUSE_TIMER

## wxwidgets/wxcore_dialogs.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxDialog and all dialog classes and functions
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
%wxchkver_3_0 #define wxICON_NONE
#define wxICON_ASTERISK
#define wxICON_ERROR
#define wxICON_EXCLAMATION
#define wxICON_HAND
#define wxICON_INFORMATION
#define wxICON_MASK
#define wxICON_QUESTION
#define wxICON_STOP
#define wxICON_WARNING
#if %wxcompat_2_6
enum // for wxFileSelector and wxFileDialog
{

> wxOPEN,
> wxSAVE,
> wxOVERWRITE_PROMPT,
> %wxcompat_2_4 wxHIDE_READONLY,
> wxFILE_MUST_EXIST,
> wxMULTIPLE,
> wxCHANGE_DIR

};
#endif //%wxcompat_2_6
#if %wxchkver_2_8
enum
{
wxFD_OPEN,
wxFD_SAVE,
wxFD_OVERWRITE_PROMPT,
wxFD_FILE_MUST_EXIST,
wxFD_MULTIPLE,
wxFD_CHANGE_DIR,
wxFD_PREVIEW,
wxFD_DEFAULT_STYLE
};
#endif //%wxchkver_2_8
// ---------------------------------------------------------------------------
// Dialog functions from wxWidgets functions documentation
void wxBeginBusyCursor(wxCursor *cursor = wxLua_wxHOURGLASS_CURSOR );
void wxEndBusyCursor( );
void wxBell( );
// wxTipProvider* wxCreateFileTipProvider(const wxString& filename, size_t currentTip );
#define_wxstring wxDirSelectorPromptStr wxT("Select a directory" );
wxString wxDirSelector(const wxString& message = wxDirSelectorPromptStr, const wxString& default_path = "", long style = wxDD_DEFAULT_STYLE, const wxPoint& pos = wxDefaultPosition, wxWindow *parent = NULL );
wxString wxFileSelector(const wxString& message, const wxString& default_path = "", const wxString& default_filename = "", const wxString& default_extension = "", const wxString& wildcard = "*.*", int flags = 0, wxWindow *parent = NULL, int x = -1, int y = -1 );
wxUSE_COLOURDLG&&!%wxchkver_2_8 wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit );
wxUSE_COLOURDLG&&%wxchkver_2_8 wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit, const wxString& caption = "" );
!%wxchkver_2_8&&wxUSE_FONTDLG wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit );
%wxchkver_2_8&&wxUSE_FONTDLG wxFont wxGetFontFromUser(wxWindow *parent = NULL, const wxFont& fontInit = wxNullFont, const wxString& caption = "" );
// %override [int, Lua int table] wxGetMultipleChoices(const wxString& message, const wxString& caption, Lua string table, wxWindow *parent = NULL, int x = -1, int y = -1, bool centre = true, int width=150, int height=200 );
// int wxGetMultipleChoices(const wxString& message, const wxString& caption, int n, const wxString choices[], int nsel, int *selection, wxWindow *parent = NULL, int x = -1, int y = -1, bool centre = true, int width=150, int height=200 );
wxUSE_CHOICEDLG int wxGetMultipleChoices(const wxString& message, const wxString& caption, LuaTable strTable, wxWindow *parent = NULL, int x = -1, int y = -1, bool centre = true, int width=150, int height=200 );
#if wxUSE_NUMBERDLG
%wxchkver_2_6 #include "wx/numdlg.h" // FIXME not in 2.4
long wxGetNumberFromUser(const wxString& message, const wxString& prompt, const wxString& caption, long value, long min = 0, long max = 100, wxWindow *parent = NULL, const wxPoint& pos = wxDefaultPosition );
#endif // wxUSE_NUMBERDLG
wxUSE_TEXTDLG wxString wxGetPasswordFromUser(const wxString& message, const wxString& caption = "Input text", const wxString& default_value = "", wxWindow *parent = NULL );
wxUSE_TEXTDLG wxString wxGetTextFromUser(const wxString& message, const wxString& caption = "Input text", const wxString& default_value = "", wxWindow *parent = NULL, int x = -1, int y = -1, bool centre = true );
// int wxGetMultipleChoice(const wxString& message, const wxString& caption, int n, const wxString& choices[], int nsel, int *selection, wxWindow *parent = NULL, int x = -1, int y = -1, bool centre = true, int width=150, int height=200 );
wxUSE_CHOICEDLG wxString wxGetSingleChoice(const wxString& message, const wxString& caption, const wxArrayString& choices, wxWindow *parent = NULL, int x = wxDefaultCoord, int y = wxDefaultCoord, bool centre = true, int width = wxCHOICE_WIDTH, int height = wxCHOICE_HEIGHT );
wxUSE_CHOICEDLG int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption, const wxArrayString& choices, wxWindow *parent = NULL, int x = wxDefaultCoord, int y = wxDefaultCoord, bool centre = true, int width = wxCHOICE_WIDTH, int height = wxCHOICE_HEIGHT );
bool wxIsBusy( );
int wxMessageBox(const wxString& message, const wxString& caption = "Message", int style = wxOK | wxCENTRE, wxWindow *parent = NULL, int x = -1, int y = -1 );
// bool wxShowTip(wxWindow *parent, wxTipProvider *tipProvider, bool showAtStartup = true );
// ---------------------------------------------------------------------------
// wxDialog
#if wxLUA_USE_wxDialog
#include "wx/dialog.h"
// #define wxDIALOG_MODAL %wxcompat_2_6
// #define wxDIALOG_MODELESS %wxcompat_2_6
#define wxDEFAULT_DIALOG_STYLE
#define wxDIALOG_NO_PARENT
#define wxDIALOG_EX_CONTEXTHELP
// #define wxDIALOG_EX_METAL mac only
#define wxCHOICEDLG_STYLE
class wxDialog : public wxTopLevelWindow
{

> wxDialog( );
> wxDialog(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE, const wxString& name = "wxDialog" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE, const wxString& name = "wxDialog" );
> //void Centre(int direction = wxBOTH) - see wxWindow
> wxUSE_BUTTON wxSizer* CreateButtonSizer(long flags );
> %wxchkver_2_8&&wxUSE_BUTTON wxSizer *CreateSeparatedButtonSizer(long flags );
> wxUSE_BUTTON wxStdDialogButtonSizer* CreateStdDialogButtonSizer(long flags );
> wxUSE_STATTEXT wxSizer *CreateTextSizer( const wxString &message );
> // virtual bool DoOK() - pocketpc only
> void EndModal(int retCode );
> // int GetAffirmativeId() const; // - pocketpc only
> int GetReturnCode( );
> // wxString GetTitle() const; // - see wxToplevelWindow
> //void Iconize(bool iconize); // - in wxToplevelWindow
> //bool IsIconized() const; // - in wxToplevelWindow
> bool IsModal() const;
> //void SetAffirmativeId(int affirmativeId );
> // void SetIcon(const wxIcon& icon) - in wxToplevelWindow
> // void SetModal(const bool flag) - deprecated
> void SetReturnCode(int retCode );
> // void SetTitle(const wxString& title) - in wxToplevelWindow
> // bool Show(const bool show) - see wxWindow
> int ShowModal( );

};
#endif // wxLUA_USE_wxDialog
// ---------------------------------------------------------------------------
// wxColourDialog
#if wxLUA_USE_wxColourDialog && wxUSE_COLOURDLG
#include "wx/colordlg.h"
class wxColourDialog : public wxDialog
{

> wxColourDialog(wxWindow* parent, wxColourData* data = NULL );
> //bool Create(wxWindow* parent, wxColourData* data = NULL );
> wxColourData& GetColourData( );
> //int ShowModal() - in wxDialog

};
// ---------------------------------------------------------------------------
// wxColourData
#include "wx/cmndata.h"
class %delete wxColourData : public wxObject
{

> wxColourData( );
> wxColourData(const wxColourData& cData );
> bool GetChooseFull() const;
> wxColour GetColour() const;
> wxColour GetCustomColour(int i) const;
> void SetChooseFull(bool flag );
> void SetColour(wxColour &colour );
> void SetCustomColour(int i, wxColour &colour );

};
#endif // wxLUA_USE_wxColourDialog && wxUSE_COLOURDLG
// ---------------------------------------------------------------------------
// wxFileDialog
#if wxLUA_USE_wxFileDialog && wxUSE_FILEDLG
#include "wx/filedlg.h"
#define_wxstring wxFileSelectorPromptStr wxT("Select a file" );
%wxchkver_2_9_0 #define_string wxFileSelectorDefaultWildcardStr
!%wxchkver_2_9_0 #define_wxstring wxFileSelectorDefaultWildcardStr
class wxFileDialog : public wxDialog
{

> // wxFileDialog() no default constructor in MSW
> %not_overload !%wxchkver_2_8 wxFileDialog(wxWindow* parent, const wxString& message = "Choose a file", const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildcard = "*.*", long style = 0, const wxPoint& pos = wxDefaultPosition );
> %not_overload %wxchkver_2_8 wxFileDialog(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr, const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildCard = wxFileSelectorDefaultWildcardStr, long style = wxFD_DEFAULT_STYLE, const wxPoint& pos = wxDefaultPosition, const wxSize& sz = wxDefaultSize, const wxString& name = "wxFileDialog" );
> //%wxchkver_2_8 bool Create(wxWindow *parent, const wxString& message = wxFileSelectorPromptStr, const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildCard = wxFileSelectorDefaultWildcardStr, long style = wxFD_DEFAULT_STYLE, const wxPoint& pos = wxDefaultPosition, const wxSize& sz = wxDefaultSize, const wxString& name = "wxFileDialog" );
> wxString GetDirectory() const;
> wxString GetFilename() const;
> // %override [Lua string table] wxFileDialog::GetFilenames( );
> // C++ Func: void GetFilenames(wxArrayString& filenames) const;
> void GetFilenames() const;
> int GetFilterIndex() const;
> wxString GetMessage() const;
> wxString GetPath() const;
> // %override [Lua string table] wxFileDialog::GetPaths( );
> // C++ Func: void GetPaths(wxArrayString& paths) const;
> void GetPaths() const;
> !%wxchkver_2_8 long GetStyle() const;
> wxString GetWildcard() const;
> void SetDirectory(const wxString& directory );
> void SetFilename(const wxString& setfilename );
> void SetFilterIndex(int filterIndex );
> void SetMessage(const wxString& message );
> void SetPath(const wxString& path );
> !%wxchkver_2_8 void SetStyle(long style );
> void SetWildcard(const wxString& wildCard );
> // int ShowModal() - in wxDialog

};
#endif //wxLUA_USE_wxFileDialog && wxUSE_FILEDLG
// ---------------------------------------------------------------------------
// wxDirDialog
#if wxLUA_USE_wxDirDialog && wxUSE_DIRDLG
#include "wx/dirdlg.h"
#define wxDD_DEFAULT_STYLE
!%wxchkver_2_8 #define wxDD_NEW_DIR_BUTTON
%wxchkver_2_8 #define wxDD_CHANGE_DIR
%wxchkver_2_8 #define wxDD_DIR_MUST_EXIST
class wxDirDialog : public wxDialog
{

> wxDirDialog(wxWindow* parent, const wxString& message = "Choose a directory", const wxString& defaultPath = "", long style = 0, const wxPoint& pos = wxDefaultPosition );
> wxString GetPath() const;
> wxString GetMessage() const;
> !%wxchkver_2_8 long GetStyle() const;
> void SetMessage(const wxString& message );
> void SetPath(const wxString& path );
> !%wxchkver_2_8 void SetStyle(long style );
> // int ShowModal() - in wxDialog

};
#endif //wxLUA_USE_wxDirDialog && wxUSE_DIRDLG
// ---------------------------------------------------------------------------
// wxMessageDialog
#if wxLUA_USE_wxMessageDialog && wxUSE_MSGDLG
class wxMessageDialog : public wxDialog
{

> wxMessageDialog(wxWindow* parent, const wxString& message, const wxString& caption = "Message box", long style = wxOK | wxCANCEL | wxCENTRE, const wxPoint& pos = wxDefaultPosition );
> // int ShowModal() - in wxDialog
> %wxchkver_2_9_0 void SetExtendedMessage(const wxString& extendedMessage);
> %wxchkver_2_9_3 bool SetHelpLabel(const wxString& help);
> %wxchkver_2_9_3 bool SetHelpLabel(int help);
> %wxchkver_2_9_0 void SetMessage(const wxString& message);
> %wxchkver_2_9_0 bool SetOKCancelLabels(const wxString& ok, const wxString& cancel);
> %wxchkver_2_9_0 bool SetOKCancelLabels(int ok, int cancel);
> %wxchkver_2_9_0 bool SetOKLabel(const wxString& ok);
> %wxchkver_2_9_0 bool SetOKLabel(int ok);
> %wxchkver_2_9_0 bool SetYesNoCancelLabels(const wxString& yes, const wxString& no, const wxString& cancel);
> %wxchkver_2_9_0 bool SetYesNoCancelLabels(int yes, int no, int cancel);
> %wxchkver_2_9_0 bool SetYesNoLabels(const wxString& yes, const wxString& no);
> %wxchkver_2_9_0 bool SetYesNoLabels(int yes, int no);
> %wxchkver_2_9_3 wxString GetCaption() const;
> %wxchkver_2_9_0 wxString GetMessage() const;
> %wxchkver_2_9_0 wxString GetExtendedMessage() const;
> %wxchkver_2_9_0 long GetMessageDialogStyle() const;
> %wxchkver_2_9_0 bool HasCustomLabels() const;
> %wxchkver_2_9_0 wxString GetYesLabel() const;
> %wxchkver_2_9_0 wxString GetOKLabel() const;
> %wxchkver_2_9_0 wxString GetNoLabel() const;
> %wxchkver_2_9_0 wxString GetCancelLabel() const;
> %wxchkver_2_9_3 wxString GetHelpLabel() const;
> %wxchkver_2_9_3 long GetEffectiveIcon() const;

};
#endif //wxLUA_USE_wxMessageDialog && wxUSE_MSGDLG
// ---------------------------------------------------------------------------
// wxMultiChoiceDialog - use wxGetMultipleChoices
#if wxUSE_CHOICEDLG && wxLUA_USE_wxMultiChoiceDialog
class wxMultiChoiceDialog : public wxDialog
{

> wxMultiChoiceDialog(wxWindow* parent, const wxString& message, const wxString& caption, const wxArrayString& choices, long style = wxCHOICEDLG_STYLE, const wxPoint& pos = wxDefaultPosition );
> wxArrayInt GetSelections() const; // FIXME
> void SetSelections(const wxArrayInt& selections) const; // FIXME
> //int ShowModal() - in wxDialog

};
#endif //wxUSE_CHOICEDLG && wxLUA_USE_wxMultiChoiceDialog
// ---------------------------------------------------------------------------
// wxSingleChoiceDialog - use wxGetSingleChoice or wxGetSingleChoiceIndex
#if wxUSE_CHOICEDLG && wxLUA_USE_wxSingleChoiceDialog
class wxSingleChoiceDialog : public wxDialog
{

> // %override wxSingleChoiceDialog(wxWindow* parent, const wxString& message, const wxString& caption, const wxArrayString& choices, long style = wxCHOICEDLG_STYLE, const wxPoint& pos = wxDefaultPosition );
> // C++ Func: wxSingleChoiceDialog(wxWindow* parent, const wxString& message, const wxString& caption, const wxArrayString& choices, void** clientData = NULL, long style = wxCHOICEDLG_STYLE, const wxPoint& pos = wxDefaultPosition );
> wxSingleChoiceDialog(wxWindow* parent, const wxString& message, const wxString& caption, const wxArrayString& choices, long style = wxCHOICEDLG_STYLE, const wxPoint& pos = wxDefaultPosition );
> int GetSelection() const;
> wxString GetStringSelection() const;
> void SetSelection(int selection) const;
> // int ShowModal() - in wxDialog

};
#endif //wxUSE_CHOICEDLG && wxLUA_USE_wxSingleChoiceDialog
// ---------------------------------------------------------------------------
// wxTextEntryDialog - see also wxGetTextFromUser
#if wxUSE_TEXTDLG && wxLUA_USE_wxTextEntryDialog
#define wxTextEntryDialogStyle
class wxTextEntryDialog : public wxDialog
{

> wxTextEntryDialog(wxWindow* parent, const wxString& message, const wxString& caption = "Please enter text", const wxString& defaultValue = "", long style = wxOK | wxCANCEL | wxCENTRE, const wxPoint& pos = wxDefaultPosition );
> wxString GetValue() const;
> void SetValue(const wxString& value );
> // int ShowModal() - in wxDialog

};
// ---------------------------------------------------------------------------
// wxPasswordEntryDialog - see also wxGetPasswordFromUser
%wxchkver_2_9_0 #define_string wxGetPasswordFromUserPromptStr
!%wxchkver_2_9_0 #define_wxstring wxGetPasswordFromUserPromptStr
#define wxTextEntryDialogStyle
class wxPasswordEntryDialog : public wxTextEntryDialog
{

> wxPasswordEntryDialog(wxWindow *parent, const wxString& message, const wxString& caption = wxGetPasswordFromUserPromptStr, const wxString& value = "", long style = wxTextEntryDialogStyle, const wxPoint& pos = wxDefaultPosition );

};
#endif //wxUSE_TEXTDLG && wxLUA_USE_wxTextEntryDialog
// ---------------------------------------------------------------------------
// wxFontDialog
#if wxUSE_FONTDLG && wxLUA_USE_wxFontDialog
#include "wx/fontdlg.h"
class wxFontDialog : public wxDialog
{

> wxFontDialog(wxWindow* parent, const wxFontData& data );
> wxFontData& GetFontData( );
> // int ShowModal() - in wxDialog

};
// ---------------------------------------------------------------------------
// wxFontData - for wxFontDialog
#include "wx/cmndata.h"
class %delete wxFontData : public wxObject
{

> wxFontData( );
> wxFontData(const wxFontData& data );
> void EnableEffects(bool enable );
> bool GetAllowSymbols( );
> wxColour GetColour( );
> wxFont GetChosenFont( );
> bool GetEnableEffects( );
> wxFont GetInitialFont( );
> bool GetShowHelp( );
> void SetAllowSymbols(bool allowSymbols );
> void SetChosenFont(const wxFont &font );
> void SetColour(const wxColour &colour );
> void SetInitialFont(const wxFont &font );
> void SetRange(int minimum, int maximum );
> void SetShowHelp(bool showHelp );

};
#endif //wxUSE_FONTDLG && wxLUA_USE_wxFontDialog
// ---------------------------------------------------------------------------
// wxFindReplaceDialog
#if wxUSE_FINDREPLDLG && wxLUA_USE_wxFindReplaceDialog
#include "wx/fdrepdlg.h"
enum wxFindReplaceDialogStyles
{

> wxFR_REPLACEDIALOG,
> wxFR_NOUPDOWN,
> wxFR_NOMATCHCASE,
> wxFR_NOWHOLEWORD

};
class wxFindReplaceDialog : public wxDialog
{

> wxFindReplaceDialog( );
> wxFindReplaceDialog(wxWindow *parent, wxFindReplaceData *findData, const wxString &title, int style = 0 );
> bool Create(wxWindow *parent, wxFindReplaceData *findData, const wxString &title, int style = 0 );
> const wxFindReplaceData *GetData( );
> void SetData(wxFindReplaceData *findData );

};
// ---------------------------------------------------------------------------
// wxFindReplaceData - Note this must exist while used in a wxFindReplaceDialog
// and you should delete() it only when the dialog is closed.
enum wxFindReplaceFlags
{

> wxFR_DOWN,
> wxFR_WHOLEWORD,
> wxFR_MATCHCASE

};
class %delete wxFindReplaceData : public wxObject
{

> wxFindReplaceData(int flags = 0 );
> wxString GetFindString( );
> wxString GetReplaceString( );
> int GetFlags( );
> void SetFlags(int flags );
> void SetFindString(const wxString& string );
> void SetReplaceString(const wxString& string );

};
// ---------------------------------------------------------------------------
// wxFindDialogEvent
class %delete wxFindDialogEvent : public wxCommandEvent
{

> %wxEventType wxEVT_COMMAND_FIND // EVT_FIND(id, fn );
> %wxEventType wxEVT_COMMAND_FIND_NEXT // EVT_FIND_NEXT(id, fn );
> %wxEventType wxEVT_COMMAND_FIND_REPLACE // EVT_FIND_REPLACE(id, fn );
> %wxEventType wxEVT_COMMAND_FIND_REPLACE_ALL // EVT_FIND_REPLACE_ALL(id, fn );
> %wxEventType wxEVT_COMMAND_FIND_CLOSE // EVT_FIND_CLOSE(id, fn );
> wxFindDialogEvent(wxEventType commandType = wxEVT_NULL, int id = 0 );
> int GetFlags( );
> wxString GetFindString( );
> wxString GetReplaceString( );
> wxFindReplaceDialog *GetDialog( );
> void SetFlags(int flags );
> void SetFindString(const wxString& str );
> void SetReplaceString(const wxString& str );

};
#endif //wxUSE_FINDREPLDLG && wxLUA_USE_wxFindReplaceDialog
// ---------------------------------------------------------------------------
// wxProgressDialog
#if wxUSE_PROGRESSDLG && wxLUA_USE_wxProgressDialog
#include "wx/progdlg.h"
#define wxPD_APP_MODAL
#define wxPD_AUTO_HIDE
#define wxPD_SMOOTH
#define wxPD_CAN_ABORT
#define wxPD_CAN_SKIP
#define wxPD_ELAPSED_TIME
#define wxPD_ESTIMATED_TIME
#define wxPD_REMAINING_TIME
class wxProgressDialog : public wxDialog
{

> wxProgressDialog(const wxString& title, const wxString& message, int maximum = 100, wxWindow* parent = NULL, int style = wxPD_AUTO_HIDE | wxPD_APP_MODAL );
> void Resume( );
> // %override [bool, bool skip] Update(int value, const wxString& newmsg = "" );
> // C++ Func: bool Update(int value, const wxString& newmsg = "", bool* skip = NULL );
> bool Update(int value, const wxString& newmsg = "" );

};
#endif //wxUSE_PROGRESSDLG && wxLUA_USE_wxProgressDialog
// ---------------------------------------------------------------------------
// wxTabbedDialog deprecated; use wxNotebook instead
//
// #include "wx/wxtab.h"
// class wxTabbedDialog : public wxDialog
// {
// wxTabbedDialog(wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style=wxDEFAULT_DIALOG_STYLE, const wxString& name = "wxTabbedDialog" );
// void SetTabView(wxTabView *view );
// wxTabView * GetTabView( );
// };

## wxwidgets/wxcore_event.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxEvent and other generic event classes and types
// events specific to a single control are with that control
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// Note: wxEvtHandler and wxEvent in wxBase bindings.
// ---------------------------------------------------------------------------
// wxPropagationDisabler
#include "wx/event.h"
class %delete wxPropagationDisabler
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxPropagationDisabler(wxEvent& event );

};
// ---------------------------------------------------------------------------
// wxPropagateOnce
#include "wx/event.h"
class %delete wxPropagateOnce
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxPropagateOnce(wxEvent& event );

};
// ---------------------------------------------------------------------------
// wxCommandEvent
#include "wx/event.h"
%wxchkver_2_4 #include "wx/tglbtn.h" // for wxEVT_COMMAND_TOGGLEBUTTON_CLICKED
class %delete wxCommandEvent : public wxEvent
{

> %wxEventType wxEVT_NULL // dummy placeholder nobody sends this event
> %wxEventType wxEVT_COMMAND_ENTER // EVT_COMMAND_ENTER(winid, func );
> %wxEventType wxEVT_COMMAND_KILL_FOCUS // EVT_COMMAND_KILL_FOCUS(winid, func );
> %wxEventType wxEVT_COMMAND_LEFT_CLICK // EVT_COMMAND_LEFT_CLICK(winid, func );
> %wxEventType wxEVT_COMMAND_LEFT_DCLICK // EVT_COMMAND_LEFT_DCLICK(winid, func );
> %wxEventType wxEVT_COMMAND_RIGHT_CLICK // EVT_COMMAND_RIGHT_CLICK(winid, func );
> %wxEventType wxEVT_COMMAND_RIGHT_DCLICK // EVT_COMMAND_RIGHT_DCLICK(winid, func );
> //%wxEventType wxEVT_COMMAND_SCROLLBAR_UPDATED // EVT_SCROLLBAR(winid, func) obsolete use wxEVT_SCROLL...
> %wxEventType wxEVT_COMMAND_SET_FOCUS // EVT_COMMAND_SET_FOCUS(winid, func );
> //%wxEventType wxEVT_COMMAND_VLBOX_SELECTED // EVT_VLBOX(winid, func) unused?
> %wxEventType wxEVT_COMMAND_MENU_SELECTED // EVT_MENU(winid, func) EVT_MENU_RANGE(id1, id2, func );
> %wxEventType wxEVT_COMMAND_TOOL_CLICKED // EVT_TOOL(winid, func) EVT_TOOL_RANGE(id1, id2, func );
> %wxEventType wxEVT_COMMAND_TOOL_ENTER // EVT_TOOL_ENTER(winid, func );
> %wxEventType wxEVT_COMMAND_TOOL_RCLICKED // EVT_TOOL_RCLICKED(winid, func) EVT_TOOL_RCLICKED_RANGE(id1, id2, func );
> %wxEventType wxEVT_COMMAND_TEXT_ENTER // EVT_TEXT_ENTER(id, fn );
> %wxEventType wxEVT_COMMAND_TEXT_UPDATED // EVT_TEXT(id, fn );
> %wxEventType wxEVT_COMMAND_TEXT_MAXLEN // EVT_TEXT_MAXLEN(id, fn );
> !%wxchkver_2_8_0 %wxEventType wxEVT_COMMAND_TEXT_URL // EVT_TEXT_URL(id, fn );
> %wxEventType wxEVT_COMMAND_SPINCTRL_UPDATED // EVT_SPINCTRL(id, fn );
> %wxEventType wxEVT_COMMAND_SLIDER_UPDATED // EVT_SLIDER(winid, func );
> %wxEventType wxEVT_COMMAND_RADIOBUTTON_SELECTED // EVT_RADIOBUTTON(winid, func );
> %wxEventType wxEVT_COMMAND_RADIOBOX_SELECTED // EVT_RADIOBOX(winid, func );
> %wxEventType wxEVT_COMMAND_CHECKLISTBOX_TOGGLED // EVT_CHECKLISTBOX(winid, func );
> %wxEventType wxEVT_COMMAND_LISTBOX_DOUBLECLICKED // EVT_LISTBOX_DCLICK(winid, func );
> %wxEventType wxEVT_COMMAND_LISTBOX_SELECTED // EVT_LISTBOX(winid, func );
> %wxEventType wxEVT_COMMAND_COMBOBOX_SELECTED // EVT_COMBOBOX(winid, func );
> %wxEventType wxEVT_COMMAND_CHOICE_SELECTED // EVT_CHOICE(winid, func );
> %wxEventType wxEVT_COMMAND_CHECKBOX_CLICKED // EVT_CHECKBOX(winid, func );
> %wxEventType wxEVT_COMMAND_BUTTON_CLICKED // EVT_BUTTON(winid, func );
> %wxchkver_2_4 %wxEventType wxEVT_COMMAND_TOGGLEBUTTON_CLICKED // EVT_TOGGLEBUTTON(id, fn );
> wxCommandEvent(wxEventType commandEventType = wxEVT_NULL, int id = 0 );
> voidptr_long GetClientData(); // C++ returns (void *) You get a number here
> wxClientData* GetClientObject( );
> %rename GetStringClientObject wxStringClientData* GetClientObject( );
> long GetExtraLong( );
> int GetInt( );
> int GetSelection( );
> wxString GetString( );
> bool IsChecked() const;
> bool IsSelection( );
> void SetClientData(voidptr_long number); // C++ is (void *clientData) You can put a number here
> void SetExtraLong(int extraLong );
> void SetInt(int intCommand );
> void SetString(const wxString &string );

};
// ---------------------------------------------------------------------------
// wxNotifyEvent
#include "wx/event.h"
class %delete wxNotifyEvent : public wxCommandEvent
{

> wxNotifyEvent(wxEventType eventType = wxEVT_NULL, int id = 0 );
> void Allow( );
> bool IsAllowed() const;
> void Veto( );

};
// ---------------------------------------------------------------------------
// wxActivateEvent
#include "wx/event.h"
class %delete wxActivateEvent : public wxEvent
{

> %wxEventType wxEVT_ACTIVATE // EVT_ACTIVATE(func );
> %wxEventType wxEVT_ACTIVATE_APP // EVT_ACTIVATE_APP(func );
> %wxEventType wxEVT_HIBERNATE // EVT_HIBERNATE(func );
> wxActivateEvent(wxEventType eventType = wxEVT_NULL, bool active = true, int id = 0 );
> bool GetActive() const;

};
// ---------------------------------------------------------------------------
// wxCloseEvent
#include "wx/event.h"
class %delete wxCloseEvent : public wxEvent
{

> %wxEventType wxEVT_CLOSE_WINDOW // EVT_CLOSE(func );
> %wxEventType wxEVT_QUERY_END_SESSION // EVT_QUERY_END_SESSION(func );
> %wxEventType wxEVT_END_SESSION // EVT_END_SESSION(func );
> wxCloseEvent(wxEventType commandEventType = wxEVT_NULL, int id = 0 );
> bool CanVeto( );
> bool GetLoggingOff() const;
> void SetCanVeto(bool canVeto );
> void SetLoggingOff(bool loggingOff) const;
> void Veto(bool veto = true );

};
// ---------------------------------------------------------------------------
// wxDialUpEvent - TODO - the rest of wxDialUp is missing, anyone care?
//#if !%mac
//%include "wx/dialup.h"
//class %delete wxDialUpEvent : public wxCommandEvent
//{
// %wxEventType wxEVT_DIALUP_CONNECTED // EVT_DIALUP_CONNECTED(func );
// %wxEventType wxEVT_DIALUP_DISCONNECTED // EVT_DIALUP_DISCONNECTED(func );
// wxDialUpEvent(bool isConnected, bool isOwnEvent );
// bool IsConnectedEvent() const;
// bool IsOwnEvent() const;
//};
//#endif
// ---------------------------------------------------------------------------
// wxEraseEvent
#include "wx/event.h"
class %delete wxEraseEvent : public wxEvent
{

> %wxEventType wxEVT_ERASE_BACKGROUND // EVT_ERASE_BACKGROUND(func );
> wxEraseEvent(int id = 0, wxDC* dc = NULL );
> wxDC* GetDC() const;

};
// ---------------------------------------------------------------------------
// wxFocusEvent
#include "wx/event.h"
class %delete wxFocusEvent : public wxEvent
{

> %wxEventType wxEVT_SET_FOCUS // EVT_SET_FOCUS(func );
> %wxEventType wxEVT_KILL_FOCUS // EVT_KILL_FOCUS(func );
> wxFocusEvent(wxEventType eventType = wxEVT_NULL, int id = 0 );
> wxWindow* GetWindow( );
> void SetWindow(wxWindow *win );

};
// ---------------------------------------------------------------------------
// wxChildFocusEvent
#include "wx/event.h"
class %delete wxChildFocusEvent : public wxCommandEvent
{

> %wxEventType wxEVT_CHILD_FOCUS // EVT_CHILD_FOCUS(func );
> wxChildFocusEvent(wxWindow *win = NULL );
> wxWindow *GetWindow() const;

};
// ---------------------------------------------------------------------------
// wxQueryNewPaletteEvent
#include "wx/event.h"
class %delete wxQueryNewPaletteEvent : public wxEvent
{

> %wxEventType wxEVT_QUERY_NEW_PALETTE // EVT_QUERY_NEW_PALETTE(func );
> wxQueryNewPaletteEvent(wxWindowID winid = 0 );
> void SetPaletteRealized(bool realized );
> bool GetPaletteRealized() const;

};
// ---------------------------------------------------------------------------
// wxPaletteChangedEvent
#include "wx/event.h"
class %delete wxPaletteChangedEvent : public wxEvent
{

> %wxEventType wxEVT_PALETTE_CHANGED // EVT_PALETTE_CHANGED(func );
> wxPaletteChangedEvent(wxWindowID winid = 0 );
> void SetChangedWindow(wxWindow* win );
> wxWindow* GetChangedWindow() const;

};
// ---------------------------------------------------------------------------
// wxKeyEvent
enum wxKeyCode
{

> WXK_ADD,
> WXK_ALT,
> WXK_BACK,
> WXK_CANCEL,
> WXK_CAPITAL,
> WXK_CLEAR,
> WXK_CONTROL,
> WXK_DECIMAL,
> WXK_DELETE,
> WXK_DIVIDE,
> WXK_DOWN,
> WXK_END,
> WXK_ESCAPE,
> WXK_EXECUTE,
> WXK_F1,
> WXK_F10,
> WXK_F11,
> WXK_F12,
> WXK_F13,
> WXK_F14,
> WXK_F15,
> WXK_F16,
> WXK_F17,
> WXK_F18,
> WXK_F19,
> WXK_F2,
> WXK_F20,
> WXK_F21,
> WXK_F22,
> WXK_F23,
> WXK_F24,
> WXK_F3,
> WXK_F4,
> WXK_F5,
> WXK_F6,
> WXK_F7,
> WXK_F8,
> WXK_F9,
> WXK_HELP,
> WXK_HOME,
> WXK_INSERT,
> WXK_LBUTTON,
> WXK_LEFT,
> WXK_MBUTTON,
> WXK_MENU,
> WXK_MULTIPLY,
> //WXK_NEXT = WXK_PAGEDOWN since 2.6
> WXK_NUMLOCK,
> WXK_NUMPAD_ADD,
> WXK_NUMPAD_BEGIN,
> WXK_NUMPAD_DECIMAL,
> WXK_NUMPAD_DELETE,
> WXK_NUMPAD_DIVIDE,
> WXK_NUMPAD_DOWN,
> WXK_NUMPAD_END,
> WXK_NUMPAD_ENTER,
> WXK_NUMPAD_EQUAL,
> WXK_NUMPAD_F1,
> WXK_NUMPAD_F2,
> WXK_NUMPAD_F3,
> WXK_NUMPAD_F4,
> WXK_NUMPAD_HOME,
> WXK_NUMPAD_INSERT,
> WXK_NUMPAD_LEFT,
> WXK_NUMPAD_MULTIPLY,
> // WXK_NUMPAD_NEXT = WXK_NUMPAD_PAGEDOWN since 2.6
> WXK_NUMPAD_PAGEDOWN,
> WXK_NUMPAD_PAGEUP,
> // WXK_NUMPAD_PRIOR = WXK_NUMPAD_PAGEUP since 2.6
> WXK_NUMPAD_RIGHT,
> WXK_NUMPAD_SEPARATOR,
> WXK_NUMPAD_SPACE,
> WXK_NUMPAD_SUBTRACT,
> WXK_NUMPAD_TAB,
> WXK_NUMPAD_UP,
> WXK_NUMPAD0,
> WXK_NUMPAD1,
> WXK_NUMPAD2,
> WXK_NUMPAD3,
> WXK_NUMPAD4,
> WXK_NUMPAD5,
> WXK_NUMPAD6,
> WXK_NUMPAD7,
> WXK_NUMPAD8,
> WXK_NUMPAD9,
> WXK_PAGEDOWN,
> WXK_PAGEUP,
> WXK_PAUSE,
> WXK_PRINT,
> // WXK_PRIOR = WXK_PAGEUP since 2.6
> WXK_RBUTTON,
> WXK_RETURN,
> WXK_RIGHT,
> WXK_SCROLL,
> WXK_SELECT,
> WXK_SEPARATOR,
> WXK_SHIFT,
> WXK_SNAPSHOT,
> WXK_SPACE,
> WXK_START,
> WXK_SUBTRACT,
> WXK_TAB,
> WXK_UP

};
#include "wx/event.h"
class %delete wxKeyEvent : public wxEvent
{

> %wxEventType wxEVT_KEY_DOWN // EVT_KEY_DOWN(func );
> %wxEventType wxEVT_KEY_UP // EVT_KEY_UP(func );
> %wxEventType wxEVT_CHAR // EVT_CHAR(func );
> %wxEventType wxEVT_CHAR_HOOK // EVT_CHAR_HOOK(func );
> wxUSE_HOTKEY %wxEventType wxEVT_HOTKEY // EVT_HOTKEY(winid, func );
> wxKeyEvent(wxEventType keyEventType );
> bool AltDown() const;
> bool CmdDown() const;
> bool ControlDown() const;
> int GetKeyCode() const;
> %wxchkver_2_8 int GetModifiers() const;
> wxPoint GetPosition() const;
> // %override [long x, long y] wxKeyEvent::GetPositionXY( );
> // C++ Func: void GetPosition(long *x, long *y) const;
> %rename GetPositionXY void GetPosition() const;
> //wxUint32 GetRawKeyCode() const;
> //wxUint32 GetRawKeyFlags() const;
> //wxChar GetUnicodeKey() const;
> long GetX( );
> long GetY() const;
> bool HasModifiers() const;
> bool MetaDown() const;
> bool ShiftDown() const;

};
// ---------------------------------------------------------------------------
// wxNavigationKeyEvent
#include "wx/event.h"
enum wxNavigationKeyEvent::dummy
{

> IsBackward,
> IsForward,
> WinChange,
> FromTab

};
class %delete wxNavigationKeyEvent : public wxEvent
{

> %wxEventType wxEVT_NAVIGATION_KEY // EVT_NAVIGATION_KEY(func );
> wxNavigationKeyEvent( );
> bool GetDirection() const;
> void SetDirection(bool bForward );
> bool IsWindowChange() const;
> void SetWindowChange(bool bIs );
> bool IsFromTab() const;
> void SetFromTab(bool bIs );
> wxWindow* GetCurrentFocus() const;
> void SetCurrentFocus(wxWindow *win );
> void SetFlags(long flags );

};
// ---------------------------------------------------------------------------
// wxIdleEvent
#include "wx/event.h"
enum wxIdleMode
{

> wxIDLE_PROCESS_ALL,
> wxIDLE_PROCESS_SPECIFIED

};
class %delete wxIdleEvent : public wxEvent
{

> %wxEventType wxEVT_IDLE // EVT_IDLE(func );
> wxIdleEvent( );
> !%wxchkver_2_9_2 static bool CanSend(wxWindow* window );
> static wxIdleMode GetMode( );
> void RequestMore(bool needMore = true );
> bool MoreRequested() const;
> static void SetMode(wxIdleMode mode );

};
// ---------------------------------------------------------------------------
// wxInitDialogEvent - for dialogs and panels
#include "wx/event.h"
class %delete wxInitDialogEvent : public wxEvent
{

> %wxEventType wxEVT_INIT_DIALOG // EVT_INIT_DIALOG(func );
> wxInitDialogEvent(int id = 0 );

};
// ---------------------------------------------------------------------------
// wxContextMenuEvent
class %delete wxContextMenuEvent : public wxCommandEvent
{

> %wxEventType wxEVT_CONTEXT_MENU // EVT_CONTEXT_MENU(func) EVT_COMMAND_CONTEXT_MENU(winid, func );
> wxContextMenuEvent(wxEventType type = wxEVT_NULL, wxWindowID winid = 0, const wxPoint& pt = wxDefaultPosition );
> //wxContextMenuEvent(const wxContextMenuEvent& event );
> wxPoint GetPosition() const;
> void SetPosition(const wxPoint& pos );

};
// ---------------------------------------------------------------------------
// wxMouseEvent
#include "wx/event.h"
enum
{
wxMOUSE_BTN_ANY,
wxMOUSE_BTN_NONE,
wxMOUSE_BTN_LEFT,
wxMOUSE_BTN_MIDDLE,
wxMOUSE_BTN_RIGHT
};
class %delete wxMouseEvent : public wxEvent
{

> %wxEventType wxEVT_ENTER_WINDOW // EVT_ENTER_WINDOW(func );
> %wxEventType wxEVT_LEAVE_WINDOW // EVT_LEAVE_WINDOW(func );
> %wxEventType wxEVT_LEFT_DCLICK // EVT_LEFT_DCLICK(func );
> %wxEventType wxEVT_LEFT_DOWN // EVT_LEFT_DOWN(func );
> %wxEventType wxEVT_LEFT_UP // EVT_LEFT_UP(func );
> %wxEventType wxEVT_MIDDLE_DCLICK // EVT_MIDDLE_DCLICK(func );
> %wxEventType wxEVT_MIDDLE_DOWN // EVT_MIDDLE_DOWN(func );
> %wxEventType wxEVT_MIDDLE_UP // EVT_MIDDLE_UP(func );
> %wxEventType wxEVT_MOTION // EVT_MOTION(func );
> %wxEventType wxEVT_MOUSEWHEEL // EVT_MOUSEWHEEL(func );
> %wxEventType wxEVT_RIGHT_DCLICK // EVT_RIGHT_DCLICK(func );
> %wxEventType wxEVT_RIGHT_DOWN // EVT_RIGHT_DOWN(func );
> %wxEventType wxEVT_RIGHT_UP // EVT_RIGHT_UP(func );
> //%wxEventType wxEVT_NC_ENTER_WINDOW // FIXME - these are not used in wxWidgets
> //%wxEventType wxEVT_NC_LEAVE_WINDOW
> //%wxEventType wxEVT_NC_LEFT_DCLICK
> //%wxEventType wxEVT_NC_LEFT_DOWN
> //%wxEventType wxEVT_NC_LEFT_UP
> //%wxEventType wxEVT_NC_MIDDLE_DCLICK
> //%wxEventType wxEVT_NC_MIDDLE_DOWN
> //%wxEventType wxEVT_NC_MIDDLE_UP
> //%wxEventType wxEVT_NC_MOTION
> //%wxEventType wxEVT_NC_RIGHT_DCLICK
> //%wxEventType wxEVT_NC_RIGHT_DOWN
> //%wxEventType wxEVT_NC_RIGHT_UP
> wxMouseEvent(wxEventType mouseEventType = wxEVT_NULL );
> bool AltDown( );
> bool Button(int button );
> bool ButtonDClick(int but = wxMOUSE_BTN_ANY );
> bool ButtonDown(int but = wxMOUSE_BTN_ANY );
> bool ButtonUp(int but = wxMOUSE_BTN_ANY );
> bool CmdDown() const;
> bool ControlDown( );
> bool Dragging( );
> bool Entering( );
> wxPoint GetPosition() const;
> // %override [long x, long y] wxMouseEvent::GetPositionXY( );
> // C++ Func: void GetPosition(wxCoord* x, wxCoord* y) const;
> %rename GetPositionXY void GetPosition() const;
> wxPoint GetLogicalPosition(const wxDC& dc) const;
> int GetLinesPerAction() const;
> int GetWheelRotation() const;
> int GetWheelDelta() const;
> long GetX() const;
> long GetY( );
> bool IsButton() const;
> bool Leaving() const;
> bool LeftDClick() const;
> bool LeftDown() const;
> bool LeftIsDown() const;
> bool LeftUp() const;
> bool MetaDown() const;
> bool MiddleDClick() const;
> bool MiddleDown() const;
> bool MiddleIsDown() const;
> bool MiddleUp() const;
> bool Moving() const;
> bool RightDClick() const;
> bool RightDown() const;
> bool RightIsDown() const;
> bool RightUp() const;
> bool ShiftDown() const;

};
// ---------------------------------------------------------------------------
// wxMouseCaptureChangedEvent
#include "wx/event.h"
class %delete wxMouseCaptureChangedEvent : public wxEvent
{

> %wxEventType wxEVT_MOUSE_CAPTURE_CHANGED // EVT_MOUSE_CAPTURE_CHANGED(func );
> wxMouseCaptureChangedEvent(wxWindowID winid = 0, wxWindow* gainedCapture = NULL );
> wxWindow* GetCapturedWindow() const;

};
// ---------------------------------------------------------------------------
// wxMouseCaptureLostEvent
#if %wxchkver_2_8
#include "wx/event.h"
class %delete wxMouseCaptureLostEvent : public wxEvent
{

> %wxEventType wxEVT_MOUSE_CAPTURE_LOST // EVT_MOUSE_CAPTURE_LOST(func );
> wxMouseCaptureLostEvent(wxWindowID winid = 0 );

};
#endif //%wxchkver_2_8
// ---------------------------------------------------------------------------
// wxMoveEvent
#include "wx/event.h"
class %delete wxMoveEvent : public wxEvent
{

> %wxEventType wxEVT_MOVE // EVT_MOVE(func );
> %wxchkver_2_6 %wxEventType wxEVT_MOVING // EVT_MOVING(func );
> wxMoveEvent(const wxPoint& pt, int id = 0 );
> wxPoint GetPosition() const;

};
// ---------------------------------------------------------------------------
// wxPaintEvent -
//
// Note: You must ALWAYS create a wxPaintDC for the window and delete() when
// done to have the exposed area marked as painted, otherwise you'll continue
// to get endless paint events.
// Tip: local dc = wx.wxPaintDC(event:GetEventObject():DynamicCast("wxWindow") );
// do stuff with dc...
// dc:delete() -- Absolutely necessary since the garbage collector may
// -- not immediatelly run.
#include "wx/event.h"
class %delete wxPaintEvent : public wxEvent
{

> %wxEventType wxEVT_PAINT // EVT_PAINT(func );
> wxPaintEvent(int id = 0 );

};
// ---------------------------------------------------------------------------
// wxNcPaintEvent - this is not sent from anything in wxWidgets
//#include "wx/event.h"
//class %delete wxNcPaintEvent : public wxEvent
//{
// %wxEventType wxEVT_NC_PAINT // EVT_NC_PAINT(func );
// wxNcPaintEvent(int winid = 0 );
//};
// ---------------------------------------------------------------------------
// wxProcessEvent
#include "wx/process.h"
class %delete wxProcessEvent : public wxEvent
{

> %wxEventType wxEVT_END_PROCESS // EVT_END_PROCESS(id, func );
> !%wxchkver_2_6 wxProcessEvent(int id = 0, int pid = 0 );
> %wxchkver_2_6 wxProcessEvent(int nId = 0, int pid = 0, int exitcode = 0 );
> int GetPid() const;
> %wxchkver_2_6 int GetExitCode( );

};
// ---------------------------------------------------------------------------
// wxScrollEvent - for independent scrollbars and sliders
#include "wx/event.h"
class %delete wxScrollEvent : public wxCommandEvent
{

> %wxEventType wxEVT_SCROLL_TOP // EVT_SCROLL_TOP(func );
> %wxEventType wxEVT_SCROLL_BOTTOM // EVT_SCROLL_BOTTOM(func );
> %wxEventType wxEVT_SCROLL_LINEUP // EVT_SCROLL_LINEUP(func );
> %wxEventType wxEVT_SCROLL_LINEDOWN // EVT_SCROLL_LINEDOWN(func );
> %wxEventType wxEVT_SCROLL_PAGEUP // EVT_SCROLL_PAGEUP(func );
> %wxEventType wxEVT_SCROLL_PAGEDOWN // EVT_SCROLL_PAGEDOWN(func );
> %wxEventType wxEVT_SCROLL_THUMBTRACK // EVT_SCROLL_THUMBTRACK(func );
> %wxEventType wxEVT_SCROLL_THUMBRELEASE // EVT_SCROLL_THUMBRELEASE(func );
> %wxcompat_2_6 %wxEventType wxEVT_SCROLL_ENDSCROLL // EVT_SCROLL_ENDSCROLL(func) FIXME called wxEVT_SCROLL_CHANGED in 2.8
> %wxchkver_2_8 %wxEventType wxEVT_SCROLL_CHANGED // EVT_SCROLL_CHANGED(func );
> wxScrollEvent(wxEventType commandType = wxEVT_NULL, int id = 0, int pos = 0, int orientation = 0 );
> int GetOrientation() const;
> int GetPosition() const;

};
// ---------------------------------------------------------------------------
// wxScrollWinEvent - for wxScrolledWindows only
#include "wx/event.h"
class %delete wxScrollWinEvent : public wxEvent
{

> %wxEventType wxEVT_SCROLLWIN_BOTTOM // EVT_SCROLLWIN_BOTTOM(func );
> %wxEventType wxEVT_SCROLLWIN_LINEDOWN // EVT_SCROLLWIN_LINEDOWN(func );
> %wxEventType wxEVT_SCROLLWIN_LINEUP // EVT_SCROLLWIN_LINEUP(func );
> %wxEventType wxEVT_SCROLLWIN_PAGEDOWN // EVT_SCROLLWIN_PAGEDOWN(func );
> %wxEventType wxEVT_SCROLLWIN_PAGEUP // EVT_SCROLLWIN_PAGEUP(func );
> %wxEventType wxEVT_SCROLLWIN_THUMBRELEASE // EVT_SCROLLWIN_THUMBRELEASE(func );
> %wxEventType wxEVT_SCROLLWIN_THUMBTRACK // EVT_SCROLLWIN_THUMBTRACK(func );
> %wxEventType wxEVT_SCROLLWIN_TOP // EVT_SCROLLWIN_TOP(func );
> wxScrollWinEvent(wxEventType commandType = wxEVT_NULL, int pos = 0, int orientation = 0 );
> int GetOrientation() const;
> int GetPosition() const;

};
// ---------------------------------------------------------------------------
// wxSizeEvent
#include "wx/event.h"
class %delete wxSizeEvent : public wxEvent
{

> %wxEventType wxEVT_SIZE // EVT_SIZE(func );
> %wxchkver_2_6 %wxEventType wxEVT_SIZING // EVT_SIZING(func );
> wxSizeEvent(const wxSize& sz, int id = 0 );
> wxSize GetSize() const;

};
// ---------------------------------------------------------------------------
// wxShowEvent
#include "wx/event.h"
class %delete wxShowEvent : public wxEvent
{

> %wxEventType wxEVT_SHOW // EVT_SHOW(func );
> wxShowEvent(int winid = 0, bool show = false );
> void SetShow(bool show );
> bool GetShow() const;

};
// ---------------------------------------------------------------------------
// wxIconizeEvent
#include "wx/event.h"
class %delete wxIconizeEvent : public wxEvent
{

> %wxEventType wxEVT_ICONIZE // EVT_ICONIZE(func );
> wxIconizeEvent(int winid = 0, bool iconized = true );
> bool Iconized() const;

};
// ---------------------------------------------------------------------------
// wxMaximizeEvent
#include "wx/event.h"
class %delete wxMaximizeEvent : public wxEvent
{

> %wxEventType wxEVT_MAXIMIZE // EVT_MAXIMIZE(func );
> wxMaximizeEvent(int winid = 0 );

};
// ---------------------------------------------------------------------------
// wxWindowCreateEvent
#include "wx/event.h"
class %delete wxWindowCreateEvent : public wxEvent
{

> %wxEventType wxEVT_CREATE // EVT_WINDOW_CREATE(func );
> wxWindowCreateEvent(wxWindow *win = NULL );
> wxWindow *GetWindow() const;

};
// ---------------------------------------------------------------------------
// wxWindowDestroyEvent
#include "wx/event.h"
class %delete wxWindowDestroyEvent : public wxEvent
{

> %wxEventType wxEVT_DESTROY // EVT_WINDOW_DESTROY(func );
> wxWindowDestroyEvent(wxWindow *win = NULL );
> wxWindow *GetWindow() const;

};
// ---------------------------------------------------------------------------
// wxSysColourChangedEvent
#include "wx/event.h"
class %delete wxSysColourChangedEvent : public wxEvent
{

> %wxEventType wxEVT_SYS_COLOUR_CHANGED // EVT_SYS_COLOUR_CHANGED(func );
> wxSysColourChangedEvent( );

};
// ---------------------------------------------------------------------------
// wxDisplayChangedEvent
#include "wx/event.h"
class %delete wxDisplayChangedEvent : public wxEvent
{

> %wxEventType wxEVT_DISPLAY_CHANGED // EVT_DISPLAY_CHANGED(func );
> wxDisplayChangedEvent( );

};
// ---------------------------------------------------------------------------
// wxPowerEvent
#if %wxchkver_2_8
#include "wx/power.h"
enum wxPowerType
{

> wxPOWER_SOCKET,
> wxPOWER_BATTERY,
> wxPOWER_UNKNOWN

};
enum wxBatteryState
{

> wxBATTERY_NORMAL_STATE, // system is fully usable
> wxBATTERY_LOW_STATE, // start to worry
> wxBATTERY_CRITICAL_STATE, // save quickly
> wxBATTERY_SHUTDOWN_STATE, // too late
> wxBATTERY_UNKNOWN_STATE

};
wxPowerType wxGetPowerType( );
wxBatteryState wxGetBatteryState( );
#if wxHAS_POWER_EVENTS
class %delete wxPowerEvent : public wxEvent
{

> %wxEventType wxEVT_POWER_SUSPENDING // EVT_POWER_SUSPENDING(func );
> %wxEventType wxEVT_POWER_SUSPENDED // EVT_POWER_SUSPENDED(func );
> %wxEventType wxEVT_POWER_SUSPEND_CANCEL // EVT_POWER_SUSPEND_CANCEL(func );
> %wxEventType wxEVT_POWER_RESUME // EVT_POWER_RESUME(func );
> wxPowerEvent(wxEventType evtType );
> void Veto( );
> bool IsVetoed() const;

};
#endif // wxHAS_POWER_EVENTS
#endif // %wxchkver_2_8
// ---------------------------------------------------------------------------
// wxSetCursorEvent
#include "wx/event.h"
class %delete wxSetCursorEvent : public wxEvent
{

> %wxEventType wxEVT_SET_CURSOR // EVT_SET_CURSOR(func );
> wxSetCursorEvent(wxCoord x = 0, wxCoord y = 0 );
> wxCoord GetX() const;
> wxCoord GetY() const;
> void SetCursor(const wxCursor& cursor );
> wxCursor GetCursor() const;
> bool HasCursor() const;

};
// ---------------------------------------------------------------------------
// wxUpdateUIEvent
#include "wx/event.h"
enum wxUpdateUIMode
{

> wxUPDATE_UI_PROCESS_ALL,
> wxUPDATE_UI_PROCESS_SPECIFIED

};
class %delete wxUpdateUIEvent : public wxCommandEvent
{

> %wxEventType wxEVT_UPDATE_UI // EVT_UPDATE_UI(winid, func) EVT_UPDATE_UI_RANGE(id1, id2, func );
> wxUpdateUIEvent(wxWindowID commandId = wxID_ANY );
> static bool CanUpdate(wxWindow* window );
> void Check(bool check );
> void Enable(bool enable );
> bool GetChecked() const;
> bool GetEnabled() const;
> %wxchkver_2_8 bool GetShown() const;
> bool GetSetChecked() const;
> bool GetSetEnabled() const;
> %wxchkver_2_8 bool GetSetShown() const;
> bool GetSetText() const;
> wxString GetText() const;
> static wxUpdateUIMode GetMode( );
> static long GetUpdateInterval( );
> static void ResetUpdateTime( );
> static void SetMode(wxUpdateUIMode mode );
> void SetText(const wxString& text );
> static void SetUpdateInterval(long updateInterval );
> %wxchkver_2_8 void Show(bool show );

};
// ---------------------------------------------------------------------------
// wxHelpEvent
#include "wx/event.h"
#if %wxchkver_2_8
enum wxHelpEvent::Origin
{

> Origin_Unknown, // unrecognized event source
> Origin_Keyboard, // event generated from F1 key press
> Origin_HelpButton // event from [?] button on the title bar (Windows );

};
#endif //%wxchkver_2_8
class %delete wxHelpEvent : public wxCommandEvent
{

> %wxEventType wxEVT_HELP // EVT_HELP(winid, func) EVT_HELP_RANGE(id1, id2, func );
> %wxEventType wxEVT_DETAILED_HELP // EVT_DETAILED_HELP(winid, func) EVT_DETAILED_HELP_RANGE(id1, id2, func );
> !%wxchkver_2_8 wxHelpEvent(wxEventType type = wxEVT_NULL, wxWindowID id = 0, const wxPoint& pt = wxDefaultPosition );
> %wxchkver_2_8 wxHelpEvent(wxEventType type = wxEVT_NULL, wxWindowID id = 0, const wxPoint& pt = wxDefaultPosition, wxHelpEvent::Origin origin = wxHelpEvent::Origin_Unknown );
> wxString GetLink( );
> %wxchkver_2_8 wxHelpEvent::Origin GetOrigin() const;
> wxPoint GetPosition( );
> wxString GetTarget( );
> void SetLink(const wxString& link );
> %wxchkver_2_8 void SetOrigin(wxHelpEvent::Origin origin );
> void SetPosition(const wxPoint& pos );
> void SetTarget(const wxString& target );

};

## wxwidgets/wxcore_gdi.i - Lua table = 'wx'

// ===========================================================================
// Purpose: GDI classes, Colour, Pen, Brush, Font, DC, Bitmap...
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxPoint
#if wxLUA_USE_wxPointSizeRect
#include "wx/gdicmn.h"
#define wxDefaultCoord
#define_object wxPoint wxDefaultPosition
class %delete wxPoint
{

> //#define_object wxDefaultPosition
> wxPoint(int x = 0, int y = 0 );
> wxPoint(const wxPoint& pt );
> // %override [int x, int y] wxPoint::GetXY( );
> // wxLua added function
> int GetXY() const;
> // %override void wxPoint::Set(int x, int y );
> // wxLua added function
> void Set(int x, int y );
> %rename X %member_func int x; // GetX() and SetX(int x );
> %rename Y %member_func int y; // GetY() and SetY(int y );
> wxPoint& operator=(const wxPoint& p) const;
> bool operator==(const wxPoint& p) const; //{ return x == p.x && y == p.y; }
> bool operator!=(const wxPoint& p) const; //{ return !(*this == p); }
> // arithmetic operations (component wise );
> wxPoint operator+(const wxPoint& p) const; //{ return wxPoint(x + p.x, y + p.y); }
> wxPoint operator-(const wxPoint& p) const; //{ return wxPoint(x - p.x, y - p.y); }
> wxPoint& operator+=(const wxPoint& p); //{ x += p.x; y += p.y; return *this; }
> wxPoint& operator-=(const wxPoint& p); //{ x -= p.x; y -= p.y; return *this; }
> wxPoint& operator+=(const wxSize& s); //{ x += s.GetWidth(); y += s.GetHeight(); return *this; }
> wxPoint& operator-=(const wxSize& s); //{ x -= s.GetWidth(); y -= s.GetHeight(); return *this; }
> wxPoint operator+(const wxSize& s) const; //{ return wxPoint(x + s.GetWidth(), y + s.GetHeight()); }
> wxPoint operator-(const wxSize& s) const; //{ return wxPoint(x - s.GetWidth(), y - s.GetHeight()); }
> wxPoint operator-() const; //{ return wxPoint(-x, -y); }

};
// ---------------------------------------------------------------------------
// wxPointList
//#if %wxchkver_2_9
//class %delete wxPointList : public wxList
//{
// wxPointList( );
//};
//#endif
// ---------------------------------------------------------------------------
// wxRealPoint - Used nowhere in wxWidgets
//class %delete wxRealPoint
//{
// wxRealPoint(double xx = 0, double yy = 0 );
//
// %rename X double x; // GetX() and SetX(int x );
// %rename Y double y; // GetY() and SetY(int y );
//};
// ---------------------------------------------------------------------------
// wxSize
class %delete wxSize
{

> #define_object wxDefaultSize
> wxSize(int width = 0, int height = 0 );
> wxSize(const wxSize& size );
> %wxchkver_2_8 void DecBy(int dx, int dy );
> //%wxchkver_2_8 void DecBy(const wxSize& sz );
> //%wxchkver_2_8 void DecBy(int d );
> void DecTo(const wxSize& sz );
> bool IsFullySpecified() const;
> int GetHeight() const;
> int GetWidth() const;
> %wxchkver_2_8 void IncBy(int dx, int dy );
> //%wxchkver_2_8 void IncBy(const wxSize& sz );
> //%wxchkver_2_8 void IncBy(int d );
> void IncTo(const wxSize& sz );
> %wxchkver_2_8 wxSize& Scale(float xscale, float yscale );
> void Set(int width, int height );
> void SetDefaults(const wxSize& size );
> void SetHeight(int height );
> void SetWidth(int width );
> wxSize& operator=(const wxSize& s) const;
> bool operator==(const wxSize& sz) const; //{ return x == sz.x && y == sz.y; }
> bool operator!=(const wxSize& sz) const; //{ return x != sz.x || y != sz.y; }
> wxSize operator+(const wxSize& sz) const; //{ return wxSize(x + sz.x, y + sz.y); }
> wxSize operator-(const wxSize& sz) const; //{ return wxSize(x - sz.x, y - sz.y); }
> wxSize operator/(int i) const; //{ return wxSize(x / i, y / i); }
> wxSize operator*(int i) const; //{ return wxSize(x * i, y * i); }
> wxSize& operator+=(const wxSize& sz); //{ x += sz.x; y += sz.y; return *this; }
> wxSize& operator-=(const wxSize& sz); //{ x -= sz.x; y -= sz.y; return *this; }
> wxSize& operator/=(const int i); //{ x /= i; y /= i; return *this; }
> wxSize& operator*=(const int i); //{ x *= i; y *= i; return *this; }

};
// ---------------------------------------------------------------------------
// wxRect
class %delete wxRect
{

> wxRect(int x = 0, int y = 0, int w = 0, int h = 0 );
> wxRect(const wxRect& rect );
> wxRect(const wxPoint& topLeft, const wxPoint& bottomRight );
> wxRect(const wxPoint& pos, const wxSize& size );
> wxRect(const wxSize& size );
> #if %wxchkver_2_8
> wxRect CentreIn(const wxRect& r, int dir = wxBOTH) const; // CenterIn
> bool Contains(wxCoord dx, wxCoord dy) const;
> bool Contains(const wxPoint& pt) const;
> bool Contains(const wxRect& rect) const;
> #endif // %wxchkver_2_8
> wxRect Deflate(wxCoord dx, wxCoord dy) const; //wxRect& Deflate(wxCoord dx, wxCoord dy );
> int GetBottom( );
> int GetHeight( );
> int GetLeft( );
> wxPoint GetPosition( );
> wxPoint GetTopLeft() const; // GetLeftTop
> %wxchkver_2_8 wxPoint GetTopRight() const; // GetRightTop
> wxPoint GetBottomRight() const; // GetRightBottom
> %wxchkver_2_8 wxPoint GetBottomLeft() const; // GetLeftBottom
> int GetRight( );
> wxSize GetSize( );
> int GetTop( );
> int GetWidth( );
> int GetX( );
> int GetY( );
> wxRect Inflate(wxCoord dx, wxCoord dy) const; //wxRect& Inflate(wxCoord dx, wxCoord dy );
> %wxcompat_2_6 bool Inside(wxCoord cx, wxCoord cy );
> bool Intersects(const wxRect& rect) const;
> bool IsEmpty() const;
> void Offset(wxCoord dx, wxCoord dy); //void Offset(const wxPoint& pt );
> void SetBottom(int bottom );
> void SetHeight(int height );
> void SetLeft(int left );
> void SetPosition(const wxPoint &p );
> %wxchkver_2_8 void SetBottomLeft(const wxPoint &p); // SetLeftBottom
> void SetBottomRight(const wxPoint &p); // SetRightBottom
> void SetRight(int right );
> void SetSize(const wxSize &s );
> void SetTop(int top );
> %wxchkver_2_8 void SetTopRight(const wxPoint &p); // SetRightTop
> void SetWidth(int width );
> void SetX(int X );
> void SetY(int Y );
> wxRect Union(const wxRect& rect) const; //wxRect& Union(const wxRect& rect);
> wxRect& operator=(const wxRect& r) const;
> bool operator==(const wxRect& rect) const;
> wxRect operator+(const wxRect& rect) const;
> wxRect& operator+=(const wxRect& rect );

};
#endif //wxLUA_USE_wxPointSizeRect
// ---------------------------------------------------------------------------
// wxGDIObject
class %delete wxGDIObject : public wxObject
{

> //wxGDIObject() - base class, no constructor since it doesn't do anything
> //bool GetVisible() these are NOT USED and have been removed in 2.7
> //void SetVisible(bool visible );
> bool IsNull( );

};
// ---------------------------------------------------------------------------
// wxRegion
#if wxLUA_USE_wxRegion
#include "wx/region.h"
enum wxRegionContain
{

> wxOutRegion,
> wxPartRegion,
> wxInRegion

};
#if defined(wxHAS_REGION_COMBINE); // MSW and MAC
enum wxRegionOp
{

> wxRGN_AND, // Creates the intersection of the two combined regions.
> wxRGN_COPY, // Creates a copy of the region
> wxRGN_DIFF, // Combines the parts of first region that are not in the second one
> wxRGN_OR, // Creates the union of two combined regions.
> wxRGN_XOR // Creates the union of two regions except for any overlapping areas.

};
#define wxHAS_REGION_COMBINE 1
#endif // defined(wxHAS_REGION_COMBINE );
class %delete wxRegion : public wxGDIObject
{

> wxRegion(long x = 0, long y = 0, long width = 0, long height = 0 );
> wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight );
> // wxRegion(const wxPoint& pos, const wxSize& size );
> wxRegion(const wxRect& rect );
> wxRegion(const wxRegion& region );
> void Clear( );
> #if defined(wxHAS_REGION_COMBINE); // MSW and MAC
> bool Combine(wxCoord x, wxCoord y, wxCoord w, wxCoord h, wxRegionOp op);
> bool Combine(const wxRect& rect, wxRegionOp op);
> bool Combine(const wxRegion& region, wxRegionOp op );
> #endif // defined(wxHAS_REGION_COMBINE );
> wxRegionContain Contains(long x, long y );
> wxRegionContain Contains(const wxPoint& pt );
> wxRegionContain Contains(const wxRect& rect );
> wxRegionContain Contains(long x, long y, long w, long h );
> wxBitmap ConvertToBitmap() const;
> wxRect GetBox() const;
> // %override [int x, int y, int width, int height] wxRegion::GetBoxXYWH( );
> // C++ Func: void GetBox(int &x, int &y, int &width, int &height );
> %rename GetBoxXYWH void GetBox( );
> bool Intersect(long x, long y, long width, long height );
> bool Intersect(const wxRect& rect );
> bool Intersect(const wxRegion& region );
> bool IsEmpty() const;
> %wxchkver_2_8 bool IsEqual(const wxRegion& region) const;
> %wxchkver_2_8 bool Ok() const;
> bool Subtract(long x, long y, long width, long height );
> bool Subtract(const wxRect& rect );
> bool Subtract(const wxRegion& region );
> bool Offset(wxCoord x, wxCoord y );
> bool Union(long x, long y, long width, long height );
> bool Union(const wxRect& rect );
> bool Union(const wxRegion& region );
> bool Union(const wxBitmap& bmp );
> bool Union(const wxBitmap& bmp, const wxColour& transColour, int tolerance = 0 );
> bool Xor(long x, long y, long width, long height );
> bool Xor(const wxRect& rect );
> bool Xor(const wxRegion& region );
> wxRegion& operator=(const wxRegion& r) const;
> // operator == just calls IsEqual( );

};
// ---------------------------------------------------------------------------
// wxRegionIterator
class %delete wxRegionIterator : public wxObject
{

> wxRegionIterator(const wxRegion& region );
> long GetX( );
> long GetY( );
> long GetWidth(); // long GetW( );
> long GetHeight(); // long GetH( );
> wxRect GetRect( );
> bool HaveRects( );
> void Reset( );
> // %override wxRegionIterator::Next() is ++ operator
> // This is a wxLua added function.
> void Next(); // operator++

};
#endif //wxLUA_USE_wxRegion
// ---------------------------------------------------------------------------
// wxFont
#if wxLUA_USE_wxFont
#include "wx/font.h"
enum
{
wxDEFAULT, // these are deprecated use wxFONTFAMILY_XXX
wxDECORATIVE,
wxROMAN,
wxSCRIPT,
wxSWISS,
wxMODERN,
wxTELETYPE,
wxVARIABLE, // unused ?
wxFIXED, // unused ?
wxNORMAL,
wxLIGHT,
wxBOLD,
wxITALIC,
wxSLANT
};
enum wxFontFamily
{

> wxFONTFAMILY_DEFAULT,
> wxFONTFAMILY_DECORATIVE,
> wxFONTFAMILY_ROMAN,
> wxFONTFAMILY_SCRIPT,
> wxFONTFAMILY_SWISS,
> wxFONTFAMILY_MODERN,
> wxFONTFAMILY_TELETYPE,
> wxFONTFAMILY_MAX,
> wxFONTFAMILY_UNKNOWN

};
enum wxFontStyle
{

> wxFONTSTYLE_NORMAL,
> wxFONTSTYLE_ITALIC,
> wxFONTSTYLE_SLANT,
> wxFONTSTYLE_MAX

};
enum wxFontWeight
{

> wxFONTWEIGHT_NORMAL,
> wxFONTWEIGHT_LIGHT,
> wxFONTWEIGHT_BOLD,
> wxFONTWEIGHT_MAX

};
enum
{
wxFONTFLAG_DEFAULT,
wxFONTFLAG_ITALIC,
wxFONTFLAG_SLANT,
wxFONTFLAG_LIGHT,
wxFONTFLAG_BOLD,
wxFONTFLAG_ANTIALIASED,
wxFONTFLAG_NOT_ANTIALIASED,
wxFONTFLAG_UNDERLINED,
wxFONTFLAG_STRIKETHROUGH,
wxFONTFLAG_MASK
};
class %delete wxFont : public wxGDIObject
{

> // Note: use wxNullFont as the object for static functions
> #define_object wxNullFont
> %rename wxNORMAL_FONT #define_pointer wxLua_wxNORMAL_FONT // hack for wxWidgets >2.7
> %rename wxSMALL_FONT #define_pointer wxLua_wxSMALL_FONT
> %rename wxITALIC_FONT #define_pointer wxLua_wxITALIC_FONT
> %rename wxSWISS_FONT #define_pointer wxLua_wxSWISS_FONT
> //wxFont(int pointSize, wxFontFamily family, int style, wxFontWeight weight, const bool underline = false, const wxString& faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT );
> wxFont(int pointSize, int family, int style, int weight, const bool underline = false, const wxString& faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT );
> wxFont(const wxFont& font );
> bool IsFixedWidth() const;
> static wxFontEncoding GetDefaultEncoding( );
> wxString GetFaceName() const;
> int GetFamily() const;
> wxString GetNativeFontInfoDesc() const;
> int GetPointSize() const;
> int GetStyle() const;
> bool GetUnderlined() const;
> int GetWeight() const;
> static %gc wxFont* New(int pointSize, wxFontFamily family, int style, wxFontWeight weight, const bool underline = false, const wxString& faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT );
> static %gc wxFont* New(int pointSize, wxFontFamily family, int flags = wxFONTFLAG_DEFAULT, const wxString& faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT );
> static %gc wxFont* New(const wxSize& pixelSize, wxFontFamily family, int style, wxFontWeight weight, const bool underline = false, const wxString& faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT );
> static %gc wxFont* New(const wxSize& pixelSize, wxFontFamily family, int flags = wxFONTFLAG_DEFAULT, const wxString& faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT );
> bool Ok( );
> static void SetDefaultEncoding(wxFontEncoding encoding );
> %not_overload !%wxchkver_2_8 void SetFaceName(const wxString& faceName );
> %not_overload %wxchkver_2_8 bool SetFaceName(const wxString& faceName );
> void SetFamily(int family );
> %not_overload !%wxchkver_2_8 void SetNativeFontInfo(const wxString& info );
> %not_overload %wxchkver_2_8 bool SetNativeFontInfo(const wxString& info );
> %wxchkver_2_8 bool SetNativeFontInfoUserDesc(const wxString& info );
> void SetPointSize(int pointSize );
> void SetStyle(int style );
> void SetUnderlined(const bool underlined );
> void SetWeight(int weight );
> wxFont& operator=(const wxFont& f) const;
> bool operator == (const wxFont& font) const;

};
// ---------------------------------------------------------------------------
// wxNativeFontInfo
#include "wx/fontutil.h"
class %delete wxNativeFontInfo
{

> wxNativeFontInfo( );
> wxNativeFontInfo(const wxNativeFontInfo& info );
> // accessors and modifiers for the font elements
> int GetPointSize() const;
> %msw wxSize GetPixelSize() const; // FIXME wxWidgets has undefined symbol in gtk/mac
> wxFontStyle GetStyle() const;
> wxFontWeight GetWeight() const;
> bool GetUnderlined() const;
> wxString GetFaceName() const;
> wxFontFamily GetFamily() const;
> wxFontEncoding GetEncoding() const;
> void SetPointSize(int pointsize );
> %msw void SetPixelSize(const wxSize& pixelSize );
> void SetStyle(wxFontStyle style );
> void SetWeight(wxFontWeight weight );
> void SetUnderlined(bool underlined );
> %wxchkver_2_8 bool SetFaceName(const wxString& facename );
> !%wxchkver_2_8 void SetFaceName(const wxString& facename );
> void SetFamily(wxFontFamily family );
> void SetEncoding(wxFontEncoding encoding );
> // sets the first facename in the given array which is found
> // to be valid. If no valid facename is given, sets the
> // first valid facename returned by wxFontEnumerator::GetFacenames().
> // Does not return a bool since it cannot fail.
> %wxchkver_2_8 void SetFaceName(const wxArrayString& facenames );
> // it is important to be able to serialize wxNativeFontInfo objects to be
> // able to store them (in config file, for example );
> bool FromString(const wxString& s);
> wxString ToString() const;
> // we also want to present the native font descriptions to the user in some
> // human-readable form (it is not platform independent neither, but can
> // hopefully be understood by the user );
> bool FromUserString(const wxString& s );
> wxString ToUserString() const;

};
#endif //wxLUA_USE_wxFont
// ---------------------------------------------------------------------------
// wxFontEnumerator
#if wxLUA_USE_wxFontEnumerator
#include "wx/fontenum.h"
class %delete wxFontEnumerator
{

> wxFontEnumerator( );
> virtual bool EnumerateFacenames( wxFontEncoding encoding = wxFONTENCODING_SYSTEM, bool fixedWidthOnly = false );
> virtual bool EnumerateEncodings( const wxString &font = "" );
> %wxchkver_2_8 static wxArrayString GetEncodings(const wxString& facename = "" );
> %wxchkver_2_8 static wxArrayString GetFacenames(wxFontEncoding encoding = wxFONTENCODING_SYSTEM, bool fixedWidthOnly = false );
> !%wxchkver_2_8 wxArrayString* GetEncodings( );
> !%wxchkver_2_8 wxArrayString* GetFacenames( );
> // Use GetEncodings/Facenames after calling EnumerateXXX
> //virtual bool OnFacename(const wxString& facename );
> //virtual bool OnFontEncoding(const wxString& facename, const wxString& encoding );

};
#endif //wxLUA_USE_wxFontEnumerator
// ---------------------------------------------------------------------------
// wxFontList
#if wxLUA_USE_wxFontList
class wxFontList
{

> #define_pointer wxTheFontList
> // No constructor, use wxTheFontList
> // Note: we don't gc the returned font as the list will delete it
> wxFont* FindOrCreateFont(int pointSize, int family, int style, int weight, bool underline = false, const wxString &faceName = "", wxFontEncoding encoding = wxFONTENCODING_DEFAULT );
> // Only use FindOrCreateFont - others deprecated in >2.7
> //void AddFont(wxFont* font );
> //void RemoveFont(wxFont* font );

};
#endif //wxLUA_USE_wxFontList
// ---------------------------------------------------------------------------
// wxFontMapper
#if wxLUA_USE_wxFontMapper
#include "wx/fontmap.h"
class wxFontMapper
{

> // No constructor, use static Get() function
> wxFontEncoding CharsetToEncoding(const wxString &charset, bool interactive = true );
> static wxFontMapper *Get( );
> // %override [bool, wxFontEncoding *altEncoding] wxFontMapper::GetAltForEncoding(wxFontEncoding encoding, const wxString &faceName = "", bool interactive = true );
> // C++ Func: bool GetAltForEncoding(wxFontEncoding encoding, wxFontEncoding *altEncoding, const wxString &faceName = "", bool interactive = true );
> bool GetAltForEncoding(wxFontEncoding encoding, const wxString &faceName = "", bool interactive = true );
> // This function is really for wxWidgets internal use
> // %rename GetAltForEncodingInternal bool GetAltForEncoding(wxFontEncoding encoding, wxNativeEncodingInfo *info, const wxString &faceName = "", bool interactive = true );
> static wxString GetDefaultConfigPath( );
> static wxFontEncoding GetEncoding(size_t n );
> static wxString GetEncodingDescription(wxFontEncoding encoding );
> static wxFontEncoding GetEncodingFromName(const wxString& encoding );
> static wxString GetEncodingName(wxFontEncoding encoding );
> static size_t GetSupportedEncodingsCount( );
> bool IsEncodingAvailable(wxFontEncoding encoding, const wxString &facename = "" );
> %wxchkver_2_8 static void Reset( );
> void SetDialogParent(wxWindow *parent );
> void SetDialogTitle(const wxString &title );
> //static wxFontMapper *Set(wxFontMapper *mapper); // wxLua probably doesn't need this
> !%wxchkver_2_8 void SetConfig(wxConfigBase *config = NULL );
> void SetConfigPath(const wxString &prefix );

};
#endif //wxLUA_USE_wxFontMapper
// ---------------------------------------------------------------------------
// wxColour
#if wxLUA_USE_wxColourPenBrush
#include "wx/colour.h"
#include "wx/gdicmn.h"
#if %wxchkver_2_8
#define wxC2S_NAME // return colour name, when possible
#define wxC2S_CSS_SYNTAX // return colour in rgb(r,g,b) syntax
#define wxC2S_HTML_SYNTAX // return colour in #rrggbb syntax
#define wxALPHA_TRANSPARENT
#define wxALPHA_OPAQUE
#endif // %wxchkver_2_8
class %delete wxColour : public wxGDIObject
{

> #define_object wxNullColour
> %rename wxBLACK #define_pointer wxLua_wxBLACK // hack for wxWidgets >2.7 wxStockGDI::GetColour
> %rename wxWHITE #define_pointer wxLua_wxWHITE
> %rename wxRED #define_pointer wxLua_wxRED
> %rename wxBLUE #define_pointer wxLua_wxBLUE
> %rename wxGREEN #define_pointer wxLua_wxGREEN
> %rename wxCYAN #define_pointer wxLua_wxCYAN
> %rename wxLIGHT_GREY #define_pointer wxLua_wxLIGHT_GREY
> !%wxchkver_2_8 wxColour(unsigned char red, unsigned char green, unsigned char blue );
> %wxchkver_2_8 wxColour(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha = wxALPHA_OPAQUE );
> wxColour(const wxString& colourName );
> wxColour(const wxColour& colour );
> %wxchkver_2_8 unsigned char Alpha() const;
> unsigned char Blue() const;
> %wxchkver_2_8 virtual wxString GetAsString(long flags = wxC2S_NAME | wxC2S_CSS_SYNTAX) const;
> !%mac long GetPixel() const;
> unsigned char Green() const;
> bool Ok() const;
> unsigned char Red() const;
> !%wxchkver_2_8 void Set(unsigned char red, unsigned char green, unsigned char blue );
> #if %wxchkver_2_8
> void Set(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha = wxALPHA_OPAQUE );
> bool Set(const wxString &str );
> void Set(unsigned long colRGB );
> #endif // %wxchkver_2_8
> wxColour& operator=(const wxColour& c) const;
> bool operator == (const wxColour& c) const;

};
// ---------------------------------------------------------------------------
// wxColourDatabase
class %delete wxColourDatabase
{

> wxColourDatabase( );
> wxColour Find(const wxString& name) const;
> wxString FindName(const wxColour& colour) const;
> void AddColour(const wxString& name, const wxColour& colour );

};
// ---------------------------------------------------------------------------
// wxPen
#include "wx/pen.h"
enum wxPenCap
{

> wxCAP_BUTT,
> wxCAP_PROJECTING,
> wxCAP_ROUND

};
enum wxPenStyle
{

> wxDOT,
> wxDOT_DASH,
> wxSOLID,
> wxLONG_DASH,
> wxSHORT_DASH,
> wxUSER_DASH

};
enum wxPenJoin
{

> wxJOIN_BEVEL,
> wxJOIN_MITER,
> wxJOIN_ROUND

};
enum
{
wxTRANSPARENT,
wxSTIPPLE_MASK_OPAQUE,
wxSTIPPLE_MASK,
wxSTIPPLE,
wxBDIAGONAL_HATCH,
wxCROSSDIAG_HATCH,
wxFDIAGONAL_HATCH,
wxCROSS_HATCH,
wxHORIZONTAL_HATCH,
wxVERTICAL_HATCH
};
class %delete wxPen : public wxGDIObject
{

> #define_object wxNullPen
> %rename wxRED_PEN #define_pointer wxLua_wxRED_PEN // hack for wxWidgets >2.7 wxStockGDI::GetPen
> %rename wxCYAN_PEN #define_pointer wxLua_wxCYAN_PEN
> %rename wxGREEN_PEN #define_pointer wxLua_wxGREEN_PEN
> %rename wxBLACK_PEN #define_pointer wxLua_wxBLACK_PEN
> %rename wxWHITE_PEN #define_pointer wxLua_wxWHITE_PEN
> %rename wxTRANSPARENT_PEN #define_pointer wxLua_wxTRANSPARENT_PEN
> %rename wxBLACK_DASHED_PEN #define_pointer wxLua_wxBLACK_DASHED_PEN
> %rename wxGREY_PEN #define_pointer wxLua_wxGREY_PEN
> %rename wxMEDIUM_GREY_PEN #define_pointer wxLua_wxMEDIUM_GREY_PEN
> %rename wxLIGHT_GREY_PEN #define_pointer wxLua_wxLIGHT_GREY_PEN
> wxPen( );
> wxPen(const wxColour& colour, int width, wxPenStyle style );
> wxPen(const wxString& colourName, int width, wxPenStyle style );
> %win wxPen(const wxBitmap& stipple, int width );
> wxPen(const wxPen& pen );
> wxPenCap GetCap() const;
> wxColour GetColour() const; // not wxColur& so we allocate a new one
> // int GetDashes(wxDash** dashes) const;
> wxPenJoin GetJoin() const;
> %win wxBitmap* GetStipple() const;
> wxPenStyle GetStyle() const;
> int GetWidth() const;
> bool Ok() const;
> void SetCap(wxPenCap capStyle );
> void SetColour(wxColour& colour );
> void SetColour(const wxString& colourName );
> void SetColour(unsigned char red, unsigned char green, unsigned char blue );
> //void SetDashes(int nb_dashes, const wxDash *dash );
> void SetJoin(wxPenJoin join_style );
> %win void SetStipple(const wxBitmap& stipple );
> void SetStyle(wxPenStyle style );
> void SetWidth(int width );
> wxPen& operator=(const wxPen& p) const;
> bool operator == (const wxPen& p) const;

};
// ---------------------------------------------------------------------------
// wxPenList
#if wxLUA_USE_wxPenList
class wxPenList //: public wxList - it's not really derived from a wxList
{

> #define_pointer wxThePenList
> // No constructor, use wxThePenList
> // Note: we don't gc the returned pen as the list will delete it
> wxPen* FindOrCreatePen(const wxColour& colour, int width, int style );

};
#endif //wxLUA_USE_wxPenList
// ---------------------------------------------------------------------------
// wxBrush
#include "wx/brush.h"
class %delete wxBrush : public wxGDIObject
{

> #define_object wxNullBrush
> %rename wxBLUE_BRUSH #define_pointer wxLua_wxBLUE_BRUSH // hack for wxWidgets >2.7 wxStockGDI::GetBrush
> %rename wxGREEN_BRUSH #define_pointer wxLua_wxGREEN_BRUSH
> %rename wxWHITE_BRUSH #define_pointer wxLua_wxWHITE_BRUSH
> %rename wxBLACK_BRUSH #define_pointer wxLua_wxBLACK_BRUSH
> %rename wxGREY_BRUSH #define_pointer wxLua_wxGREY_BRUSH
> %rename wxMEDIUM_GREY_BRUSH #define_pointer wxLua_wxMEDIUM_GREY_BRUSH
> %rename wxLIGHT_GREY_BRUSH #define_pointer wxLua_wxLIGHT_GREY_BRUSH
> %rename wxTRANSPARENT_BRUSH #define_pointer wxLua_wxTRANSPARENT_BRUSH
> %rename wxCYAN_BRUSH #define_pointer wxLua_wxCYAN_BRUSH
> %rename wxRED_BRUSH #define_pointer wxLua_wxRED_BRUSH
> wxBrush( );
> wxBrush(const wxColour& colour, int style );
> wxBrush(const wxString& colourName, int style );
> wxBrush(const wxBitmap& stippleBitmap );
> wxBrush(const wxBrush& brush );
> wxColour GetColour() const;
> wxBitmap* GetStipple() const;
> int GetStyle() const;
> bool IsHatch() const;
> bool Ok() const;
> void SetColour(wxColour& colour );
> void SetColour(const wxString& colourName );
> void SetColour(const unsigned char red, const unsigned char green, const unsigned char blue );
> void SetStipple(const wxBitmap& bitmap );
> void SetStyle(int style );
> wxBrush& operator=(const wxBrush& b) const;
> bool operator == (const wxBrush& b) const;

};
// ---------------------------------------------------------------------------
// wxBrushList
#if wxLUA_USE_wxBrushList
class wxBrushList // : public wxList - it's not really derived from it
{

> #define_pointer wxTheBrushList
> // No constructor, use wxTheBrushList
> // Note: we don't gc the returned brush as the list will delete it
> wxBrush* FindOrCreateBrush(const wxColour& colour, int style );
> // Use the wxList methods, see also wxNode
> //void AddBrush(wxBrush *brush) internal use for wxWidgets
> //void RemoveBrush(wxBrush *brush );

};
#endif //wxLUA_USE_wxBrushList
// ---------------------------------------------------------------------------
// wxStockGDI
#include "wx/gdicmn.h"
#if %wxchkver_2_8
enum wxStockGDI::Item
{

> BRUSH_BLACK,
> BRUSH_BLUE,
> BRUSH_CYAN,
> BRUSH_GREEN,
> BRUSH_GREY,
> BRUSH_LIGHTGREY,
> BRUSH_MEDIUMGREY,
> BRUSH_RED,
> BRUSH_TRANSPARENT,
> BRUSH_WHITE,
> COLOUR_BLACK,
> COLOUR_BLUE,
> COLOUR_CYAN,
> COLOUR_GREEN,
> COLOUR_LIGHTGREY,
> COLOUR_RED,
> COLOUR_WHITE,
> CURSOR_CROSS,
> CURSOR_HOURGLASS,
> CURSOR_STANDARD,
> FONT_ITALIC,
> FONT_NORMAL,
> FONT_SMALL,
> FONT_SWISS,
> PEN_BLACK,
> PEN_BLACKDASHED,
> PEN_CYAN,
> PEN_GREEN,
> PEN_GREY,
> PEN_LIGHTGREY,
> PEN_MEDIUMGREY,
> PEN_RED,
> PEN_TRANSPARENT,
> PEN_WHITE,
> ITEMCOUNT

};
class wxStockGDI
{

> //wxStockGDI() use instance to get the implemented wxStockGDI
> //static void DeleteAll( );
> static wxStockGDI& instance( );
> static const wxBrush* GetBrush(wxStockGDI::Item item );
> static const wxColour* GetColour(wxStockGDI::Item item );
> static const wxCursor* GetCursor(wxStockGDI::Item item );
> // Can be overridden by platform-specific derived classes
> virtual const wxFont* GetFont(wxStockGDI::Item item );
> static const wxPen* GetPen(wxStockGDI::Item item );

};
#endif // %wxchkver_2_8
#endif //wxLUA_USE_wxColourPenBrush
// ---------------------------------------------------------------------------
// wxPalette
#if wxLUA_USE_wxPalette && wxUSE_PALETTE
#include "wx/palette.h"
class %delete wxPalette : public wxGDIObject
{

> #define_object wxNullPalette
> wxPalette( );
> // wxPalette(int n, const unsigned char* red, const unsigned char* green, const unsigned char* blue) - use Create
> wxPalette(const wxPalette& palette );
> // %override bool wxPalette::Create(int n, Lua string red, Lua string green, Lua string blue );
> // C++ Func: bool Create(int n, const unsigned char* red, const unsigned char* green, const unsigned char* blue );
> bool Create(int n, const unsigned char* red, const unsigned char* green, const unsigned char* blue );
> int GetColoursCount() const;
> int GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
> // %override [bool, char red, char green, char blue] wxPalette::GetRGB(int pixel) const;
> // C++ Func: bool GetRGB(int pixel, unsigned char* red, unsigned char* green, unsigned char* blue) const;
> bool GetRGB(int pixel) const;
> bool Ok() const;

};
#endif //wxLUA_USE_wxPalette && wxUSE_PALETTE
// ---------------------------------------------------------------------------
// wxIcon
#if wxLUA_USE_wxIcon
typedef void* WXHANDLE
class %delete wxIcon : public wxGDIObject
{

> #define_object wxNullIcon
> wxIcon( );
> wxIcon(const wxString& name, wxBitmapType type, int desiredWidth = -1, int desiredHeight = -1 );
> //wxIcon(int width, int height, int depth = -1); // constructor does not exist
> %win|%mac|%wxchkver_2_6 void CopyFromBitmap(const wxBitmap& bmp );
> int GetDepth( );
> int GetHeight( );
> int GetWidth( );
> bool LoadFile(const wxString& name, wxBitmapType flags );
> bool Ok( );
> void SetDepth(int d );
> void SetHeight(int h );
> void SetWidth(int w );
> //%win void SetSize(const wxSize& size );
> wxIcon& operator=(const wxIcon& i) const;

};
// ---------------------------------------------------------------------------
// wxIconBundle
#include "wx/iconbndl.h"
class %delete wxIconBundle
{

> wxIconBundle( );
> wxIconBundle( const wxString& file, long type );
> wxIconBundle( const wxIcon& icon );
> wxIconBundle( const wxIconBundle& ic );
> void AddIcon( const wxString& file, long type );
> void AddIcon( const wxIcon& icon );
> wxIcon GetIcon( const wxSize& size ) const;
> // equivalent to GetIcon( wxSize( size, size ) );
> wxIcon GetIcon( int size = wxDefaultCoord ) const;

};
#endif //wxLUA_USE_wxIcon
// ---------------------------------------------------------------------------
// wxBitmap
#if wxLUA_USE_wxBitmap
#include "wx/bitmap.h"
//%win class %delete wxBitmapHandler // are these even necessary?
//{
//};
//%win class %delete wxGDIImageHandler
//{
//};
//%wxchkver_2_6&%win class wxGDIImageHandlerList : public wxList
//{
//};
class %delete wxBitmap : public wxGDIObject
{

> #define_object wxNullBitmap
> wxBitmap( );
> wxBitmap(const wxBitmap& bitmap );
> wxBitmap( int width, int height, int depth = -1 );
> wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_ANY );
> wxBitmap(const wxImage &image, int depth = -1 );
> // %override wxBitmap(lua string, int width, int height, int depth );
> // C++ Func: wxBitmap(const char bits[], int width, int height, int depth = 1 );
> // Creates a bitmap from an array of bits in the form of a Lua string.
> %override_name wxLua_wxBitmapFromBits_constructor wxBitmap(const char* mono_bits, int width, int height, int depth /* = 1 */);
> // %override wxBitmap(LuaTable charTable, int width, int height, int depth );
> // C++ Func: wxBitmap(const char bits[], int width, int height, int depth = 1 );
> // Creates a bitmap from an array of chars in a Lua table.
> %override_name wxLua_wxBitmapFromBitTable_constructor wxBitmap(LuaTable charTable, int width, int height, int depth /* = 1 */);
> // %override wxBitmap(LuaTable stringTable where each index is a row in the image );
> // C++ Func: wxBitmap(const char **data) Load from XPM
> %override_name wxLua_wxBitmapFromXPMData_constructor wxBitmap(LuaTable charTable );
> // %override wxBitmap(Lua string of data, int type, int width, int height, int depth = -1 );
> // C++ Func: wxBitmap(const void* data, int type, int width, int height, int depth = -1 );
> %override_name wxLua_wxBitmapFromData_constructor %win wxBitmap(const wxString& data, int type, int width, int height, int depth /* = -1 */ );
> //%win static void AddHandler(wxBitmapHandler* handler );
> //%win static void CleanUpHandlers( );
> wxImage ConvertToImage( );
> bool CopyFromIcon(const wxIcon& icon );
> virtual bool Create(int width, int height, int depth = -1 );
> //static wxBitmapHandler* FindHandler(const wxString& name );
> //static wxBitmapHandler* FindHandler(const wxString& extension, wxBitmapType bitmapType );
> //static wxBitmapHandler* FindHandler(wxBitmapType bitmapType );
> int GetDepth() const;
> //%wxchkver_2_6&%win static wxGDIImageHandlerList& GetHandlers( );
> //!%wxchkver_2_6&%win static wxList& GetHandlers( );
> int GetHeight() const;
> wxPalette* GetPalette() const;
> wxMask* GetMask() const;
> wxBitmap GetSubBitmap(const wxRect&rect) const;
> int GetWidth() const;
> //%win static void InitStandardHandlers( );
> //%win static void InsertHandler(wxBitmapHandler* handler );
> bool LoadFile(const wxString& name, wxBitmapType type );
> bool Ok() const;
> !%msw&%wxchkver_2_8 virtual wxColour QuantizeColour(const wxColour& colour) const; // msw doesn't derive from wxBitmapBase
> //%win static bool RemoveHandler(const wxString& name );
> bool SaveFile(const wxString& name, wxBitmapType type, wxPalette* palette = NULL );
> void SetDepth(int depth );
> void SetHeight(int height );
> void SetMask(%ungc wxMask* mask );
> %win void SetPalette(const wxPalette& palette );
> void SetWidth(int width );
> wxBitmap& operator=(const wxBitmap& b) const;

};
#endif //wxLUA_USE_wxBitmap
// ---------------------------------------------------------------------------
// wxCursor
#if wxLUA_USE_wxCursor
//typedef void* WXHANDLE
#include "wx/cursor.h"
enum wxStockCursor
{

> wxCURSOR_NONE,
> wxCURSOR_ARROW,
> wxCURSOR_RIGHT_ARROW,
> wxCURSOR_BULLSEYE,
> wxCURSOR_CHAR,
> wxCURSOR_CROSS,
> wxCURSOR_HAND,
> wxCURSOR_IBEAM,
> wxCURSOR_LEFT_BUTTON,
> wxCURSOR_MAGNIFIER,
> wxCURSOR_MIDDLE_BUTTON,
> wxCURSOR_NO_ENTRY,
> wxCURSOR_PAINT_BRUSH,
> wxCURSOR_PENCIL,
> wxCURSOR_POINT_LEFT,
> wxCURSOR_POINT_RIGHT,
> wxCURSOR_QUESTION_ARROW,
> wxCURSOR_RIGHT_BUTTON,
> wxCURSOR_SIZENESW,
> wxCURSOR_SIZENS,
> wxCURSOR_SIZENWSE,
> wxCURSOR_SIZEWE,
> wxCURSOR_SIZING,
> wxCURSOR_SPRAYCAN,
> wxCURSOR_WAIT,
> wxCURSOR_WATCH,
> wxCURSOR_BLANK,
> wxCURSOR_DEFAULT,
> %mac wxCURSOR_COPY_ARROW,
> #if defined(__X__ );
> // Not yet implemented for Windows
> wxCURSOR_CROSS_REVERSE,
> wxCURSOR_DOUBLE_ARROW,
> wxCURSOR_BASED_ARROW_UP,
> wxCURSOR_BASED_ARROW_DOWN,
> #endif // X11
> wxCURSOR_ARROWWAIT,
> wxCURSOR_MAX

};
class %delete wxCursor : public wxObject // wxObject in gtk, wxGDIImage in msw, wxBitmap in osx
{

> #define_object wxNullCursor
> %rename wxSTANDARD_CURSOR #define_pointer wxLua_wxSTANDARD_CURSOR // hack for wxWidgets >2.7
> %rename wxHOURGLASS_CURSOR #define_pointer wxLua_wxHOURGLASS_CURSOR
> %rename wxCROSS_CURSOR #define_pointer wxLua_wxCROSS_CURSOR
> wxCursor( );
> wxCursor(int id );
> wxCursor(const wxImage& image );
> #if %wxchkver_2_9_0
> wxCursor(const wxString& cursorName, wxBitmapType type, int hotSpotX = 0, int hotSpotY = 0 );
> #endif
> #if !%wxchkver_2_9_0 && __UNICODE__ && (%win || %mac );
> // There is a version that takes a const char[] as the first param that
> // gives an error about ambiguous overloads if wxString is ANSI.
> wxCursor(const wxString& cursorName, long type, int hotSpotX = 0, int hotSpotY = 0 );
> #endif
> bool Ok( );
> %win int GetWidth( );
> %win int GetHeight( );
> %win int GetDepth( );
> //%win void SetWidth(int width );
> //%win void SetHeight(int height );
> //%win void SetDepth(int depth );
> //%win void SetSize(const wxSize& size );
> wxCursor& operator=(const wxCursor& c) const;

};
#endif //wxLUA_USE_wxCursor
// ---------------------------------------------------------------------------
// wxMask
#if wxLUA_USE_wxMask
#include "wx/bitmap.h"
class %delete wxMask : public wxObject
{

> wxMask( );
> wxMask(const wxBitmap& bitmap );
> wxMask(const wxBitmap& bitmap, const wxColour& colour );
> %win wxMask(const wxBitmap& bitmap, int index );
> bool Create(const wxBitmap& bitmap );
> bool Create(const wxBitmap& bitmap, const wxColour& colour );
> %win bool Create(const wxBitmap& bitmap, int index );
> wxMask& operator=(const wxMask& m) const;

};
#endif //wxLUA_USE_wxMask
// ---------------------------------------------------------------------------
// wxImageList
#if wxLUA_USE_wxImageList
#include "wx/imaglist.h"
#define wxIMAGELIST_DRAW_NORMAL
#define wxIMAGELIST_DRAW_TRANSPARENT
#define wxIMAGELIST_DRAW_SELECTED
#define wxIMAGELIST_DRAW_FOCUSED
#define wxIMAGE_LIST_NORMAL
#define wxIMAGE_LIST_SMALL
#define wxIMAGE_LIST_STATE
class %delete wxImageList : public wxObject
{

> wxImageList(int width, int height, bool mask = true, int initialCount = 1 );
> int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap );
> int Add(const wxBitmap& bitmap, const wxColour& maskColour );
> int Add(const wxIcon& icon );
> bool Draw(int index, wxDC& dc, int x, int y, int flags = wxIMAGELIST_DRAW_NORMAL, bool solidBackground = false );
> wxBitmap GetBitmap(int index) const;
> wxIcon GetIcon(int index) const;
> int GetImageCount( );
> // %override [int width, int height] wxImageList::GetSize(int index );
> // C++ Func: void GetSize(int index, int& width, int& height );
> void GetSize(int index );
> bool Remove(int index );
> bool RemoveAll( );
> %win bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap );
> %gtk|%mac bool Replace(int index, const wxBitmap& bitmap );
> //bool ReplaceIcon(int index, const wxIcon& icon );

};
#endif //wxLUA_USE_wxImageList
// ---------------------------------------------------------------------------
// wxDC
#if wxLUA_USE_wxDC
#include "wx/dc.h"
enum wxMappingMode
{

> wxMM_TEXT,
> wxMM_METRIC,
> wxMM_LOMETRIC,
> wxMM_TWIPS,
> wxMM_POINTS,
> !%wxchkver_2_9_2 wxMM_HIMETRIC,
> !%wxchkver_2_9_2 wxMM_LOENGLISH,
> !%wxchkver_2_9_2 wxMM_HIENGLISH,
> !%wxchkver_2_9_2 wxMM_ISOTROPIC,
> !%wxchkver_2_9_2 wxMM_ANISOTROPIC

};
enum wxRasterOperationMode
{

> wxCLEAR,
> wxXOR,
> wxINVERT,
> wxOR_REVERSE,
> wxAND_REVERSE,
> wxCOPY,
> wxAND,
> wxAND_INVERT,
> wxNO_OP,
> wxNOR,
> wxEQUIV,
> wxSRC_INVERT,
> wxOR_INVERT,
> wxNAND,
> wxOR,
> wxSET,
> // wxROP_XXX and wxBLIT_XXX are wxcompat_2_8
> wxROP_BLACK,
> wxROP_COPYPEN,
> wxROP_MASKNOTPEN,
> wxROP_MASKPEN,
> wxROP_MASKPENNOT,
> wxROP_MERGENOTPEN,
> wxROP_MERGEPEN,
> wxROP_MERGEPENNOT,
> wxROP_NOP,
> wxROP_NOT,
> wxROP_NOTCOPYPEN,
> wxROP_NOTMASKPEN,
> wxROP_NOTMERGEPEN,
> wxROP_NOTXORPEN,
> wxROP_WHITE,
> wxROP_XORPEN,
> wxBLIT_00220326,
> wxBLIT_007700E6,
> wxBLIT_00990066,
> wxBLIT_00AA0029,
> wxBLIT_00DD0228,
> wxBLIT_BLACKNESS,
> wxBLIT_DSTINVERT,
> wxBLIT_MERGEPAINT,
> wxBLIT_NOTSCRCOPY,
> wxBLIT_NOTSRCERASE,
> wxBLIT_SRCAND,
> wxBLIT_SRCCOPY,
> wxBLIT_SRCERASE,
> wxBLIT_SRCINVERT,
> wxBLIT_SRCPAINT,
> wxBLIT_WHITENESS

};
enum wxFloodFillStyle
{

> wxFLOOD_BORDER,
> wxFLOOD_SURFACE

};
enum wxPolygonFillMode
{

> wxODDEVEN_RULE,
> wxWINDING_RULE

};
class %delete wxDC : public wxObject
{

> // %win wxDC() wxDC is abstract use wxXXXDC
> //void BeginDrawing(); // these are deprecated in 2.8 and didn't do anything anyway
> bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC* source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY, bool useMask = false );
> void CalcBoundingBox(wxCoord x, wxCoord y );
> void Clear( );
> //void ComputeScaleAndOrigin() used internally
> void CrossHair(wxCoord x, wxCoord y );
> void DestroyClippingRegion( );
> wxCoord DeviceToLogicalX(wxCoord x );
> wxCoord DeviceToLogicalXRel(wxCoord x );
> wxCoord DeviceToLogicalY(wxCoord y );
> wxCoord DeviceToLogicalYRel(wxCoord y );
> void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc );
> void DrawBitmap(const wxBitmap& bitmap, wxCoord x, wxCoord y, bool transparent );
> void DrawCheckMark(wxCoord x, wxCoord y, wxCoord width, wxCoord height );
> void DrawCheckMark(const wxRect &rect );
> void DrawCircle(wxCoord x, wxCoord y, wxCoord radius );
> //void DrawCircle(const wxPoint& pt, wxCoord radius );
> void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height );
> //void DrawEllipse(const wxPoint& pt, const wxSize& size );
> //void DrawEllipse(const wxRect& rect );
> void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double start, double end );
> void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y );
> void DrawLabel(const wxString& text, const wxBitmap& image, const wxRect& rect, int alignment = wxALIGN_LEFT | wxALIGN_TOP, int indexAccel = -1); //, wxRect *rectBounding = NULL );
> void DrawLabel(const wxString& text, const wxRect& rect, int alignment = wxALIGN_LEFT | wxALIGN_TOP, int indexAccel = -1 );
> void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 );
> //void DrawLines(int n, wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0 );
> // Provide a Lua Table of {{1,2},{3,4},...}, {{x=1,y=2},{x=3,y=4},...}, or {wx.wxPoint(1,2),wx.wxPoint(3,4),...}
> void DrawLines(wxPointArray_FromLuaTable points, wxCoord xoffset = 0, wxCoord yoffset = 0 );
> //%wxchkver_2_9 void DrawLines(const wxPointList *points, wxCoord xoffset = 0, wxCoord yoffset = 0 );
> //!%wxchkver_2_9 void DrawLines(const wxList *points, wxCoord xoffset = 0, wxCoord yoffset = 0 );
> //void DrawPolygon(int n, wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE );
> // Provide a Lua Table of {{1,2},{3,4},...}, {{x=1,y=2},{x=3,y=4},...}, or {wx.wxPoint(1,2),wx.wxPoint(3,4),...}
> void DrawPolygon(wxPointArray_FromLuaTable points, wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE );
> //%wxchkver_2_9 void DrawPolygon(const wxPointList *points, wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE );
> //!%wxchkver_2_9 void DrawPolygon(const wxList *points, wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE );
> //void DrawPolyPolygon(int n, int count[], wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE );
> void DrawPoint(wxCoord x, wxCoord y );
> void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height );
> void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle );
> void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius = 20 );
> #if wxUSE_SPLINES
> //void DrawSpline(int n, wxPoint points[] );
> // Provide a Lua Table of {{1,2},{3,4},...}, {{x=1,y=2},{x=3,y=4},...}, or {wx.wxPoint(1,2),wx.wxPoint(3,4),...}
> void DrawSpline(wxPointArray_FromLuaTable points );
> //void DrawSpline(wxList *points );
> #endif //wxUSE_SPLINES
> void DrawText(const wxString& text, wxCoord x, wxCoord y );
> void EndDoc( );
> //void EndDrawing(); // these are deprecated in 2.8 and didn't do anything anyway
> void EndPage( );
> void FloodFill(wxCoord x, wxCoord y, const wxColour& colour, wxFloodFillStyle style=wxFLOOD_SURFACE );
> #if %wxchkver_2_8
> //void GradientFillConcentric(const wxRect& rect, const wxColour& initialColour, const wxColour& destColour );
> void GradientFillConcentric(const wxRect& rect, const wxColour& initialColour, const wxColour& destColour, const wxPoint& circleCenter );
> void GradientFillLinear(const wxRect& rect, const wxColour& initialColour, const wxColour& destColour, wxDirection nDirection = wxEAST );
> wxBitmap GetAsBitmap(const wxRect *subrect = NULL) const;
> #endif //%wxchkver_2_8
> // alias
> const wxBrush& GetBackground( );
> int GetBackgroundMode() const;
> const wxBrush& GetBrush( );
> wxCoord GetCharHeight( );
> wxCoord GetCharWidth( );
> void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *width, wxCoord *height );
> const wxFont& GetFont( );
> %wxchkver_2_8 wxLayoutDirection GetLayoutDirection() const;
> int GetLogicalFunction( );
> int GetMapMode( );
> //bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
> const wxPen& GetPen( );
> bool GetPixel(wxCoord x, wxCoord y, wxColour *colour );
> wxSize GetPPI() const;
> void GetSize(wxCoord *width, wxCoord *height); // wxSize GetSize() const;
> //void GetSizeMM(wxCoord *width, wxCoord *height) const; // wxSize GetSizeMM() const;
> const wxColour& GetTextBackground() const;
> // %override [int x, int y, int descent, int externalLeading] int wxDC::GetTextExtent(const wxString& string, const wxFont* font = NULL );
> // C++ Func: void GetTextExtent(const wxString& string, wxCoord* x, wxCoord* y, wxCoord* descent = NULL, wxCoord* externalLeading = NULL, const wxFont* font = NULL );
> void GetTextExtent(const wxString& string, wxFont *font = NULL );
> %wxchkver_2_8 %rename GetTextExtentSize wxSize GetTextExtent(const wxString& string) const;
> // %override [int x, int y, int heightLine] int wxDC::GetMultiLineTextExtent(const wxString& string, const wxFont* font = NULL );
> // C++ Func: void GetMultiLineTextExtent(const wxString& string, wxCoord* x, wxCoord* y, wxCoord* heightLine = NULL, const wxFont* font = NULL );
> %wxchkver_2_8 void GetMultiLineTextExtent(const wxString& string, wxFont *font = NULL) const;
> %wxchkver_2_8 %rename GetMultiLineTextExtentSize wxSize GetMultiLineTextExtent(const wxString& string) const;
> const wxColour& GetTextForeground( );
> // %override [int x, int y] wxDC::GetUserScale( );
> // C++ Func: void GetUserScale(double *x, double *y );
> void GetUserScale( );
> wxCoord LogicalToDeviceX(wxCoord x );
> wxCoord LogicalToDeviceXRel(wxCoord x );
> wxCoord LogicalToDeviceY(wxCoord y );
> wxCoord LogicalToDeviceYRel(wxCoord y );
> wxCoord MaxX( );
> wxCoord MaxY( );
> wxCoord MinX( );
> wxCoord MinY( );
> bool IsOk( );
> void ResetBoundingBox( );
> void SetAxisOrientation(bool xLeftRight, bool yBottomUp );
> %wxchkver_2_9_5 virtual double GetContentScaleFactor() const;
> void SetBackground(const wxBrush& brush );
> void SetBackgroundMode(int mode );
> void SetBrush(const wxBrush& brush );
> void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height );
> void SetClippingRegion(const wxRegion& region );
> //void SetClippingRegion(const wxPoint& pt, const wxSize& sz );
> //void SetClippingRegion(const wxRect& rect );
> void SetDeviceOrigin(wxCoord x, wxCoord y );
> void SetFont(const wxFont& font );
> %wxchkver_2_8 void SetLayoutDirection(wxLayoutDirection dir );
> void SetLogicalFunction(wxRasterOperationMode function );
> void SetMapMode(wxMappingMode unit );
> void SetPalette(const wxPalette& palette );
> void SetPen(const wxPen& pen );
> void SetTextBackground(const wxColour& colour );
> void SetTextForeground(const wxColour& colour );
> void SetUserScale(double xScale, double yScale );
> bool StartDoc(const wxString& message );
> void StartPage( );

};
// ---------------------------------------------------------------------------
// wxMemoryDC
#include "wx/dcmemory.h"
class %delete wxMemoryDC : public wxDC
{

> wxMemoryDC( );
> void SelectObject(wxBitmap& bitmap); // not const in >=2.8
> %wxchkver_2_8 virtual void SelectObjectAsSource(const wxBitmap& bmp );

};
// ---------------------------------------------------------------------------
// wxWindowDC
#include "wx/dcclient.h"
class %delete wxWindowDC : public wxDC
{

> wxWindowDC(wxWindow* window );

};
// ---------------------------------------------------------------------------
// wxClientDC
#include "wx/dcclient.h"
class %delete wxClientDC : public wxWindowDC
{

> wxClientDC(wxWindow* window );

};
// ---------------------------------------------------------------------------
// wxPaintDC
#include "wx/dcclient.h"
class %delete wxPaintDC : public wxWindowDC // base ok as wxWindowDC since only some platforms have wxClientDC as base
{

> wxPaintDC(wxWindow* window );

};
// ---------------------------------------------------------------------------
// wxScreenDC
#include "wx/dcscreen.h"
class %delete wxScreenDC : public wxDC
{

> wxScreenDC( );
> static bool StartDrawingOnTop(wxWindow* window );
> static bool StartDrawingOnTop(wxRect* rect = NULL );
> static bool EndDrawingOnTop( );

};
// ---------------------------------------------------------------------------
// wxBufferedDC
#include "wx/dcbuffer.h"
class %delete wxBufferedDC : public wxMemoryDC
{

> wxBufferedDC( );
> wxBufferedDC(wxDC *dc, const wxSize& area, int style = wxBUFFER_CLIENT_AREA );
> wxBufferedDC(wxDC *dc, wxBitmap& buffer, int style = wxBUFFER_CLIENT_AREA); // not const bitmap >= 2.8
> void Init(wxDC *dc, const wxSize& area, int style = wxBUFFER_CLIENT_AREA );
> void Init(wxDC *dc, wxBitmap& buffer, int style = wxBUFFER_CLIENT_AREA); // not const bitmap in >= 2.8

};
// ---------------------------------------------------------------------------
// wxBufferedPaintDC
#include "wx/dcbuffer.h"
class %delete wxBufferedPaintDC : public wxBufferedDC
{

> wxBufferedPaintDC(wxWindow *window, int style = wxBUFFER_CLIENT_AREA );
> wxBufferedPaintDC(wxWindow *window, wxBitmap& buffer, int style = wxBUFFER_CLIENT_AREA); // not const bitmap in >= 2.8

};
// ---------------------------------------------------------------------------
// wxAutoBufferedPaintDC
#include "wx/dcbuffer.h"
#if %wxchkver_2_8
#define wxALWAYS_NATIVE_DOUBLE_BUFFER
// This class is derived from a wxPaintDC if wxALWAYS_NATIVE_DOUBLE_BUFFER else wxBufferedPaintDC
// In fact in release mode it's only a #define to either
class %delete wxAutoBufferedPaintDC : public wxDC // base ok as wxDC since no need for others
{

> wxAutoBufferedPaintDC(wxWindow *window );

};
#endif // %wxchkver_2_8
// ---------------------------------------------------------------------------
// wxMirrorDC
#include "wx/dcmirror.h"
class %delete wxMirrorDC : public wxDC
{

> wxMirrorDC(wxDC& dc, bool mirror );

};
// ---------------------------------------------------------------------------
// wxDCClipper
#include "wx/dc.h"
class %delete wxDCClipper
{

> wxDCClipper(wxDC& dc, const wxRect& r );
> //wxDCClipper(wxDC& dc, const wxRegion& r );
> wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h );

};
#endif //wxLUA_USE_wxDC
// ---------------------------------------------------------------------------
// wxCaret
#if wxLUA_USE_wxCaret && wxUSE_CARET
#include "wx/caret.h"
class %delete wxCaret
{

> wxCaret( );
> wxCaret(wxWindow* window, const wxSize& size );
> wxCaret(wxWindow* window, int width, int height );
> bool Create(wxWindow* window, const wxSize& size );
> bool Create(wxWindow* window, int width, int height );
> static int GetBlinkTime( );
> // %override [int x, int y] wxCaret::GetPositionXY( );
> // C++ Func: void GetPosition(int *x, int *y );
> %rename GetPositionXY void GetPosition( );
> wxPoint GetPosition( );
> // %override [int x, int y] wxCaret::GetSizeWH( );
> // C++ Func: void GetSize(int *x, int *y );
> %rename GetSizeWH void GetSize( );
> wxSize GetSize( );
> wxWindow *GetWindow( );
> void Hide( );
> bool IsOk( );
> bool IsVisible( );
> void Move(int x, int y );
> void Move(const wxPoint& pt );
> static void SetBlinkTime(int ms );
> void SetSize(int width, int height );
> void SetSize(const wxSize& size );
> void Show(bool show = true );

};
// ---------------------------------------------------------------------------
// wxCaretSuspend
#include "wx/caret.h"
class %delete wxCaretSuspend
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxCaretSuspend(wxWindow *win = NULL );

};
#endif //wxLUA_USE_wxCaret && wxUSE_CARET
// ---------------------------------------------------------------------------
// wxVideoMode
#if wxLUA_USE_wxDisplay && wxUSE_DISPLAY
#include "wx/display.h"
class %delete wxVideoMode
{

> #define_object wxDefaultVideoMode
> wxVideoMode(int width = 0, int height = 0, int depth = 0, int freq = 0 );
> bool Matches(const wxVideoMode& other) const;
> int GetWidth() const;
> int GetHeight() const;
> int GetDepth() const;
> bool IsOk() const;
> bool operator==(const wxVideoMode& v) const;

};
// ---------------------------------------------------------------------------
// wxArrayVideoModes
class %delete wxArrayVideoModes
{

> wxArrayVideoModes( );
> wxArrayVideoModes(const wxArrayVideoModes& array );
> void Add(const wxVideoMode& vm, size_t copies = 1 );
> void Alloc(size_t nCount );
> void Clear( );
> void Empty( );
> int GetCount() const;
> void Insert(const wxVideoMode& vm, int nIndex, size_t copies = 1 );
> bool IsEmpty( );
> wxVideoMode Item(size_t nIndex) const;
> wxVideoMode Last( );
> void RemoveAt(size_t nIndex, size_t count = 1 );
> void Shrink( );
> wxVideoMode& operator[](size_t nIndex );

};
// ---------------------------------------------------------------------------
// wxDisplay
class %delete wxDisplay
{

> wxDisplay(size_t index = 0 );
> bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode );
> static size_t GetCount( );
> wxVideoMode GetCurrentMode() const;
> // int GetDepth() const; // in docs BUT not in C++ header
> static int GetFromPoint(const wxPoint& pt );
> %wxchkver_2_8|!%gtk static int GetFromWindow(wxWindow* win );
> wxRect GetGeometry() const;
> %wxchkver_2_8 wxRect GetClientArea() const;
> wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
> wxString GetName() const;
> bool IsOk() const;
> bool IsPrimary( );

};
#endif //wxLUA_USE_wxDisplay && wxUSE_DISPLAY
// ---------------------------------------------------------------------------
// wxEffects
#include "wx/effects.h"
class %delete wxEffects : public wxObject
{

> wxEffects(); // use system default colours
> wxEffects(const wxColour& highlightColour, const wxColour& lightShadow, const wxColour& faceColour, const wxColour& mediumShadow, const wxColour& darkShadow );
> wxColour GetHighlightColour() const;
> wxColour GetLightShadow() const;
> wxColour GetFaceColour() const;
> wxColour GetMediumShadow() const;
> wxColour GetDarkShadow() const;
> void SetHighlightColour(const wxColour& c );
> void SetLightShadow(const wxColour& c );
> void SetFaceColour(const wxColour& c );
> void SetMediumShadow(const wxColour& c );
> void SetDarkShadow(const wxColour& c );
> void Set(const wxColour& highlightColour, const wxColour& lightShadow, const wxColour& faceColour, const wxColour& mediumShadow, const wxColour& darkShadow );
> void DrawSunkenEdge(wxDC& dc, const wxRect& rect, int borderSize = 1 );
> bool TileBitmap(const wxRect& rect, wxDC& dc, wxBitmap& bitmap );

};
// ---------------------------------------------------------------------------
// wxRenderer
#if wxLUA_USE_wxRenderer
#include "wx/renderer.h"
%wxHAS_NATIVE_RENDERER #define wxHAS_NATIVE_RENDERER 1
enum
{
wxCONTROL_DISABLED, //= 0x00000001, // control is disabled
wxCONTROL_FOCUSED, //= 0x00000002, // currently has keyboard focus
wxCONTROL_PRESSED, //= 0x00000004, // (button) is pressed
wxCONTROL_SPECIAL, //= 0x00000008, // control-specific bit:
wxCONTROL_ISDEFAULT, //= wxCONTROL_SPECIAL, // only for the buttons
wxCONTROL_ISSUBMENU, //= wxCONTROL_SPECIAL, // only for the menu items
wxCONTROL_EXPANDED, //= wxCONTROL_SPECIAL, // only for the tree items
wxCONTROL_SIZEGRIP, //= wxCONTROL_SPECIAL, // only for the status bar panes
wxCONTROL_CURRENT, //= 0x00000010, // mouse is currently over the control
wxCONTROL_SELECTED, //= 0x00000020, // selected item in e.g. listbox
wxCONTROL_CHECKED, //= 0x00000040, // (check/radio button) is checked
wxCONTROL_CHECKABLE, //= 0x00000080, // (menu) item can be checked
wxCONTROL_UNDETERMINED, //= wxCONTROL_CHECKABLE, // (check) undetermined state
wxCONTROL_FLAGS_MASK, //= 0x000000ff,
// this is a pseudo flag not used directly by wxRenderer but rather by some
// controls internally
wxCONTROL_DIRTY //= 0x80000000
};
struct %delete wxSplitterRenderParams
{

> // the only way to initialize this struct is by using this ctor
> wxSplitterRenderParams(wxCoord widthSash_, wxCoord border_, bool isSens_ );
> const wxCoord widthSash; // the width of the splitter sash
> const wxCoord border; // the width of the border of the splitter window
> const bool isHotSensitive; // true if the splitter changes its appearance when the mouse is over it

};
// extra optional parameters for DrawHeaderButton
struct %delete wxHeaderButtonParams
{

> wxHeaderButtonParams( );
> wxColour m_arrowColour;
> wxColour m_selectionColour;
> wxString m_labelText;
> wxFont m_labelFont;
> wxColour m_labelColour;
> wxBitmap m_labelBitmap;
> int m_labelAlignment;

};
enum wxHeaderSortIconType
{

> wxHDR_SORT_ICON_NONE, // Header button has no sort arrow
> wxHDR_SORT_ICON_UP, // Header button an an up sort arrow icon
> wxHDR_SORT_ICON_DOWN // Header button an a down sort arrow icon

};
// the current version and age of wxRendererNative interface: different
// versions are incompatible (in both ways) while the ages inside the same
// version are upwards compatible, i.e. the version of the renderer must
// match the version of the main program exactly while the age may be
// highergreater or equal to it
enum wxRendererVersion::dummy
{

> Current_Version, //= 1,
> Current_Age //= 5

};
// wxRendererNative interface version
struct %delete wxRendererVersion
{

> wxRendererVersion(int version_, int age_ );
> // check if the given version is compatible with the current one
> static bool IsCompatible(const wxRendererVersion& ver );
> const int version;
> const int age;

};
class %delete wxRendererNative
{

> // pseudo constructors
> // -------------------
> // return the currently used renderer
> static wxRendererNative& Get();
> // return the generic implementation of the renderer
> static wxRendererNative& GetGeneric();
> // return the default (native) implementation for this platform
> static wxRendererNative& GetDefault();
> // draw the header control button (used by wxListCtrl) Returns optimal
> // width for the label contents.
> virtual int DrawHeaderButton(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0, wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE, wxHeaderButtonParams* params=NULL); //= 0;
> // Draw the contents of a header control button (label, sort arrows, etc. );
> // Normally only called by DrawHeaderButton.
> virtual int DrawHeaderButtonContents(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0, wxHeaderSortIconType sortArrow = wxHDR_SORT_ICON_NONE, wxHeaderButtonParams* params=NULL); //= 0;
> // Returns the default height of a header button, either a fixed platform
> // height if available, or a generic height based on the window's font.
> virtual int GetHeaderButtonHeight(wxWindow *win); //= 0;
> // draw the expanded/collapsed icon for a tree control item
> virtual void DrawTreeItemButton(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0); //= 0;
> // draw the border for sash window: this border must be such that the sash
> // drawn by DrawSash() blends into it well
> virtual void DrawSplitterBorder(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0); //= 0;
> // draw a (vertical) sash
> virtual void DrawSplitterSash(wxWindow *win, wxDC& dc, const wxSize& size, wxCoord position, wxOrientation orient, int flags = 0); //= 0;
> // draw a combobox dropdown button
> // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
> virtual void DrawComboBoxDropButton(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0); //= 0;
> // draw a dropdown arrow
> // flags may use wxCONTROL_PRESSED and wxCONTROL_CURRENT
> virtual void DrawDropArrow(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0); //= 0;
> // draw check button
> // flags may use wxCONTROL_CHECKED, wxCONTROL_UNDETERMINED and wxCONTROL_CURRENT
> virtual void DrawCheckBox(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0); //= 0;
> // draw blank button
> // flags may use wxCONTROL_PRESSED, wxCONTROL_CURRENT and wxCONTROL_ISDEFAULT
> virtual void DrawPushButton(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0); //= 0;
> // draw rectangle indicating that an item in e.g. a list control has been selected or focused
> // flags may use
> // wxCONTROL_SELECTED (item is selected, e.g. draw background );
> // wxCONTROL_CURRENT (item is the current item, e.g. dotted border );
> // wxCONTROL_FOCUSED (the whole control has focus, e.g. blue background vs. grey otherwise );
> virtual void DrawItemSelectionRect(wxWindow *win, wxDC& dc, const wxRect& rect, int flags = 0); //= 0;
> // geometry functions
> // ------------------
> // get the splitter parameters: the x field of the returned point is the
> // sash width and the y field is the border width
> virtual wxSplitterRenderParams GetSplitterParams(const wxWindow *win); //= 0;
> // changing the global renderer
> // ----------------------------
> #if wxUSE_DYNLIB_CLASS
> // load the renderer from the specified DLL, the returned pointer must be
> // deleted by caller if not NULL when it is not used any more
> static %gc wxRendererNative *Load(const wxString& name);
> #endif // wxUSE_DYNLIB_CLASS
> // set the renderer to use, passing NULL reverts to using the default
> // renderer
> //
> // return the previous renderer used with Set() or NULL if none
> static %gc wxRendererNative *Set(%ungc wxRendererNative *renderer);
> // this function is used for version checking: Load() refuses to load any
> // DLLs implementing an older or incompatible version; it should be
> // implemented simply by returning wxRendererVersion::Current_XXX values
> virtual wxRendererVersion GetVersion() const; //= 0;

};
#endif // wxLUA_USE_wxRenderer

## wxwidgets/wxcore_geometry.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxPoint2DInt, wxRect2DInt and other classes from wx/geometry.h
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_Geometry && wxUSE_GEOMETRY
typedef int wxInt32
typedef double wxDouble
enum wxOutCode
{

> wxInside,
> wxOutLeft,
> wxOutRight,
> wxOutTop,
> wxOutBottom

};
// ---------------------------------------------------------------------------
// wxPoint2DInt
#include "wx/geometry.h"
class %delete wxPoint2DInt
{

> //wxPoint2DInt( );
> wxPoint2DInt( wxInt32 x=0, wxInt32 y=0 );
> wxPoint2DInt( const wxPoint2DInt &pt );
> wxPoint2DInt( const wxPoint &pt );
> //void GetFloor( wxInt32 *x , wxInt32 *y ) const;
> //void GetRounded( wxInt32 *x , wxInt32 *y ) const;
> wxDouble GetVectorLength() const;
> wxDouble GetVectorAngle() const;
> void SetVectorLength( wxDouble length );
> void SetVectorAngle( wxDouble degrees );
> //void SetPolarCoordinates( wxInt32 angle, wxInt32 length ) - no function body in wxWidgets
> void Normalize( );
> wxDouble GetDistance( const wxPoint2DInt &pt ) const;
> wxDouble GetDistanceSquare( const wxPoint2DInt &pt ) const;
> wxInt32 GetDotProduct( const wxPoint2DInt &vec ) const;
> wxInt32 GetCrossProduct( const wxPoint2DInt &vec ) const;
> //void WriteTo( wxDataOutputStream &stream ) const;
> //void ReadFrom( wxDataInputStream &stream );
> %rename X %member_func wxInt32 m_x;
> %rename Y %member_func wxInt32 m_y;
> wxPoint2DInt operator-( );
> wxPoint2DInt& operator=(const wxPoint2DInt& pt );
> wxPoint2DInt& operator+=(const wxPoint2DInt& pt );
> wxPoint2DInt& operator-=(const wxPoint2DInt& pt );
> wxPoint2DInt& operator*=(const wxPoint2DInt& pt );
> //wxPoint2DInt& operator*=(wxDouble n) - no function body in wxWidgets
> //wxPoint2DInt& operator*=(wxInt32 n) - no function body in wxWidgets
> wxPoint2DInt& operator/=(const wxPoint2DInt& pt );
> //wxPoint2DInt& operator/=(wxDouble n) - no function body in wxWidgets
> //wxPoint2DInt& operator/=(wxInt32 n) - no function body in wxWidgets
> //operator wxPoint() const;
> bool operator==(const wxPoint2DInt& pt) const;
> //bool operator!=(const wxPoint2DInt& pt) const;
> wxPoint2DInt operator*(wxInt32 n );

};
// ---------------------------------------------------------------------------
// wxPoint2DDouble
#include "wx/geometry.h"
class %delete wxPoint2DDouble
{

> //wxPoint2DDouble( );
> wxPoint2DDouble( wxDouble x=0, wxDouble y=0 );
> wxPoint2DDouble( const wxPoint2DDouble &pt );
> wxPoint2DDouble( const wxPoint2DInt &pt );
> wxPoint2DDouble( const wxPoint &pt );
> //void GetFloor( wxInt32 *x , wxInt32 *y ) const;
> //void GetRounded( wxInt32 *x , wxInt32 *y ) const;
> wxDouble GetVectorLength() const;
> wxDouble GetVectorAngle() const;
> void SetVectorLength( wxDouble length );
> void SetVectorAngle( wxDouble degrees );
> //void SetPolarCoordinates( wxDouble angle, wxDouble length ) - no function body in wxWidgets
> //void Normalize() - no function body in wxWidgets
> wxDouble GetDistance( const wxPoint2DDouble &pt ) const;
> wxDouble GetDistanceSquare( const wxPoint2DDouble &pt ) const;
> wxDouble GetDotProduct( const wxPoint2DDouble &vec ) const;
> wxDouble GetCrossProduct( const wxPoint2DDouble &vec ) const;
> %rename X %member_func wxDouble m_x;
> %rename Y %member_func wxDouble m_y;
> wxPoint2DDouble operator-( );
> wxPoint2DDouble& operator=(const wxPoint2DDouble& pt );
> wxPoint2DDouble& operator+=(const wxPoint2DDouble& pt );
> wxPoint2DDouble& operator-=(const wxPoint2DDouble& pt );
> wxPoint2DDouble& operator*=(const wxPoint2DDouble& pt );
> //wxPoint2DDouble& operator*=(wxDouble n );
> //wxPoint2DDouble& operator*=(wxInt32 n );
> wxPoint2DDouble& operator/=(const wxPoint2DDouble& pt );
> //wxPoint2DDouble& operator/=(wxDouble n );
> //wxPoint2DDouble& operator/=(wxInt32 n );
> bool operator==(const wxPoint2DDouble& pt) const;
> //bool operator!=(const wxPoint2DDouble& pt) const;

};
// ---------------------------------------------------------------------------
// wxRect2DDouble
#include "wx/geometry.h"
class %delete wxRect2DDouble
{

> //wxRect2DDouble( );
> wxRect2DDouble(wxDouble x=0, wxDouble y=0, wxDouble w=0, wxDouble h=0 );
> wxRect2DDouble(const wxRect2DDouble& rect );
> wxPoint2DDouble GetPosition( );
> wxSize GetSize( );
> wxDouble GetLeft() const;
> void SetLeft( wxDouble n );
> void MoveLeftTo( wxDouble n );
> wxDouble GetTop() const;
> void SetTop( wxDouble n );
> void MoveTopTo( wxDouble n );
> wxDouble GetBottom() const;
> void SetBottom( wxDouble n );
> void MoveBottomTo( wxDouble n );
> wxDouble GetRight() const;
> void SetRight( wxDouble n );
> void MoveRightTo( wxDouble n );
> wxPoint2DDouble GetLeftTop() const;
> void SetLeftTop( const wxPoint2DDouble &pt );
> void MoveLeftTopTo( const wxPoint2DDouble &pt );
> wxPoint2DDouble GetLeftBottom() const;
> void SetLeftBottom( const wxPoint2DDouble &pt );
> void MoveLeftBottomTo( const wxPoint2DDouble &pt );
> wxPoint2DDouble GetRightTop() const;
> void SetRightTop( const wxPoint2DDouble &pt );
> void MoveRightTopTo( const wxPoint2DDouble &pt );
> wxPoint2DDouble GetRightBottom() const;
> void SetRightBottom( const wxPoint2DDouble &pt );
> void MoveRightBottomTo( const wxPoint2DDouble &pt );
> wxPoint2DDouble GetCentre() const;
> void SetCentre( const wxPoint2DDouble &pt );
> void MoveCentreTo( const wxPoint2DDouble &pt );
> wxOutCode GetOutCode( const wxPoint2DDouble &pt ) const;
> bool Contains( const wxPoint2DDouble &pt ) const;
> bool Contains( const wxRect2DDouble &rect ) const;
> bool IsEmpty() const;
> bool HaveEqualSize( const wxRect2DDouble &rect ) const;
> //void Inset( wxDouble x, wxDouble y );
> void Inset( wxDouble left, wxDouble top, wxDouble right, wxDouble bottom );
> void Offset( const wxPoint2DDouble &pt );
> void ConstrainTo( const wxRect2DDouble &rect );
> wxPoint2DDouble Interpolate( wxInt32 widthfactor , wxInt32 heightfactor );
> //static void Intersect( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
> void Intersect( const wxRect2DDouble &otherRect );
> wxRect2DDouble CreateIntersection( const wxRect2DDouble &otherRect ) const;
> bool Intersects( const wxRect2DDouble &rect ) const;
> //static void Union( const wxRect2DDouble &src1 , const wxRect2DDouble &src2 , wxRect2DDouble *dest );
> void Union( const wxRect2DDouble &otherRect );
> void Union( const wxPoint2DDouble &pt );
> wxRect2DDouble CreateUnion( const wxRect2DDouble &otherRect ) const;
> void Scale( wxDouble f );
> //void Scale( wxInt32 num , wxInt32 denum );
> %rename X %member_func wxDouble m_x;
> %rename Y %member_func wxDouble m_y;
> %rename Width %member_func wxDouble m_width;
> %rename Height %member_func wxDouble m_height;
> //wxRect2DDouble& operator = (const wxRect2DDouble& rect) - use copy constructor
> bool operator==(const wxRect2DDouble& rect );
> //bool operator != (const wxRect2DDouble& rect) const;

};
// ---------------------------------------------------------------------------
// wxRect2DInt
#include "wx/geometry.h"
class %delete wxRect2DInt
{

> //wxRect2DInt( );
> wxRect2DInt(wxInt32 x=0, wxInt32 y=0, wxInt32 w=0, wxInt32 h=0 );
> wxRect2DInt(const wxRect2DInt& rect );
> wxRect2DInt( const wxRect& r );
> wxRect2DInt(const wxPoint2DInt& topLeft, const wxPoint2DInt& bottomRight );
> wxRect2DInt(const wxPoint2DInt& pos, const wxSize& size );
> wxPoint2DInt GetPosition( );
> wxSize GetSize( );
> wxInt32 GetLeft() const;
> void SetLeft( wxInt32 n );
> void MoveLeftTo( wxInt32 n );
> wxInt32 GetTop() const;
> void SetTop( wxInt32 n );
> void MoveTopTo( wxInt32 n );
> wxInt32 GetBottom() const;
> void SetBottom( wxInt32 n );
> void MoveBottomTo( wxInt32 n );
> wxInt32 GetRight() const;
> void SetRight( wxInt32 n );
> void MoveRightTo( wxInt32 n );
> wxPoint2DInt GetLeftTop() const;
> void SetLeftTop( const wxPoint2DInt &pt );
> void MoveLeftTopTo( const wxPoint2DInt &pt );
> wxPoint2DInt GetLeftBottom() const;
> void SetLeftBottom( const wxPoint2DInt &pt );
> void MoveLeftBottomTo( const wxPoint2DInt &pt );
> wxPoint2DInt GetRightTop() const;
> void SetRightTop( const wxPoint2DInt &pt );
> void MoveRightTopTo( const wxPoint2DInt &pt );
> wxPoint2DInt GetRightBottom() const;
> void SetRightBottom( const wxPoint2DInt &pt );
> void MoveRightBottomTo( const wxPoint2DInt &pt );
> wxPoint2DInt GetCentre() const;
> void SetCentre( const wxPoint2DInt &pt );
> void MoveCentreTo( const wxPoint2DInt &pt );
> wxOutCode GetOutCode( const wxPoint2DInt &pt ) const;
> bool Contains( const wxPoint2DInt &pt ) const;
> bool Contains( const wxRect2DInt &rect ) const;
> bool IsEmpty() const;
> bool HaveEqualSize( const wxRect2DInt &rect ) const;
> //void Inset( wxInt32 x , wxInt32 y );
> void Inset( wxInt32 left, wxInt32 top, wxInt32 right, wxInt32 bottom );
> void Offset( const wxPoint2DInt &pt );
> void ConstrainTo( const wxRect2DInt &rect );
> wxPoint2DInt Interpolate( wxInt32 widthfactor , wxInt32 heightfactor );
> //static void Intersect( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
> void Intersect( const wxRect2DInt &otherRect );
> wxRect2DInt CreateIntersection( const wxRect2DInt &otherRect ) const;
> bool Intersects( const wxRect2DInt &rect ) const;
> //static void Union( const wxRect2DInt &src1 , const wxRect2DInt &src2 , wxRect2DInt *dest );
> void Union( const wxRect2DInt &otherRect );
> void Union( const wxPoint2DInt &pt );
> wxRect2DInt CreateUnion( const wxRect2DInt &otherRect ) const;
> void Scale( wxInt32 f );
> //void Scale( wxInt32 num , wxInt32 denum );
> //void WriteTo( wxDataOutputStream &stream ) const;
> //void ReadFrom( wxDataInputStream &stream );
> %rename X %member_func wxInt32 m_x;
> %rename Y %member_func wxInt32 m_y;
> %rename Width %member_func wxInt32 m_width;
> %rename Height %member_func wxInt32 m_height;
> //wxRect2DInt& operator = (const wxRect2DInt& rect) - use copy constructor
> bool operator == (const wxRect2DInt& rect) const;
> //bool operator != (const wxRect2DInt& rect) const;

};
// ---------------------------------------------------------------------------
// wxTransform2D - an abstract class
//#include "wx/geometry.h"
//
//class %delete wxTransform2D
//{
// virtual void Transform( wxPoint2DInt* pt )const; // = 0
// virtual void Transform( wxRect2DInt* r ) const;
// virtual wxPoint2DInt Transform( const wxPoint2DInt &pt ) const;
// virtual wxRect2DInt Transform( const wxRect2DInt &r ) const;
// virtual void InverseTransform( wxPoint2DInt* pt ) const; // = 0
// virtual void InverseTransform( wxRect2DInt* r ) const;
// virtual wxPoint2DInt InverseTransform( const wxPoint2DInt &pt ) const;
// virtual wxRect2DInt InverseTransform( const wxRect2DInt &r ) const;
// void wxTransform2D::Transform( wxRect2DInt* r ) const;
// wxPoint2DInt wxTransform2D::Transform( const wxPoint2DInt &pt ) const;
// wxRect2DInt wxTransform2D::Transform( const wxRect2DInt &r ) const;
// void wxTransform2D::InverseTransform( wxRect2DInt* r ) const;
// wxPoint2DInt wxTransform2D::InverseTransform( const wxPoint2DInt &pt ) const;
// wxRect2DInt wxTransform2D::InverseTransform( const wxRect2DInt &r ) const;
//};
#endif //wxLUA_USE_Geometry && wxUSE_GEOMETRY

## wxwidgets/wxcore_help.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxHelpController and help related classes
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// See wxhtml_html.i for wxHtmlHelp classes
// ---------------------------------------------------------------------------
// wxContextHelp
#if wxLUA_USE_wxHelpController && wxUSE_HELP
#include "wx/cshelp.h"
class %delete wxContextHelp : public wxObject
{

> wxContextHelp(wxWindow* win = NULL, bool beginHelp = true );
> bool BeginContextHelp(wxWindow* win );
> bool EndContextHelp( );
> //bool EventLoop( );
> //bool DispatchEvent(wxWindow* win, const wxPoint& pt );
> //void SetStatus(bool status );

};
// ---------------------------------------------------------------------------
// wxContextHelpButton
#if wxLUA_USE_wxBitmapButton && wxUSE_BMPBUTTON
#include "wx/cshelp.h"
class wxContextHelpButton : public wxBitmapButton
{

> wxContextHelpButton(wxWindow* parent, wxWindowID id = wxID_CONTEXT_HELP, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxBU_AUTODRAW );
> //void OnContextHelp(wxCommandEvent& event );

};
#endif //wxLUA_USE_wxBitmapButton && wxUSE_BMPBUTTON
// ---------------------------------------------------------------------------
// wxHelpProvider
class %delete wxHelpProvider
{

> // No constructor see wxSimpleHelpProvider
> // Note that the wxHelpProviderModule will delete the set wxHelpProvider
> // so you do not have to delete() it when the program exits. However,
> // if you set a different wxHelpProvider you must delete() the previous one.
> static %gc wxHelpProvider *Set(%ungc wxHelpProvider *helpProvider );
> static wxHelpProvider *Get( );
> virtual wxString GetHelp(const wxWindow *window); // pure virtual
> %wxchkver_2_8 virtual bool ShowHelpAtPoint(wxWindow *window, const wxPoint& pt, wxHelpEvent::Origin origin );
> virtual bool ShowHelp(wxWindow *window );
> virtual void AddHelp(wxWindow *window, const wxString& text );
> //virtual void AddHelp(wxWindowID id, const wxString& text );
> virtual void RemoveHelp(wxWindow* window );

};
// ---------------------------------------------------------------------------
// wxSimpleHelpProvider
class %delete wxSimpleHelpProvider : public wxHelpProvider
{

> wxSimpleHelpProvider( );

};
// ---------------------------------------------------------------------------
// wxHelpControllerHelpProvider
class %delete wxHelpControllerHelpProvider : public wxSimpleHelpProvider
{

> wxHelpControllerHelpProvider(wxHelpController* hc = NULL );
> // The wxHelpController you set must exist for the life of this.
> // And this will not delete() it when done.
> void SetHelpController(wxHelpController* hc );
> wxHelpController* GetHelpController() const;

};
#endif //wxLUA_USE_wxHelpController && wxUSE_HELP
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// wxHelpControllerBase and derived help controller classes
#if wxLUA_USE_wxHelpController && wxUSE_HELP
#include "wx/help.h"
#define wxHELP_NETSCAPE // Flags for SetViewer
enum wxHelpSearchMode
{

> wxHELP_SEARCH_INDEX,
> wxHELP_SEARCH_ALL

};
class %delete wxHelpControllerBase : public wxObject
{

> //wxHelpControllerBase() - base class no constructor
> virtual void Initialize(const wxString& file );
> // virtual void Initialize(const wxString& file, int server) - marked obsolete
> virtual bool DisplayBlock(long blockNo );
> virtual bool DisplayContents( );
> virtual bool DisplayContextPopup(int contextId );
> virtual bool DisplaySection(int sectionNo );
> virtual bool DisplaySection(const wxString &section );
> virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos );
> // %override [wxFrame*, wxSize* size = NULL, wxPoint* pos = NULL, bool *newFrameEachTime = NULL] wxHelpControllerBase::GetFrameParameters( );
> // C++ Func: virtual wxFrame* GetFrameParameters(wxSize* size = NULL, wxPoint* pos = NULL, bool *newFrameEachTime = NULL );
> virtual wxFrame* GetFrameParameters( );
> %wxchkver_2_8 virtual wxWindow* GetParentWindow() const;
> virtual bool KeywordSearch(const wxString& keyWord, wxHelpSearchMode mode = wxHELP_SEARCH_ALL );
> virtual bool LoadFile(const wxString& file = "" );
> //virtual bool OnQuit( );
> virtual void SetFrameParameters(const wxString& title, const wxSize& size, const wxPoint& pos = wxDefaultPosition, bool newFrameEachTime = false );
> %wxchkver_2_8 virtual void SetParentWindow(wxWindow* win );
> virtual void SetViewer(const wxString& viewer, long flags );
> virtual bool Quit( );

};
// ---------------------------------------------------------------------------
// wxHelpController - wxWidgets #defines it appropriately per platform
class %delete wxHelpController : public wxHelpControllerBase
{

> wxHelpController( );
> //%wxchkver_2_8 wxHelpController(wxWindow* parentWindow = NULL) wxHTMLHelpController takes different params

};
// ---------------------------------------------------------------------------
// wxWinHelpController
#if %msw
#include "wx/helpwin.h"
class %delete wxWinHelpController : public wxHelpControllerBase
{

> wxWinHelpController( );

};
#endif //%msw
// ---------------------------------------------------------------------------
// wxCHMHelpController
//#include "wx/msw/helpchm.h"
//class %delete wxCHMHelpController : public wxHelpControllerBase
//{
// wxCHMHelpController( );
//};
// ---------------------------------------------------------------------------
// wxBestHelpController
#if %msw
#include "wx/msw/helpbest.h"
class %delete wxBestHelpController : public wxHelpControllerBase
{

> wxBestHelpController(wxWindow* parentWindow = NULL, int style = wxHF_DEFAULT_STYLE );

};
#endif //%msw
// ---------------------------------------------------------------------------
// wxExtHelpController
#if !%win
#include "wx/generic/helpext.h"
class %delete wxExtHelpController : public wxHelpControllerBase
{

> wxExtHelpController( );

};
#endif //!%win
#endif //wxLUA_USE_wxHelpController && wxUSE_HELP

## wxwidgets/wxcore_image.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxImage
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#define wxIMAGE_ALPHA_TRANSPARENT
#define wxIMAGE_ALPHA_THRESHOLD
#define wxIMAGE_ALPHA_OPAQUE
enum wxBitmapType
{

> wxBITMAP_TYPE_INVALID,
> wxBITMAP_TYPE_BMP,
> wxBITMAP_TYPE_BMP_RESOURCE,
> wxBITMAP_TYPE_RESOURCE,
> wxBITMAP_TYPE_ICO,
> wxBITMAP_TYPE_ICO_RESOURCE,
> wxBITMAP_TYPE_CUR,
> wxBITMAP_TYPE_CUR_RESOURCE,
> wxBITMAP_TYPE_XBM,
> wxBITMAP_TYPE_XBM_DATA,
> wxBITMAP_TYPE_XPM,
> wxBITMAP_TYPE_XPM_DATA,
> wxBITMAP_TYPE_TIF,
> wxBITMAP_TYPE_TIF_RESOURCE,
> wxBITMAP_TYPE_GIF,
> wxBITMAP_TYPE_GIF_RESOURCE,
> wxBITMAP_TYPE_PNG,
> wxBITMAP_TYPE_PNG_RESOURCE,
> wxBITMAP_TYPE_JPEG,
> wxBITMAP_TYPE_JPEG_RESOURCE,
> wxBITMAP_TYPE_PNM,
> wxBITMAP_TYPE_PNM_RESOURCE,
> wxBITMAP_TYPE_PCX,
> wxBITMAP_TYPE_PCX_RESOURCE,
> wxBITMAP_TYPE_PICT,
> wxBITMAP_TYPE_PICT_RESOURCE,
> wxBITMAP_TYPE_ICON,
> wxBITMAP_TYPE_ICON_RESOURCE,
> wxBITMAP_TYPE_ANI,
> wxBITMAP_TYPE_IFF,
> %wxchkver_2_8 wxBITMAP_TYPE_TGA,
> wxBITMAP_TYPE_MACCURSOR,
> wxBITMAP_TYPE_MACCURSOR_RESOURCE,
> wxBITMAP_TYPE_ANY

};
// ---------------------------------------------------------------------------
// wxImage
#if wxLUA_USE_wxImage && wxUSE_IMAGE
#include "wx/image.h"
%wxchkver_2_6 #define_wxstring wxIMAGE_OPTION_CUR_HOTSPOT_X
%wxchkver_2_6 #define_wxstring wxIMAGE_OPTION_CUR_HOTSPOT_Y
//#define_string wxIMAGE_OPTION_PNG_FORMAT see wxPNGHandler
//#define_string wxIMAGE_OPTION_PNG_BITDEPTH see wxPNGHandler
//#define_string wxIMAGE_OPTION_BMP_FORMAT see wxBMPHandler
#define_wxstring wxIMAGE_OPTION_QUALITY wxT("quality" );
#define_wxstring wxIMAGE_OPTION_FILENAME wxT("FileName" );
#define_wxstring wxIMAGE_OPTION_RESOLUTION wxT("Resolution" );
#define_wxstring wxIMAGE_OPTION_RESOLUTIONX wxT("ResolutionX" );
#define_wxstring wxIMAGE_OPTION_RESOLUTIONY wxT("ResolutionY" );
#define_wxstring wxIMAGE_OPTION_RESOLUTIONUNIT wxT("ResolutionUnit" );
enum
{
// constants used with wxIMAGE_OPTION_RESOLUTIONUNIT
wxIMAGE_RESOLUTION_INCHES,
wxIMAGE_RESOLUTION_CM
};
// Constants for wxImage::Scale() for determining the level of quality
enum wxImageResizeQuality
{

> // different image resizing algorithms used by Scale() and Rescale( );
> %wxchkver_2_9_2 wxIMAGE_QUALITY_NEAREST,
> %wxchkver_2_9_2 wxIMAGE_QUALITY_BILINEAR,
> %wxchkver_2_9_2 wxIMAGE_QUALITY_BICUBIC,
> %wxchkver_2_9_2 wxIMAGE_QUALITY_BOX_AVERAGE,
> // default quality is low (but fast );
> %wxchkver_2_8 wxIMAGE_QUALITY_NORMAL,
> // highest (but best) quality
> %wxchkver_2_8 wxIMAGE_QUALITY_HIGH

};
class %delete wxImage : public wxObject
{

> #define_object wxNullImage
> wxImage( );
> wxImage(const wxImage& image );
> wxImage(int width, int height, bool clear=true );
> wxImage(const wxString& name, long type = wxBITMAP_TYPE_ANY );
> // %override wxImage(int width, int height, unsigned char* data, bool static_data = false );
> // C++ Func: wxImage(int width, int height, unsigned char* data, bool static_data = false );
> %override_name wxLua_wxImageFromData_constructor wxImage(int width, int height, unsigned char* data, bool static_data = false );
> // %override wxLua provides this constructor
> %override_name wxLua_wxImageFromBitmap_constructor wxImage(const wxBitmap& bitmap );
> static void AddHandler(%ungc wxImageHandler* handler );
> %wxchkver_2_8 wxImage Blur(int radius );
> %wxchkver_2_8 wxImage BlurHorizontal(int radius );
> %wxchkver_2_8 wxImage BlurVertical(int radius );
> static void CleanUpHandlers( );
> unsigned long ComputeHistogram(wxImageHistogram& histogram) const;
> //wxBitmap ConvertToBitmap() const; // - deprecated use wxBitmap constructor
> %wxchkver_2_8 wxImage ConvertToGreyscale( double lr = 0.299, double lg = 0.587, double lb = 0.114 ) const;
> wxImage ConvertToMono(unsigned char r, unsigned char g, unsigned char b) const;
> wxImage Copy() const;
> void Create(int width, int height, bool clear=true );
> void Destroy( );
> // %override [bool, uchar r, uchar g, char b] wxImage::FindFirstUnusedColour(unsigned char startR = 1, unsigned char startG = 0, unsigned char startB = 0 );
> // C++ Func: bool FindFirstUnusedColour(unsigned char* r, unsigned char* g, unsigned char* b, unsigned char startR = 1, unsigned char startG = 0, unsigned char startB = 0 );
> bool FindFirstUnusedColour(unsigned char startR = 1, unsigned char startG = 0, unsigned char startB = 0 );
> static wxImageHandler* FindHandler(const wxString& name );
> static wxImageHandler* FindHandler(const wxString& extension, long imageType );
> static wxImageHandler* FindHandler(long imageType );
> static wxImageHandler* FindHandlerMime(const wxString& mimetype );
> static wxString GetImageExtWildcard( );
> unsigned char GetAlpha(int x, int y) const;
> unsigned char GetBlue(int x, int y) const;
> // %override [Lua string] wxImage::GetAlpha() const;
> // C++ Func: unsigned char* GetAlpha() const;
> %override_name wxLua_wxImage_GetAlphaData unsigned char* GetAlpha() const;
> // %override [Lua string] wxImage::GetData() const;
> // C++ Func: unsigned char* GetData() const;
> unsigned char* GetData() const;
> unsigned char GetGreen(int x, int y) const;
> static int GetImageCount(const wxString& filename, wxBitmapType type = wxBITMAP_TYPE_ANY );
> static int GetImageCount(wxInputStream& stream, wxBitmapType type = wxBITMAP_TYPE_ANY );
> static wxList& GetHandlers( );
> int GetHeight() const;
> unsigned char GetMaskBlue() const;
> unsigned char GetMaskGreen() const;
> unsigned char GetMaskRed() const;
> // %override [bool, uchar r, uchar g, uchar b] wxImage::GetOrFindMaskColour() const;
> // C++ Func: bool GetOrFindMaskColour(unsigned char *r, unsigned char *g, unsigned char *b) const;
> bool GetOrFindMaskColour() const;
> wxPalette GetPalette() const;
> unsigned char GetRed(int x, int y) const;
> wxImage GetSubImage(const wxRect& rect) const;
> int GetWidth() const;
> // note: we're tricking generator to not gag on RGB/HSVValue, so pretend to return an int
> // %override [r, g, b] wxImage::HSVtoRGB(double h, double s, double v );
> // C++ Func: static RGBValue HSVtoRGB(const HSVValue& hsv );
> static int HSVtoRGB(double h, double s, double v );
> // %override [h, s, v] wxImage::RGBtoHSV(unsigned char r, unsigned char g, unsigned char b );
> // C++ Func: static HSVValue RGBtoHSV(const RGBValue& rgb );
> static int RGBtoHSV(unsigned char r, unsigned char g, unsigned char b );
> bool HasAlpha() const;
> bool HasMask() const;
> wxString GetOption(const wxString &name) const;
> int GetOptionInt(const wxString &name) const;
> int HasOption(const wxString &name) const;
> void InitAlpha( );
> static void InitStandardHandlers( );
> static void InsertHandler(%ungc wxImageHandler* handler );
> bool IsTransparent(int x, int y, unsigned char threshold = 128) const;
> bool LoadFile(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_ANY, int index = -1 );
> bool LoadFile(const wxString& name, const wxString& mimetype, int index = -1 );
> bool LoadFile(wxInputStream& stream, wxBitmapType type = wxBITMAP_TYPE_ANY, int index = -1 );
> bool LoadFile(wxInputStream& stream, const wxString& mimetype, int index = -1 );
> bool Ok() const;
> static bool RemoveHandler(const wxString& name );
> wxImage Mirror(bool horizontally = true) const;
> void Replace(unsigned char r1, unsigned char g1, unsigned char b1, unsigned char r2, unsigned char g2, unsigned char b2 );
> %wxchkver_2_8 wxImage ResampleBox(int width, int height) const;
> %wxchkver_2_8 wxImage ResampleBicubic(int width, int height) const;
> !%wxchkver_2_8 wxImage& Rescale(int width, int height );
> %wxchkver_2_8 wxImage& Rescale( int width, int height, wxImageResizeQuality quality = wxIMAGE_QUALITY_NORMAL );
> wxImage& Resize(const wxSize& size, const wxPoint& pos, int red = -1, int green = -1, int blue = -1 );
> wxImage Rotate(double angle, const wxPoint& rotationCentre, bool interpolating = true, wxPoint* offsetAfterRotation = NULL );
> void RotateHue(double angle );
> wxImage Rotate90(bool clockwise = true) const;
> bool SaveFile(const wxString& name );
> bool SaveFile(const wxString& name, int type );
> bool SaveFile(const wxString& name, const wxString& mimetype );
> !%wxchkver_2_8 wxImage Scale(int width, int height) const;
> %wxchkver_2_8 wxImage Scale( int width, int height, wxImageResizeQuality quality = wxIMAGE_QUALITY_NORMAL ) const;
> wxImage Size(const wxSize& size, const wxPoint& pos, int red = -1, int green = -1, int blue = -1) const;
> void SetAlpha(int x, int y, unsigned char alpha );
> // %override void wxImage::SetAlpha(Lua string) - copy contents of string to image
> // C++ Func: void SetAlpha(unsigned char *alpha = NULL,bool static_data = false );
> %override_name wxLua_wxImage_SetAlphaData void SetAlpha(const wxString& dataStr );
> // %override void wxImage::SetData(Lua string) - copy contents of string to image
> // C++ Func: void SetData(unsigned char *data );
> void SetData(const wxString& data );
> void SetMask(bool hasMask = true );
> void SetMaskColour(unsigned char red, unsigned char blue, unsigned char green );
> bool SetMaskFromImage(const wxImage& mask, unsigned char mr, unsigned char mg, unsigned char mb );
> void SetOption(const wxString &name, const wxString &value );
> void SetOption(const wxString &name, int value );
> void SetPalette(const wxPalette& palette );
> void SetRGB(int x, int y, unsigned char red, unsigned char green, unsigned char blue );
> void SetRGB(wxRect& rect, unsigned char red, unsigned char green, unsigned char blue );
> wxImage& operator=(const wxImage& image );
> //bool operator==(const wxImage& image) const; // not in 2.8

};
// ---------------------------------------------------------------------------
// wxImageHistogram
class %delete wxImageHistogramEntry
{

> wxImageHistogramEntry( );
> unsigned long index; // GetIndex() only, SetIndex(idx) is not allowed
> unsigned long value; // GetValue() and SetValue(val );

};
class %delete wxImageHistogram::iterator
{

> long first;
> wxImageHistogramEntry second;
> // operator used to compare with wxImageHistogram::end() iterator
> bool operator==(const wxImageHistogram::iterator& other) const;
> //wxImageHistogram::iterator& operator++(); // it just returns *this
> void operator++(); // it's best if we don't return the iterator

};
class %delete wxImageHistogram // wxImageHistogramBase actually a hash map
{

> wxImageHistogram( );
> // get the key in the histogram for the given RGB values
> static unsigned long MakeKey(unsigned char r, unsigned char g, unsigned char b );
> // Use the function wxImage::FindFirstUnusedColour
> //bool FindFirstUnusedColour(unsigned char *r, unsigned char *g, unsigned char *b, unsigned char startR = 1, unsigned char startG = 0, unsigned char startB = 0 ) const;
> // Selected functions from the base wxHashMap class
> wxImageHistogram::iterator begin() const; // not const iterator since we create a new copy of it
> void clear( );
> size_t count(long key) const;
> bool empty() const;
> wxImageHistogram::iterator end() const; // not const iterator since we create a new copy of it
> size_t erase(long key );
> wxImageHistogram::iterator find(long key );
> //Insert_Result insert(const value_type& v );
> size_t size() const;
> //mapped_type& operator[](const key_type& key );

};
// ---------------------------------------------------------------------------
// wxQuantize
#include "wx/quantize.h"
#define wxQUANTIZE_INCLUDE_WINDOWS_COLOURS
#define wxQUANTIZE_RETURN_8BIT_DATA
#define wxQUANTIZE_FILL_DESTINATION_IMAGE
class wxQuantize : public wxObject
{

> // No constructor - all methods static
> // %override bool wxQuantize::Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236, int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE|wxQUANTIZE_RETURN_8BIT_DATA);
> // C++ Func: static bool Quantize(const wxImage& src, wxImage& dest, wxPalette** pPalette, int desiredNoColours = 236, unsigned char** eightBitData = 0, int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE|wxQUANTIZE_RETURN_8BIT_DATA);
> static bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236, int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE|wxQUANTIZE_RETURN_8BIT_DATA);
> //static bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236, unsigned char** eightBitData = 0, int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE|wxQUANTIZE_RETURN_8BIT_DATA);
> //static void DoQuantize(unsigned w, unsigned h, unsigned char **in_rows, unsigned char **out_rows, unsigned char *palette, int desiredNoColours);

};
// ---------------------------------------------------------------------------
// wxImageHandler and derived classes
class %delete wxImageHandler : public wxObject
{

> // no constructor - abstract class
> wxString GetName() const;
> wxString GetExtension() const;
> int GetImageCount(wxInputStream& stream );
> long GetType() const;
> wxString GetMimeType() const;
> bool LoadFile(wxImage* image, wxInputStream& stream, bool verbose=true, int index=0 );
> bool SaveFile(wxImage* image, wxOutputStream& stream );
> void SetName(const wxString& name );
> void SetExtension(const wxString& extension );
> void SetMimeType(const wxString& mimetype );
> void SetType(long type );

};
// ---------------------------------------------------------------------------
// wxBMPHandler and friends in imagbmp.h
#include "wx/imagbmp.h"
enum
{
wxBMP_24BPP,
//wxBMP_16BPP, - remmed out in wxWidgets
wxBMP_8BPP,
wxBMP_8BPP_GREY,
wxBMP_8BPP_GRAY,
wxBMP_8BPP_RED,
wxBMP_8BPP_PALETTE,
wxBMP_4BPP,
wxBMP_1BPP,
wxBMP_1BPP_BW
};
#define_wxstring wxIMAGE_OPTION_BMP_FORMAT wxT("wxBMP_FORMAT"); // wxString(wxT("wxBMP_FORMAT") );
class %delete wxBMPHandler : public wxImageHandler
{

> wxBMPHandler( );

};
#if wxUSE_ICO_CUR
class %delete wxICOHandler : public wxBMPHandler
{

> wxICOHandler( );

};
class %delete wxCURHandler : public wxICOHandler
{

> wxCURHandler( );

};
class %delete wxANIHandler : public wxCURHandler
{

> wxANIHandler( );

};
#endif // wxUSE_ICO_CUR
// ---------------------------------------------------------------------------
// wxIFFHandler and friends in imagiff.h
#include "wx/imagiff.h"
#if wxUSE_IFF
class %delete wxIFFHandler : public wxImageHandler
{

> wxIFFHandler( );

};
#endif //wxUSE_IFF
// ---------------------------------------------------------------------------
// wxGIFHandler and friends in imaggif.h
#include "wx/imaggif.h"
#if wxUSE_GIF
class %delete wxGIFHandler : public wxImageHandler
{

> wxGIFHandler( );

};
#endif //wxUSE_GIF
// ---------------------------------------------------------------------------
// wxJPEGHandler and friends in imagjpeg.h
#include "wx/imagjpeg.h"
#if wxUSE_LIBJPEG
class %delete wxJPEGHandler : public wxImageHandler
{

> wxJPEGHandler( );

};
#endif //wxUSE_LIBJPEG
// ---------------------------------------------------------------------------
// wxPCXHandler and friends in imagpcx.h
#include "wx/imagpcx.h"
#if wxUSE_PCX
class %delete wxPCXHandler : public wxImageHandler
{

> wxPCXHandler( );

};
#endif //wxUSE_PCX
// ---------------------------------------------------------------------------
// wxPNGHandler and friends in imagpng.h
#include "wx/imagpng.h"
#if wxUSE_LIBPNG
#define_wxstring wxIMAGE_OPTION_PNG_FORMAT // wxT("PngFormat" );
#define_wxstring wxIMAGE_OPTION_PNG_BITDEPTH // wxT("PngBitDepth" );
enum
{
wxPNG_TYPE_COLOUR,
wxPNG_TYPE_GREY,
wxPNG_TYPE_GREY_RED
};
class %delete wxPNGHandler : public wxImageHandler
{

> wxPNGHandler( );

};
#endif //wxUSE_LIBPNG
// ---------------------------------------------------------------------------
// wxPNMHandler and friends in imagpnm.h
#include "wx/imagpnm.h"
#if wxUSE_PNM
class %delete wxPNMHandler : public wxImageHandler
{

> wxPNMHandler( );

};
#endif //wxUSE_PNM
// ---------------------------------------------------------------------------
// wxTIFFHandler and friends in imagtiff.h
#include "wx/imagtiff.h"
#if wxUSE_LIBTIFF
#define_wxstring wxIMAGE_OPTION_BITSPERSAMPLE wxT("BitsPerSample" );
#define_wxstring wxIMAGE_OPTION_SAMPLESPERPIXEL wxT("SamplesPerPixel" );
#define_wxstring wxIMAGE_OPTION_COMPRESSION wxT("Compression" );
#define_wxstring wxIMAGE_OPTION_IMAGEDESCRIPTOR wxT("ImageDescriptor" );
class %delete wxTIFFHandler : public wxImageHandler
{

> wxTIFFHandler( );

};
#endif //wxUSE_LIBTIFF
// ---------------------------------------------------------------------------
// wxTGAHandler and friends in imagtga.h
#if %wxchkver_2_8 && wxUSE_TGA
#include "wx/imagtga.h"
class %delete wxTGAHandler : public wxImageHandler
{

> wxTGAHandler( );

};
#endif // %wxchkver_2_8 && wxUSE_TGA
// ---------------------------------------------------------------------------
// wxXPMHandler and friends in imagxpm.h
#include "wx/imagxpm.h"
class %delete wxXPMHandler : public wxImageHandler
{

> wxXPMHandler( );

};
#endif //wxLUA_USE_wxImage && wxUSE_IMAGE
// ---------------------------------------------------------------------------
// wxArtProvider and friends
#if wxLUA_USE_wxArtProvider
#include "wx/artprov.h"
//typedef wxString wxArtClient Just treat these as wxStrings
//typedef wxString wxArtID
// ----------------------------------------------------------------------------
// Art clients
// ----------------------------------------------------------------------------
#if %wxchkver_2_9_0
#define_string wxART_TOOLBAR
#define_string wxART_MENU
#define_string wxART_FRAME_ICON
#define_string wxART_CMN_DIALOG
#define_string wxART_HELP_BROWSER
#define_string wxART_MESSAGE_BOX
#define_string wxART_BUTTON
#define_string wxART_OTHER
#endif
#if !%wxchkver_2_9_0
#define_wxstring wxART_TOOLBAR
#define_wxstring wxART_MENU
#define_wxstring wxART_FRAME_ICON
#define_wxstring wxART_CMN_DIALOG
#define_wxstring wxART_HELP_BROWSER
#define_wxstring wxART_MESSAGE_BOX
#define_wxstring wxART_BUTTON
#define_wxstring wxART_OTHER
#endif
// ----------------------------------------------------------------------------
// Art IDs
// ----------------------------------------------------------------------------
#if %wxchkver_2_9_0
#define_string wxART_ADD_BOOKMARK
#define_string wxART_DEL_BOOKMARK
#define_string wxART_HELP_SIDE_PANEL
#define_string wxART_HELP_SETTINGS
#define_string wxART_HELP_BOOK
#define_string wxART_HELP_FOLDER
#define_string wxART_HELP_PAGE
#define_string wxART_GO_BACK
#define_string wxART_GO_FORWARD
#define_string wxART_GO_UP
#define_string wxART_GO_DOWN
#define_string wxART_GO_TO_PARENT
#define_string wxART_GO_HOME
#define_string wxART_FILE_OPEN
#define_string wxART_FILE_SAVE
#define_string wxART_FILE_SAVE_AS
#define_string wxART_PRINT
#define_string wxART_HELP
#define_string wxART_TIP
#define_string wxART_REPORT_VIEW
#define_string wxART_LIST_VIEW
#define_string wxART_NEW_DIR
#define_string wxART_HARDDISK
#define_string wxART_FLOPPY
#define_string wxART_CDROM
#define_string wxART_REMOVABLE
#define_string wxART_FOLDER
#define_string wxART_FOLDER_OPEN
#define_string wxART_GO_DIR_UP
#define_string wxART_EXECUTABLE_FILE
#define_string wxART_NORMAL_FILE
#define_string wxART_TICK_MARK
#define_string wxART_CROSS_MARK
#define_string wxART_ERROR
#define_string wxART_QUESTION
#define_string wxART_WARNING
#define_string wxART_INFORMATION
#define_string wxART_MISSING_IMAGE
#define_string wxART_COPY
#define_string wxART_CUT
#define_string wxART_PASTE
#define_string wxART_DELETE
#define_string wxART_NEW
#define_string wxART_UNDO
#define_string wxART_REDO
#define_string wxART_QUIT
#define_string wxART_FIND
#define_string wxART_FIND_AND_REPLACE
#endif
#if !%wxchkver_2_9_0
#define_wxstring wxART_ADD_BOOKMARK
#define_wxstring wxART_DEL_BOOKMARK
#define_wxstring wxART_HELP_SIDE_PANEL
#define_wxstring wxART_HELP_SETTINGS
#define_wxstring wxART_HELP_BOOK
#define_wxstring wxART_HELP_FOLDER
#define_wxstring wxART_HELP_PAGE
#define_wxstring wxART_GO_BACK
#define_wxstring wxART_GO_FORWARD
#define_wxstring wxART_GO_UP
#define_wxstring wxART_GO_DOWN
#define_wxstring wxART_GO_TO_PARENT
#define_wxstring wxART_GO_HOME
#define_wxstring wxART_FILE_OPEN
#define_wxstring wxART_FILE_SAVE
#define_wxstring wxART_FILE_SAVE_AS
#define_wxstring wxART_PRINT
#define_wxstring wxART_HELP
#define_wxstring wxART_TIP
#define_wxstring wxART_REPORT_VIEW
#define_wxstring wxART_LIST_VIEW
#define_wxstring wxART_NEW_DIR
#define_wxstring wxART_HARDDISK
#define_wxstring wxART_FLOPPY
#define_wxstring wxART_CDROM
#define_wxstring wxART_REMOVABLE
#define_wxstring wxART_FOLDER
#define_wxstring wxART_FOLDER_OPEN
#define_wxstring wxART_GO_DIR_UP
#define_wxstring wxART_EXECUTABLE_FILE
#define_wxstring wxART_NORMAL_FILE
#define_wxstring wxART_TICK_MARK
#define_wxstring wxART_CROSS_MARK
#define_wxstring wxART_ERROR
#define_wxstring wxART_QUESTION
#define_wxstring wxART_WARNING
#define_wxstring wxART_INFORMATION
#define_wxstring wxART_MISSING_IMAGE
#define_wxstring wxART_COPY
#define_wxstring wxART_CUT
#define_wxstring wxART_PASTE
#define_wxstring wxART_DELETE
#define_wxstring wxART_NEW
#define_wxstring wxART_UNDO
#define_wxstring wxART_REDO
#define_wxstring wxART_QUIT
#define_wxstring wxART_FIND
#define_wxstring wxART_FIND_AND_REPLACE
#endif
class wxArtProvider : public wxObject
{

> // wxArtProvider() - abstract class
> #if %wxchkver_2_8
> static void Push(%ungc wxArtProvider *provider );
> static void Insert(%ungc wxArtProvider *provider );
> static bool Pop( );
> static bool Remove(%gc wxArtProvider *provider); // FIXME - mem leak if not found
> static bool Delete(%ungc wxArtProvider *provider );
> #endif // %wxchkver_2_8
> //#if !%wxcompat_2_6
> //static void PushProvider(wxArtProvider *provider) FIXME add wxLuaArtProvider maybe?
> //static bool PopProvider( );
> //static bool RemoveProvider(wxArtProvider *provider );
> //#endif // !%wxcompat_2_6
> static wxBitmap GetBitmap(const wxString& id, const wxString& client = wxART_OTHER, const wxSize& size = wxDefaultSize );
> static wxIcon GetIcon(const wxString& id, const wxString& client = wxART_OTHER, const wxSize& size = wxDefaultSize );
> static wxSize GetSizeHint(const wxString& client, bool platform_dependent = false );

};
class %delete wxLuaArtProvider : public wxArtProvider
{

> // %override - the C++ function takes the wxLuaState as the first param
> wxLuaArtProvider( );
> // virtual function that you can override in Lua.
> virtual wxSize DoGetSizeHint(const wxString& client); // { return GetSizeHint(client, true); }
> // virtual function that you can override in Lua.
> // Derived classes must override this method to create requested
> // art resource. This method is called only once per instance's
> // lifetime for each requested wxArtID.
> virtual wxBitmap CreateBitmap(const wxString& id, const wxString& client, const wxSize& size);

};
#endif //wxLUA_USE_wxArtProvider

## wxwidgets/wxcore_mdi.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxMDI classes
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_MDI && wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
#include "wx/cmdproc.h"
// ---------------------------------------------------------------------------
// wxMDIClientWindow
class wxMDIClientWindow : public wxWindow
{

};
// ---------------------------------------------------------------------------
// wxMDIParentFrame
class wxMDIParentFrame : public wxFrame
{

> wxMDIParentFrame( );
> wxMDIParentFrame(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL, const wxString& name = "wxMDIParentFrame" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL, const wxString& name = "wxMDIParentFrame" );
> void ActivateNext( );
> void ActivatePrevious( );
> void ArrangeIcons( );
> void Cascade( );
> wxMDIChildFrame* GetActiveChild() const;
> wxMDIClientWindow* GetClientWindow() const;
> // virtual wxToolBar* GetToolBar() const; - see wxFrame
> %win wxMenu* GetWindowMenu() const;
> // virtual void SetToolBar(wxToolBar* toolbar) - see wxFrame
> %win void SetWindowMenu(%ungc wxMenu* menu );
> void Tile(wxOrientation orient = wxHORIZONTAL );

};
// ---------------------------------------------------------------------------
// wxMDIChildFrame
class wxMDIChildFrame : public wxFrame
{

> wxMDIChildFrame( );
> wxMDIChildFrame(wxMDIParentFrame* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxMDIChildFrame" );
> bool Create(wxMDIParentFrame* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxMDIChildFrame" );
> void Activate( );
> %win void Maximize( );
> void Restore( );

};
// ---------------------------------------------------------------------------
// wxDocMDIParentFrame
#include "wx/docmdi.h"
class wxDocMDIParentFrame : public wxMDIParentFrame
{

> wxDocMDIParentFrame( );
> wxDocMDIParentFrame(wxDocManager *manager, wxFrame *parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocMDIParentFrame" );
> bool Create(wxDocManager *manager, wxFrame *parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocMDIParentFrame" );
> wxDocManager *GetDocumentManager() const;

};
// ---------------------------------------------------------------------------
// wxDocMDIChildFrame
class wxDocMDIChildFrame : public wxMDIChildFrame
{

> wxDocMDIChildFrame( );
> wxDocMDIChildFrame(wxDocument *doc, wxView *view, wxMDIParentFrame *frame, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,long type = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocMDIChildFrame" );
> bool Create(wxDocument *doc, wxView *view, wxMDIParentFrame *frame, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long type = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocMDIChildFrame" );
> wxDocument *GetDocument() const;
> wxView *GetView() const;
> void SetDocument(wxDocument *doc );
> void SetView(wxView *view );

};
// ---------------------------------------------------------------------------
// wxDocChildFrame
#include "wx/docview.h"
class wxDocChildFrame : public wxFrame
{

> wxDocChildFrame(wxDocument* doc, wxView* view, wxFrame* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocChildFrame" );
> wxDocument* GetDocument() const;
> wxView* GetView() const;
> void SetDocument(wxDocument *doc );
> void SetView(wxView *view );

};
// ---------------------------------------------------------------------------
// wxDocManager
#define wxDEFAULT_DOCMAN_FLAGS
#define wxDOC_NEW
#define wxDOC_SILENT
class wxDocManager : public wxEvtHandler
{

> wxDocManager(long flags = wxDEFAULT_DOCMAN_FLAGS, bool initialize = true );
> %wxchkver_2_6 void ActivateView(wxView* view, bool activate );
> !%wxchkver_2_6 void ActivateView(wxView* view, bool activate, bool deleting );
> void AddDocument(wxDocument *doc );
> void AddFileToHistory(const wxString& filename );
> void AssociateTemplate(wxDocTemplate *temp );
> bool CloseDocuments(bool force = true );
> wxDocument* CreateDocument(const wxString& path, long flags );
> wxView* CreateView(wxDocument*doc, long flags );
> void DisassociateTemplate(wxDocTemplate *temp );
> void FileHistoryAddFilesToMenu( );
> void FileHistoryAddFilesToMenu(wxMenu* menu );
> void FileHistoryLoad(wxConfigBase& config );
> void FileHistoryRemoveMenu(wxMenu* menu );
> void FileHistorySave(wxConfigBase& resourceFile );
> void FileHistoryUseMenu(wxMenu* menu );
> wxDocTemplate * FindTemplateForPath(const wxString& path );
> wxDocument * GetCurrentDocument( );
> wxView * GetCurrentView( );
> // %overide wxList& wxDocManager::GetDocuments() - returns a copied list
> wxList& GetDocuments( );
> wxFileHistory * GetFileHistory( );
> wxString GetLastDirectory() const;
> int GetMaxDocsOpen( );
> !%wxchkver_2_6 int GetNoHistoryFiles( );
> %wxchkver_2_6 size_t GetHistoryFilesCount() const;
> // %overide wxList& wxDocManager::GetTemplates() - returns a copied list
> wxList& GetTemplates( );
> bool Initialize( );
> // %override [bool, string buf] wxDocManager::MakeDefaultName(wxString& buf );
> // C++ Func: bool MakeDefaultName(wxString& buf );
> bool MakeDefaultName(wxString& buf );
> wxFileHistory* OnCreateFileHistory( );
> void OnFileClose(wxCommandEvent &event );
> void OnFileCloseAll(wxCommandEvent& event );
> void OnFileNew(wxCommandEvent &event );
> void OnFileOpen(wxCommandEvent &event );
> void OnFileRevert(wxCommandEvent& event );
> void OnFileSave(wxCommandEvent &event );
> void OnFileSaveAs(wxCommandEvent &event );
> //void OnMenuCommand(int cmd );
> void RemoveDocument(wxDocument *doc );
> //wxDocTemplate * SelectDocumentPath(wxDocTemplate **templates, int noTemplates, const wxString& path, const wxString& bufSize, long flags, bool save );
> //wxDocTemplate * SelectDocumentType(wxDocTemplate **templates, int noTemplates, bool sort = false );
> //wxDocTemplate * SelectViewType(wxDocTemplate **templates, int noTemplates, bool sort = false );
> void SetLastDirectory(const wxString& dir );
> void SetMaxDocsOpen(int n );

};
// ---------------------------------------------------------------------------
// wxDocMDIChildFrame
//%include "wx/docmdi.h"
//class wxDocMDIChildFrame : public wxMDIChildFrame FIXME
//{
// wxDocMDIChildFrame(wxDocument* doc, wxView* view, wxFrame* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocMDIChildFrame" );
//
// wxDocument* GetDocument() const;
// wxView* GetView() const;
// void OnActivate(wxActivateEvent event );
// void OnCloseWindow(wxCloseEvent& event );
// void SetDocument(wxDocument *doc );
// void SetView(wxView *view );
//}
// ---------------------------------------------------------------------------
// wxDocMDIParentFrame
//%include "wx/docmdi.h"
//class wxDocMDIParentFrame : public wxMDIParentFrame FIXME
//{
// wxDocMDIParentFrame(wxDocManager* manager, wxFrame *parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocMDIParentFrame" );
//
// void OnCloseWindow(wxCloseEvent& event );
//}
// ---------------------------------------------------------------------------
// wxDocParentFrame
class wxDocParentFrame : public wxFrame
{

> wxDocParentFrame(wxDocManager* manager, wxFrame *parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxDocParentFrame" );
> //void OnCloseWindow(wxCloseEvent& event );

};
// ---------------------------------------------------------------------------
// wxDocTemplate
#define wxTEMPLATE_VISIBLE
#define wxTEMPLATE_INVISIBLE
#define wxDEFAULT_TEMPLATE_FLAGS
class wxDocTemplate : public wxObject
{

> wxDocTemplate(wxDocManager* manager, const wxString& descr, const wxString& filter, const wxString& dir, const wxString& ext, const wxString& docTypeName, const wxString& viewTypeName, wxClassInfo* docClassInfo = NULL, wxClassInfo* viewClassInfo = NULL, long flags = wxDEFAULT_TEMPLATE_FLAGS );
> wxDocument* CreateDocument(const wxString& path, long flags = 0 );
> wxView* CreateView(wxDocument *doc, long flags = 0 );
> wxString GetDefaultExtension( );
> wxString GetDescription( );
> wxString GetDirectory( );
> wxDocManager * GetDocumentManager( );
> wxString GetDocumentName( );
> wxString GetFileFilter( );
> long GetFlags( );
> wxString GetViewName( );
> bool InitDocument(wxDocument* doc, const wxString& path, long flags = 0 );
> bool IsVisible( );
> void SetDefaultExtension(const wxString& ext );
> void SetDescription(const wxString& descr );
> void SetDirectory(const wxString& dir );
> void SetDocumentManager(wxDocManager *manager );
> void SetFileFilter(const wxString& filter );
> void SetFlags(long flags );

};
// ---------------------------------------------------------------------------
// wxDocument
class wxDocument : public wxEvtHandler
{

> wxDocument( );
> virtual bool AddView(wxView *view );
> virtual bool Close( );
> virtual bool DeleteAllViews( );
> wxCommandProcessor* GetCommandProcessor() const;
> wxDocTemplate* GetDocumentTemplate() const;
> wxDocManager* GetDocumentManager() const;
> wxString GetDocumentName() const;
> wxWindow* GetDocumentWindow() const;
> wxString GetFilename() const;
> wxView * GetFirstView() const;
> // %override [string name] wxDocument::GetPrintableName(wxString& name) const;
> // C++ Func: virtual void GetPrintableName(wxString& name) const;
> virtual void GetPrintableName(wxString& name) const;
> wxString GetTitle() const;
> wxList& GetViews() const;
> virtual bool IsModified() const;
> //virtual istream& LoadObject(istream& stream );
> //virtual wxInputStream& LoadObject(wxInputStream& stream );
> virtual void Modify(bool modify );
> virtual void OnChangedViewList( );
> virtual bool OnCloseDocument( );
> virtual bool OnCreate(const wxString& path, long flags );
> virtual wxCommandProcessor* OnCreateCommandProcessor( );
> virtual bool OnNewDocument( );
> virtual bool OnOpenDocument(const wxString& filename );
> virtual bool OnSaveDocument(const wxString& filename );
> virtual bool OnSaveModified( );
> virtual bool RemoveView(wxView* view );
> virtual bool Save( );
> virtual bool SaveAs( );
> //virtual ostream& SaveObject(ostream& stream );
> //virtual wxOutputStream& SaveObject(wxOutputStream& stream );
> virtual void SetCommandProcessor(wxCommandProcessor *processor );
> void SetDocumentName(const wxString& name );
> void SetDocumentTemplate(wxDocTemplate* templ );
> void SetFilename(const wxString& filename, bool notifyViews = false );
> void SetTitle(const wxString& title );
> void UpdateAllViews(wxView* sender = NULL, wxObject* hint = NULL );

};
// ---------------------------------------------------------------------------
// wxView
class wxView : public wxEvtHandler
{

> //wxView( );
> virtual void Activate(bool activate );
> virtual bool Close(bool deleteWindow = true );
> wxDocument* GetDocument() const;
> wxDocManager* GetDocumentManager() const;
> wxWindow * GetFrame( );
> wxString GetViewName() const;
> virtual void OnActivateView(bool activate, wxView *activeView, wxView *deactiveView );
> virtual void OnChangeFilename( );
> virtual bool OnClose(bool deleteWindow );
> //virtual void OnClosingDoocument( );
> virtual bool OnCreate(wxDocument* doc, long flags );
> virtual wxPrintout* OnCreatePrintout( );
> //virtual void OnDraw(wxDC& dc );
> virtual void OnUpdate(wxView* sender, wxObject* hint );
> void SetDocument(wxDocument* doc );
> void SetFrame(wxFrame* frame );
> void SetViewName(const wxString& name );

};
#endif //wxLUA_USE_MDI && wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
// ---------------------------------------------------------------------------
// wxCommandProcessor
#if wxLUA_USE_wxCommandProcessor
#include "wx/cmdproc.h"
class wxCommandProcessor : public wxObject
{

> wxCommandProcessor(int maxCommands = -1 );
> virtual bool CanRedo() const;
> virtual bool CanUndo() const;
> virtual bool Redo( );
> virtual bool Undo( );
> virtual void ClearCommands( );
> wxList& GetCommands() const;
> int GetMaxCommands() const;
> wxMenu *GetEditMenu() const;
> wxString GetRedoAccelerator() const;
> wxString GetRedoMenuLabel() const;
> wxString GetUndoAccelerator() const;
> wxString GetUndoMenuLabel() const;
> virtual void Initialize( );
> virtual bool IsDirty( );
> virtual void MarkAsSaved( );
> void SetEditMenu(wxMenu *menu );
> virtual void SetMenuStrings( );
> void SetRedoAccelerator(const wxString& accel );
> void SetUndoAccelerator(const wxString& accel );
> virtual bool Submit(wxCommand *command, bool storeIt = true );
> virtual void Store(wxCommand *command );
> wxCommand *GetCurrentCommand() const;

};
// ---------------------------------------------------------------------------
// wxCommand
class wxCommand : public wxObject
{

> //wxCommand(bool canUndo = false, const wxString& name = "" );
> virtual bool CanUndo( );
> virtual bool Do(); // pure virtual
> virtual wxString GetName( );
> virtual bool Undo(); // pure virtual

};
#endif //wxLUA_USE_wxCommandProcessor
// ---------------------------------------------------------------------------
// wxFileHistory
#if wxLUA_USE_wxFileHistory && wxUSE_DOC_VIEW_ARCHITECTURE
#include "wx/docview.h"
class %delete wxFileHistory : public wxObject
{

> wxFileHistory(int maxFiles = 9, wxWindowID idBase = wxID_FILE1 );
> void AddFileToHistory(const wxString& filename );
> void AddFilesToMenu( );
> void AddFilesToMenu(wxMenu* menu );
> wxString GetHistoryFile(int index) const;
> int GetMaxFiles() const;
> size_t GetCount() const;
> void Load(wxConfigBase& config );
> void RemoveFileFromHistory(size_t i );
> void RemoveMenu(wxMenu* menu );
> void Save(wxConfigBase& config );
> void UseMenu(wxMenu* menu );

};
#endif //wxLUA_USE_wxFileHistory && wxUSE_DOC_VIEW_ARCHITECTURE

## wxwidgets/wxcore_menutool.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxMenu and wxToolbar classes
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxMenu
#if wxLUA_USE_wxMenu && wxUSE_MENUS
#include "wx/menu.h"
enum wxItemKind
{

> wxITEM_SEPARATOR,
> wxITEM_NORMAL,
> wxITEM_CHECK,
> wxITEM_RADIO,
> wxITEM_MAX

};
#define wxMB_DOCKABLE
#define wxMENU_TEAROFF
class %delete wxMenu : public wxEvtHandler
{

> wxMenu(const wxString& title = "", long style = 0 );
> // %override wxMenu* wxMenu({{wx.wxID_NEW, "&New\tCtrl-N", "New doc", [wx.wxITEM_NORMAL]}, {}, {item 2}}, const wxString& title = "", long style = "") - empty tables are separators
> // wxLua provides this function
> %override_name wxLua_wxCreateMenu_constructor wxMenu(LuaTable, const wxString& title = "", long style = 0 );
> wxMenuItem* Append(int id, const wxString& item, const wxString& helpString = "", wxItemKind kind = wxITEM_NORMAL );
> wxMenuItem* Append(int id, const wxString& item, %ungc wxMenu *subMenu, const wxString& helpString = "" );
> wxMenuItem* Append(%ungc wxMenuItem* menuItem );
> wxMenuItem* AppendCheckItem(int id, const wxString& item, const wxString& helpString = "" );
> wxMenuItem* AppendRadioItem(int id, const wxString& item, const wxString& helpString = "" );
> wxMenuItem* AppendSeparator( );
> void Break( );
> void Check(int id, bool check );
> void Delete(int id );
> void Delete(wxMenuItem *item );
> void Destroy(int id );
> void Destroy(wxMenuItem *item );
> void Enable(int id, bool enable );
> int FindItem(const wxString& itemString) const;
> // %override [wxMenuItem* menuItem, wxMenu* ownerMenu] wxMenu::FindItem(int id );
> // C++ Func: wxMenuItem* FindItem(int id, wxMenu **menu = NULL) const;
> %override_name wxLua_wxMenu_FindItemById wxMenuItem* FindItem(int id) const;
> wxMenuItem* FindItemByPosition(size_t position) const;
> wxString GetHelpString(int id) const;
> wxString GetLabel(int id) const;
> size_t GetMenuItemCount() const;
> wxMenuItemList& GetMenuItems() const;
> wxString GetTitle() const;
> wxMenuItem* Insert(size_t pos, int id, const wxString& item, const wxString& helpString = "", wxItemKind kind = wxITEM_NORMAL );
> wxMenuItem* Insert(size_t pos, %ungc wxMenuItem *item );
> wxMenuItem* InsertCheckItem(size_t pos, int id, const wxString& item, const wxString& helpString = "" );
> wxMenuItem* InsertRadioItem(size_t pos, int id, const wxString& item, const wxString& helpString = "" );
> wxMenuItem* InsertSeparator(size_t pos );
> bool IsChecked(int id) const;
> bool IsEnabled(int id) const;
> wxMenuItem* Prepend(int id, const wxString& item, const wxString& helpString = "", wxItemKind kind = wxITEM_NORMAL );
> wxMenuItem* Prepend(%ungc wxMenuItem *item );
> wxMenuItem* PrependCheckItem(int id, const wxString& item, const wxString& helpString = "" );
> wxMenuItem* PrependRadioItem(int id, const wxString& item, const wxString& helpString = "" );
> wxMenuItem* PrependSeparator( );
> %gc wxMenuItem* Remove(wxMenuItem *item );
> %gc wxMenuItem* Remove(int id );
> void SetHelpString(int id, const wxString& helpString );
> void SetLabel(int id, const wxString& label );
> void SetTitle(const wxString& title );
> void UpdateUI(wxEvtHandler* source = NULL) const;

};
// ---------------------------------------------------------------------------
// wxMenuBar
class wxMenuBar : public wxWindow
{

> wxMenuBar(long style = 0 );
> // void wxMenuBar(int n, wxMenu* menus[], const wxString titles[] );
> bool Append(%ungc wxMenu *menu, const wxString& title );
> void Check(int id, bool check );
> void Enable(int id, bool enable );
> void EnableTop(int pos, bool enable );
> int FindMenu(const wxString& title) const;
> int FindMenuItem(const wxString& menuString, const wxString& itemString) const;
> wxMenuItem* FindItem(int id, wxMenu **menu = NULL) const;
> wxString GetHelpString(int id) const;
> wxString GetLabel(int id) const;
> wxMenu* GetMenu(int menuIndex) const;
> int GetMenuCount() const;
> bool Insert(size_t pos, %ungc wxMenu *menu, const wxString& title );
> bool IsChecked(int id) const;
> bool IsEnabled(int id) const;
> void Refresh( );
> %gc wxMenu* Remove(size_t pos );
> %gc wxMenu* Replace(size_t pos, %ungc wxMenu *menu, const wxString& title );
> void SetHelpString(int id, const wxString& helpString );
> void SetLabel(int id, const wxString& label );
> %wxchkver_2_8 virtual void UpdateMenus( );
> #if !%wxchkver_3_0 || %wxcompat_2_8
> wxString GetLabelTop(int pos) const;
> void SetLabelTop(int pos, const wxString& label);
> #endif
> #if %wxchkver_3_0
> void SetMenuLabel(size_t pos, const wxString& label);
> wxString GetMenuLabel(size_t pos) const;
> wxString GetMenuLabelText(size_t pos) const;
> #endif

};
// ---------------------------------------------------------------------------
// wxMenuItem
//
// Note: this is almost always owned by a wxMenu, however you can get an
// unattached one from wxMenu::Remove() so that's why we gc collect it.
#include "wx/menuitem.h"
class %delete wxMenuItem : public wxObject
{

> %ungc_this wxMenuItem(wxMenu *parentMenu = NULL, int id = wxID_SEPARATOR, const wxString& text = "", const wxString& help = "", wxItemKind kind = wxITEM_NORMAL, wxMenu *subMenu = NULL );
> void Check(bool check );
> void Enable(bool enable );
> //%win wxColour GetBackgroundColour() const;
> //%win wxBitmap GetBitmap(bool checked = true) const;
> //%win wxFont GetFont() const;
> wxString GetHelp() const;
> int GetId() const;
> wxItemKind GetKind() const;
> //%win int GetMarginWidth() const;
> wxMenu* GetMenu() const;
> // wxString GetName() const; - deprecated
> wxMenu* GetSubMenu() const;
> //%win wxColour& GetTextColour() const;
> bool IsCheckable() const;
> bool IsChecked() const;
> bool IsEnabled() const;
> bool IsSeparator() const;
> bool IsSubMenu() const;
> //%win void SetBackgroundColour(const wxColour& colour) const;
> void SetBitmap(const wxBitmap& bmp );
> //%win void SetBitmaps(const wxBitmap& checked, const wxBitmap& unchecked = wxNullBitmap) const;
> //%win void SetFont(const wxFont& font) const;
> void SetHelp(const wxString& helpString) const;
> //%win void SetMarginWidth(int width) const;
> //void SetMenu(wxMenu* menu );
> void SetSubMenu(wxMenu* menu );
> // void SetName(const wxString& text) const; - deprecated
> %win void SetTextColour(const wxColour& colour) const;
> #if %wxchkver_2_8
> void SetItemLabel(const wxString& str );
> wxString GetItemLabel() const;
> wxString GetItemLabelText() const;
> static wxString GetLabelText(const wxString& label );
> #endif
> #if !%wxchkver_3_0 || %wxcompat_2_8
> wxString GetLabel() const;
> static wxString GetLabelFromText(const wxString& text );
> wxString GetText() const;
> void SetText(const wxString& text );
> #endif
> #if %wxchkver_3_0
> wxString GetItemLabelText() const;
> static wxString GetLabelText(const wxString& label);
> wxString GetItemLabel() const;
> void SetItemLabel(const wxString& str);
> #endif

};
// ---------------------------------------------------------------------------
// wxMenuItemList
class wxMenuItemList : public wxList
{

> // no constructor, you only get this back from wxMenu::GetMenuItems
> // Use the wxList methods, see also wxNode

};
// ---------------------------------------------------------------------------
// wxMenuEvent
#include "wx/event.h"
class %delete wxMenuEvent : public wxEvent
{

> %wxEventType wxEVT_MENU_HIGHLIGHT // EVT_MENU_HIGHLIGHT(winid, func) EVT_MENU_HIGHLIGHT_ALL(func );
> %wxEventType wxEVT_MENU_OPEN // EVT_MENU_OPEN(func );
> %wxEventType wxEVT_MENU_CLOSE // EVT_MENU_CLOSE(func );
> wxMenuEvent(wxEventType type = wxEVT_NULL, int id = 0, wxMenu* menu = NULL );
> wxMenu* GetMenu() const;
> int GetMenuId() const;
> bool IsPopup() const;

};
#endif //wxLUA_USE_wxMenu && wxUSE_MENUS
// ---------------------------------------------------------------------------
// wxToolBarBase
#if wxLUA_USE_wxToolbar
#include "wx/tbarbase.h"
#define wxTB_FLAT
#define wxTB_DOCKABLE
#define wxTB_HORIZONTAL
#define wxTB_VERTICAL
#define wxTB_3DBUTTONS
#define wxTB_TEXT
#define wxTB_NOICONS
#define wxTB_NODIVIDER
#define wxTB_NOALIGN
#define wxTB_HORZ_LAYOUT
#define wxTB_HORZ_TEXT
class wxToolBarBase : public wxControl
{

> // no constructors base class
> wxToolBarToolBase* AddControl(wxControl *control );
> wxToolBarToolBase* AddSeparator( );
> wxToolBarToolBase* AddTool(int toolId, const wxString& label, const wxBitmap& bitmap1, const wxBitmap& bitmap2 = wxNullBitmap, wxItemKind kind = wxITEM_NORMAL, const wxString& shortHelpString = "", const wxString& longHelpString = "", wxObject* clientData = NULL );
> wxToolBarToolBase* AddTool(int toolId, const wxString& label, const wxBitmap& bitmap1, const wxString& shortHelpString = "", wxItemKind kind = wxITEM_NORMAL );
> //wxToolBarToolBase* AddTool(wxToolBarToolBase* tool );
> wxToolBarToolBase *AddCheckTool(int toolid, const wxString& label, const wxBitmap& bitmap, const wxBitmap& bmpDisabled = wxNullBitmap, const wxString& shortHelp = "", const wxString& longHelp = "", wxObject *data = NULL );
> wxToolBarToolBase *AddRadioTool(int toolid, const wxString& label, const wxBitmap& bitmap, const wxBitmap& bmpDisabled = wxNullBitmap, const wxString& shortHelp = "", const wxString& longHelp = "", wxObject *data = NULL );
> void ClearTools( );
> bool DeleteTool(int toolId );
> bool DeleteToolByPos(size_t pos );
> void EnableTool(int toolId, const bool enable );
> wxToolBarToolBase* FindById(int id );
> wxControl* FindControl(int id );
> wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const;
> int GetMaxRows( );
> int GetMaxCols( );
> wxSize GetToolSize( );
> wxSize GetToolBitmapSize( );
> wxObject* GetToolClientData(int toolId) const;
> bool GetToolEnabled(int toolId) const;
> wxString GetToolLongHelp(int toolId) const;
> wxSize GetToolMargins(); // GetMargins is deprecated
> int GetToolPacking( );
> int GetToolPos(int toolId) const;
> int GetToolSeparation() const;
> wxString GetToolShortHelp(int toolId) const;
> bool GetToolState(int id );
> wxToolBarToolBase* InsertControl(size_t pos, wxControl *control );
> wxToolBarToolBase* InsertSeparator(size_t pos );
> #if !%wxchkver_3_0 || %wxcompat_2_8
> wxToolBarToolBase* InsertTool(size_t pos, int id, const wxBitmap& bitmap, const wxBitmap& pushedBitmap = wxNullBitmap, bool isToggle = false, wxObject *clientData = NULL, const wxString& shortHelpString = "", const wxString& longHelpString = "" );
> #endif
> wxToolBarToolBase* InsertTool(size_t pos, int toolid, const wxString& label, const wxBitmap& bitmap, const wxBitmap& bmpDisabled = wxNullBitmap, wxItemKind kind = wxITEM_NORMAL, const wxString& shortHelp = "", const wxString& longHelp = "", wxObject *clientData = NULL );
> //wxToolBarToolBase * InsertTool(size_t pos, wxToolBarToolBase* tool );
> wxToolBarToolBase* RemoveTool(int id );
> bool Realize( );
> void SetMargins(int x, int y );
> void SetMargins(const wxSize& size );
> void SetToolBitmapSize(const wxSize& size );
> void SetToolClientData(int id, wxObject* clientData );
> void SetToolLongHelp(int toolId, const wxString& helpString );
> void SetToolPacking(int packing );
> void SetToolShortHelp(int id, const wxString& helpString );
> void SetToolSeparation(int separation );
> void SetToggle(int id, bool toggle );
> void SetRows(int nRows );
> void SetMaxRowsCols(int rows, int cols );
> void ToggleTool(int toolId, const bool toggle );

};
// ---------------------------------------------------------------------------
// wxToolBar
#include "wx/toolbar.h"
class wxToolBar : public wxToolBarBase
{

> wxToolBar( );
> wxToolBar(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxNO_BORDER | wxTB_HORIZONTAL, const wxString &name = "wxToolBar" );
> bool Create(wxWindow *parent,wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxNO_BORDER | wxTB_HORIZONTAL, const wxString &name = "wxToolBar" );

};
// ---------------------------------------------------------------------------
// wxToolBarSimple
#if !%wxchkver_2_6
#include "wx/tbarsmpl.h"
class wxToolBarSimple : public wxToolBarBase
{

> wxToolBarSimple( );
> wxToolBarSimple(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxNO_BORDER | wxTB_HORIZONTAL, const wxString &name = wxToolBarNameStr );
> bool Create(wxWindow *parent,wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxNO_BORDER | wxTB_HORIZONTAL, const wxString &name = wxToolBarNameStr );

};
#endif // !%wxchkver_2_6
// ---------------------------------------------------------------------------
// wxToolBarToolBase
// these are unused
//#define wxTOOL_BOTTOM
//#define wxTOOL_LEFT
//#define wxTOOL_RIGHT
//#define wxTOOL_TOP
enum wxToolBarToolStyle
{

> wxTOOL_STYLE_BUTTON,
> wxTOOL_STYLE_SEPARATOR,
> wxTOOL_STYLE_CONTROL

};
class wxToolBarToolBase : public wxObject
{

> // no constructors
> int GetId( );
> wxControl *GetControl( );
> wxToolBarBase *GetToolBar( );
> int IsButton( );
> int IsControl( );
> int IsSeparator( );
> int GetStyle( );
> wxItemKind GetKind() const;
> bool IsEnabled( );
> bool IsToggled( );
> bool CanBeToggled( );
> wxBitmap GetNormalBitmap( );
> wxBitmap GetDisabledBitmap( );
> wxBitmap GetBitmap( );
> wxString GetLabel( );
> wxString GetShortHelp( );
> wxString GetLongHelp( );
> bool Enable(bool enable );
> bool Toggle(bool toggle );
> bool SetToggle(bool toggle );
> bool SetShortHelp(const wxString& help );
> bool SetLongHelp(const wxString& help );
> void SetNormalBitmap(const wxBitmap& bmp );
> void SetDisabledBitmap(const wxBitmap& bmp );
> void SetLabel(const wxString& label );
> void Detach( );
> void Attach(wxToolBarBase *tbar );
> wxObject *GetClientData( );
> void SetClientData(wxObject* clientData );

};
// ---------------------------------------------------------------------------
// wxToolBarTool - This class doesn't exist!
//class wxToolBarTool : public wxToolBarToolBase
//{
//};
#endif //wxLUA_USE_wxToolbar
// ---------------------------------------------------------------------------
// wxAcceleratorTable
#if wxLUA_USE_wxAcceleratorTable && wxUSE_ACCEL
#include "wx/accel.h"
class %delete wxAcceleratorTable : public wxObject
{

> #define_object wxNullAcceleratorTable
> // %override wxAcceleratorTable(Lua table with this format );
> // { { wx.wxACCEL_NORMAL, string.byte('0'), ID_0 },
> // { wx.wxACCEL_NORMAL, wx.VXK_NUMPAD0, ID_0 } }
> // C++ Func: wxAcceleratorTable(int n, wxAcceleratorEntry* entries );
> wxAcceleratorTable(LuaTable accelTable );
> wxAcceleratorTable(const wxAcceleratorTable& accel );
> bool Ok() const;
> //%wxchkver_2_8 bool IsOk() const;
> // believe it or not, there aren't functions to add or remove wxAcceleratorEntries for MSW
> // operators are WXWIN_COMPATIBILITY_2_4

};
// ---------------------------------------------------------------------------
// wxAcceleratorEntry
%wxcompat_2_6 wxAcceleratorEntry* wxGetAccelFromString(const wxString& label); // deprecated in 2.8 use wxAcceleratorEntry::Create() or FromString( );
#include "wx/accel.h"
enum
{
wxACCEL_NORMAL,
wxACCEL_ALT,
wxACCEL_CTRL,
wxACCEL_SHIFT,
%wxchkver_2_8 wxACCEL_CMD // Command key on OS X else wxACCEL_CTRL
};
class %delete wxAcceleratorEntry
{

> wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0, wxMenuItem *item = NULL );
> wxAcceleratorEntry(const wxAcceleratorEntry& entry );
> int GetCommand() const;
> int GetFlags() const;
> int GetKeyCode() const;
> void Set(int flags, int keyCode, int Cmd, wxMenuItem *item = NULL );
> #if %wxchkver_2_8
> static %gc wxAcceleratorEntry *Create(const wxString& str );
> bool IsOk() const;
> wxString ToString() const;
> bool FromString(const wxString& str );
> wxMenuItem *GetMenuItem() const;
> #endif // %wxchkver_2_8
> // these are probably not necessary
> //wxAcceleratorEntry& operator=(const wxAcceleratorEntry& entry );
> //bool operator==(const wxAcceleratorEntry& entry) const;
> //bool operator!=(const wxAcceleratorEntry& entry) const;

};
#endif //wxLUA_USE_wxAcceleratorTable && wxUSE_ACCEL

## wxwidgets/wxcore_picker.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxPickerXXX controls
// Author: John Labenski
// Created: 14/11/2001
// Copyright: (c) 2007 John Labenski
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if %wxchkver_2_8 && wxLUA_USE_wxPicker
// ---------------------------------------------------------------------------
// wxPickerBase
#include "wx/pickerbase.h"
#define wxPB_USE_TEXTCTRL
class wxPickerBase : public wxControl
{

> // No construcor - this is a base class
> // margin between the text control and the picker
> void SetInternalMargin(int newmargin );
> int GetInternalMargin() const;
> // proportion of the text control
> void SetTextCtrlProportion(int prop );
> int GetTextCtrlProportion() const;
> // proportion of the picker control
> void SetPickerCtrlProportion(int prop );
> int GetPickerCtrlProportion() const;
> bool IsTextCtrlGrowable() const;
> void SetTextCtrlGrowable(bool grow = true );
> bool IsPickerCtrlGrowable() const;
> void SetPickerCtrlGrowable(bool grow = true );
> bool HasTextCtrl() const;
> wxTextCtrl *GetTextCtrl( );
> wxControl *GetPickerCtrl( );
> // methods that derived class must/may override
> virtual void UpdatePickerFromTextCtrl( );
> virtual void UpdateTextCtrlFromPicker( );

};
// ---------------------------------------------------------------------------
// wxColourPickerCtrl
#if wxLUA_USE_wxColourPickerCtrl && wxUSE_COLOURPICKERCTRL
#include "wx/clrpicker.h"
#define wxCLRP_SHOW_LABEL
#define wxCLRP_USE_TEXTCTRL
#define wxCLRP_DEFAULT_STYLE
class wxColourPickerCtrl : public wxPickerBase
{

> wxColourPickerCtrl( );
> // Note default color is *wxBLACK
> wxColourPickerCtrl(wxWindow *parent, wxWindowID id, const wxColour& col, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCLRP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxColourPickerCtrl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxColour& col, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCLRP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxColourPickerCtrl" );
> // get the colour chosen
> wxColour GetColour() const;
> // set currently displayed color
> void SetColour(const wxColour& col );
> // set colour using RGB(r,g,b) syntax or considering given text as a colour name;
> // returns true if the given text was successfully recognized.
> bool SetColour(const wxString& text );

};
// ---------------------------------------------------------------------------
// wxColourPickerEvent
class %delete wxColourPickerEvent : public wxCommandEvent
{

> %wxEventType wxEVT_COMMAND_COLOURPICKER_CHANGED // EVT_COLOURPICKER_CHANGED(id, func );
> wxColourPickerEvent( );
> wxColourPickerEvent(wxObject *generator, int id, const wxColour &col );
> wxColour GetColour() const;
> void SetColour(const wxColour &c );

};
#endif //wxLUA_USE_wxColourPickerCtrl && wxUSE_COLOURPICKERCTRL
// ---------------------------------------------------------------------------
// wxDatePickerCtrl
#if wxLUA_USE_wxDatePickerCtrl && wxUSE_DATEPICKCTRL
#include "wx/datectrl.h"
// Note: this sends a wxDateEvent wxEVT_DATE_CHANGED // EVT_DATE_CHANGED(id, fn );
enum
{
wxDP_SPIN, // MSW only
wxDP_DROPDOWN,
wxDP_DEFAULT,
wxDP_ALLOWNONE,
wxDP_SHOWCENTURY
};
class wxDatePickerCtrl : public wxControl
{

> wxDatePickerCtrl( );
> wxDatePickerCtrl(wxWindow *parent, wxWindowID id, const wxDateTime& dt = wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDP_DEFAULT | wxDP_SHOWCENTURY, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxDatePickerCtrl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxDateTime& dt = wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDP_DEFAULT | wxDP_SHOWCENTURY, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxDatePickerCtrl" );
> // %override [bool, wxDateTime dt1, wxDateTime dt2] wxDatePickerCtrl::GetRange() const;
> // C++ Func: bool GetRange(wxDateTime *dt1, wxDateTime *dt2) const;
> bool GetRange() const;
> wxDateTime GetValue() const;
> void SetRange(const wxDateTime& dt1, const wxDateTime& dt2 );
> void SetValue(const wxDateTime& dt );

};
#endif //wxLUA_USE_wxDatePickerCtrl && wxUSE_DATEPICKCTRL
// ---------------------------------------------------------------------------
// wxFileDirPickerCtrlBase
#if (wxLUA_USE_wxDirPickerCtrl || wxLUA_USE_wxFilePickerCtrl) && (wxUSE_FILEPICKERCTRL || wxUSE_DIRPICKERCTRL );
#include "wx/filepicker.h"
class wxFileDirPickerCtrlBase : public wxPickerBase
{

> // No constructor - this is a base class
> wxString GetPath() const;
> void SetPath(const wxString &str );
> // return true if the given path is valid for this control
> // bool CheckPath(const wxString& path) const; - Removed in 2.9.5
> // return the text control value in canonical form
> wxString GetTextCtrlValue() const;

};
// ---------------------------------------------------------------------------
// wxFileDirPickerEvent
class %delete wxFileDirPickerEvent : public wxCommandEvent
{

> %wxEventType wxEVT_COMMAND_FILEPICKER_CHANGED // EVT_FILEPICKER_CHANGED(id, fn );
> %wxEventType wxEVT_COMMAND_DIRPICKER_CHANGED // EVT_DIRPICKER_CHANGED(id, fn );
> //wxFileDirPickerEvent( );
> wxFileDirPickerEvent(wxEventType type, wxObject *generator, int id, const wxString &path );
> wxString GetPath() const;
> void SetPath(const wxString &p );

};
#endif // (wxLUA_USE_wxDirPickerCtrl || wxLUA_USE_wxFilePickerCtrl) && (wxUSE_FILEPICKERCTRL || wxUSE_DIRPICKERCTRL );
// ---------------------------------------------------------------------------
// wxDirPickerCtrl
#if wxLUA_USE_wxDirPickerCtrl && (wxUSE_FILEPICKERCTRL || wxUSE_DIRPICKERCTRL );
#define wxDIRP_DIR_MUST_EXIST
#define wxDIRP_CHANGE_DIR
#define wxDIRP_DEFAULT_STYLE
#define wxDIRP_USE_TEXTCTRL
class wxDirPickerCtrl : public wxFileDirPickerCtrlBase
{

> wxDirPickerCtrl( );
> wxDirPickerCtrl(wxWindow *parent, wxWindowID id, const wxString& path = "", const wxString& message = wxDirSelectorPromptStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDIRP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxDirPickerCtrl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxString& path = "", const wxString& message = wxDirSelectorPromptStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDIRP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxDirPickerCtrl" );

};
#endif wxLUA_USE_wxDirPickerCtrl && (wxUSE_FILEPICKERCTRL || wxUSE_DIRPICKERCTRL );
// ---------------------------------------------------------------------------
// wxFilePickerCtrl
#if wxLUA_USE_wxDirPickerCtrl && (wxUSE_FILEPICKERCTRL || wxUSE_DIRPICKERCTRL );
#define wxFLP_OPEN
#define wxFLP_SAVE
#define wxFLP_OVERWRITE_PROMPT
#define wxFLP_FILE_MUST_EXIST
#define wxFLP_CHANGE_DIR
#define wxFLP_DEFAULT_STYLE
#define wxFLP_USE_TEXTCTRL
class wxFilePickerCtrl : public wxFileDirPickerCtrlBase
{

> wxFilePickerCtrl( );
> wxFilePickerCtrl(wxWindow *parent, wxWindowID id, const wxString& path = "", const wxString& message = wxFileSelectorPromptStr, const wxString& wildcard = wxFileSelectorDefaultWildcardStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxFLP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxFilePickerCtrl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxString& path = "", const wxString& message = wxFileSelectorPromptStr, const wxString& wildcard = wxFileSelectorDefaultWildcardStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxFLP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxFilePickerCtrl" );

};
#endif // wxLUA_USE_wxDirPickerCtrl && (wxUSE_FILEPICKERCTRL || wxUSE_DIRPICKERCTRL );
// ---------------------------------------------------------------------------
// wxFontPickerCtrl
#if wxLUA_USE_wxFontPickerCtrl && wxUSE_FONTPICKERCTRL
#include "wx/fontpicker.h"
#define wxFNTP_FONTDESC_AS_LABEL
#define wxFNTP_USEFONT_FOR_LABEL
#define wxFNTP_USE_TEXTCTRL // (wxFNTP_FONTDESC_AS_LABEL|wxFNTP_USEFONT_FOR_LABEL );
#define wxFNTP_DEFAULT_STYLE
#define wxFNTP_MAXPOINT_SIZE // 100 the default max size to allow
class wxFontPickerCtrl : public wxPickerBase
{

> wxFontPickerCtrl( );
> wxFontPickerCtrl(wxWindow *parent, wxWindowID id, const wxFont& initial = wxNullFont, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxFNTP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxFontPickerCtrl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxFont& initial = wxNullFont, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxFNTP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxFontPickerCtrl" );
> wxFont GetSelectedFont() const;
> virtual void SetSelectedFont(const wxFont &f );
> void SetMaxPointSize(unsigned int max );
> unsigned int GetMaxPointSize() const;

};
// ---------------------------------------------------------------------------
// wxFontPickerEvent
class %delete wxFontPickerEvent : public wxCommandEvent
{

> %wxEventType wxEVT_COMMAND_FONTPICKER_CHANGED // EVT_FONTPICKER_CHANGED(id, fn );
> //wxFontPickerEvent( );
> wxFontPickerEvent(wxObject *generator, int id, const wxFont &f );
> wxFont GetFont() const;
> void SetFont(const wxFont &c );

};
#endif // wxLUA_USE_wxFontPickerCtrl && wxUSE_FONTPICKERCTRL
#endif // %wxchkver_2_8 && wxLUA_USE_wxPicker

## wxwidgets/wxcore_print.i - Lua table = 'wx'

// ===========================================================================
// Purpose: printing related classes
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxPrint && wxUSE_PRINTING_ARCHITECTURE
typedef wxScrolledWindow wxPreviewWindow
#include "wx/print.h"
// ---------------------------------------------------------------------------
// wxPrintout
class wxPrintout : public wxObject
{

> // virtual class, use wxLuaPrintout
> wxDC * GetDC( );
> // %override [int minPage, int maxPage, int pageFrom, int pageTo] wxPrintout::GetPageInfo( );
> // C++ Func: void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo );
> void GetPageInfo( );
> // %override [int w, int h] wxPrintout::GetPageSizeMM( );
> // C++ Func: void GetPageSizeMM(int *w, int *h );
> void GetPageSizeMM( );
> // %override [int w, int h] wxPrintout::GetPageSizePixels( );
> // C++ Func: void GetPageSizePixels(int *w, int *h );
> void GetPageSizePixels( );
> // %override [int w, int h] wxPrintout::GetPPIPrinter( );
> // C++ Func: void GetPPIPrinter(int *w, int *h );
> void GetPPIPrinter( );
> // %override [int w, int h] wxPrintout::GetPPIScreen( );
> // C++ Func: void GetPPIScreen(int *w, int *h );
> void GetPPIScreen( );
> wxString GetTitle( );
> bool HasPage(int pageNum );
> bool IsPreview( );
> bool OnBeginDocument(int startPage, int endPage );
> void OnEndDocument( );
> void OnBeginPrinting( );
> void OnEndPrinting( );
> void OnPreparePrinting( );
> bool OnPrintPage(int pageNum );

};
// ---------------------------------------------------------------------------
// wxLuaPrintout
#if wxLUA_USE_wxLuaPrintout
#include "wxlua/wxlua_bind.h" // for wxLuaObject tag
#include "wxbind/include/wxcore_wxlcore.h"
class %delete wxLuaPrintout : public wxPrintout
{

> // %override - the C++ function takes the wxLuaState as the first param
> wxLuaPrintout(const wxString& title = "Printout", wxLuaObject *pObject = NULL );
> wxLuaObject *GetID( );
> // This is an added function to wxPrintout so you don't have to override GetPageInfo
> void SetPageInfo(int minPage, int maxPage, int pageFrom = 0, int pageTo = 0 );
> // The functions below are all virtual functions that you can override in Lua.
> // See the printing sample and wxPrintout for proper parameters and usage.
> //void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo );
> //bool HasPage(int pageNum );
> //bool OnBeginDocument(int startPage, int endPage );
> //void OnEndDocument( );
> //void OnBeginPrinting( );
> //void OnEndPrinting( );
> //void OnPreparePrinting( );
> //bool OnPrintPage(int pageNum );
> // Dummy test function to directly verify that the binding virtual functions really work.
> // This base class function appends "-Base" to the val string and returns it.
> virtual wxString TestVirtualFunctionBinding(const wxString& val); // { return val + wxT("-Base"); }
> static int ms_test_int;

};
// ---------------------------------------------------------------------------
// wxPrinter
enum wxPrinterError
{

> wxPRINTER_NO_ERROR,
> wxPRINTER_CANCELLED,
> wxPRINTER_ERROR

};
class %delete wxPrinter : public wxObject
{

> wxPrinter(wxPrintDialogData* data = NULL );
> //bool Abort( );
> virtual void CreateAbortWindow(wxWindow* parent, wxLuaPrintout* printout );
> bool GetAbort() const;
> static wxPrinterError GetLastError( );
> wxPrintDialogData& GetPrintDialogData( );
> bool Print(wxWindow *parent, wxLuaPrintout *printout, bool prompt=true );
> wxDC* PrintDialog(wxWindow *parent );
> void ReportError(wxWindow *parent, wxLuaPrintout *printout, const wxString& message );
> bool Setup(wxWindow *parent );

};
#endif //wxLUA_USE_wxLuaPrintout
// ---------------------------------------------------------------------------
// wxPrintData
#define wxPORTRAIT
#define wxLANDSCAPE
enum wxDuplexMode
{

> wxDUPLEX_HORIZONTAL,
> wxDUPLEX_SIMPLEX,
> wxDUPLEX_VERTICAL

};
enum wxPaperSize
{

> wxPAPER_NONE,
> wxPAPER_LETTER,
> wxPAPER_LEGAL,
> wxPAPER_A4,
> wxPAPER_CSHEET,
> wxPAPER_DSHEET,
> wxPAPER_ESHEET,
> wxPAPER_LETTERSMALL,
> wxPAPER_TABLOID,
> wxPAPER_LEDGER,
> wxPAPER_STATEMENT,
> wxPAPER_EXECUTIVE,
> wxPAPER_A3,
> wxPAPER_A4SMALL,
> wxPAPER_A5,
> wxPAPER_B4,
> wxPAPER_B5,
> wxPAPER_FOLIO,
> wxPAPER_QUARTO,
> wxPAPER_10X14,
> wxPAPER_11X17,
> wxPAPER_NOTE,
> wxPAPER_ENV_9,
> wxPAPER_ENV_10,
> wxPAPER_ENV_11,
> wxPAPER_ENV_12,
> wxPAPER_ENV_14,
> wxPAPER_ENV_DL,
> wxPAPER_ENV_C5,
> wxPAPER_ENV_C3,
> wxPAPER_ENV_C4,
> wxPAPER_ENV_C6,
> wxPAPER_ENV_C65,
> wxPAPER_ENV_B4,
> wxPAPER_ENV_B5,
> wxPAPER_ENV_B6,
> wxPAPER_ENV_ITALY,
> wxPAPER_ENV_MONARCH,
> wxPAPER_ENV_PERSONAL,
> wxPAPER_FANFOLD_US,
> wxPAPER_FANFOLD_STD_GERMAN,
> wxPAPER_FANFOLD_LGL_GERMAN,
> wxPAPER_ISO_B4,
> wxPAPER_JAPANESE_POSTCARD,
> wxPAPER_9X11,
> wxPAPER_10X11,
> wxPAPER_15X11,
> wxPAPER_ENV_INVITE,
> wxPAPER_LETTER_EXTRA,
> wxPAPER_LEGAL_EXTRA,
> wxPAPER_TABLOID_EXTRA,
> wxPAPER_A4_EXTRA,
> wxPAPER_LETTER_TRANSVERSE,
> wxPAPER_A4_TRANSVERSE,
> wxPAPER_LETTER_EXTRA_TRANSVERSE,
> wxPAPER_A_PLUS,
> wxPAPER_B_PLUS,
> wxPAPER_LETTER_PLUS,
> wxPAPER_A4_PLUS,
> wxPAPER_A5_TRANSVERSE,
> wxPAPER_B5_TRANSVERSE,
> wxPAPER_A3_EXTRA,
> wxPAPER_A5_EXTRA,
> wxPAPER_B5_EXTRA,
> wxPAPER_A2,
> wxPAPER_A3_TRANSVERSE,
> wxPAPER_A3_EXTRA_TRANSVERSE,
> wxPAPER_DBL_JAPANESE_POSTCARD,
> wxPAPER_A6,
> wxPAPER_JENV_KAKU2,
> wxPAPER_JENV_KAKU3,
> wxPAPER_JENV_CHOU3,
> wxPAPER_JENV_CHOU4,
> wxPAPER_LETTER_ROTATED,
> wxPAPER_A3_ROTATED,
> wxPAPER_A4_ROTATED,
> wxPAPER_A5_ROTATED,
> wxPAPER_B4_JIS_ROTATED,
> wxPAPER_B5_JIS_ROTATED,
> wxPAPER_JAPANESE_POSTCARD_ROTATED,
> wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED,
> wxPAPER_A6_ROTATED,
> wxPAPER_JENV_KAKU2_ROTATED,
> wxPAPER_JENV_KAKU3_ROTATED,
> wxPAPER_JENV_CHOU3_ROTATED,
> wxPAPER_JENV_CHOU4_ROTATED,
> wxPAPER_B6_JIS,
> wxPAPER_B6_JIS_ROTATED,
> wxPAPER_12X11,
> wxPAPER_JENV_YOU4,
> wxPAPER_JENV_YOU4_ROTATED,
> wxPAPER_P16K,
> wxPAPER_P32K,
> wxPAPER_P32KBIG,
> wxPAPER_PENV_1,
> wxPAPER_PENV_2,
> wxPAPER_PENV_3,
> wxPAPER_PENV_4,
> wxPAPER_PENV_5,
> wxPAPER_PENV_6,
> wxPAPER_PENV_7,
> wxPAPER_PENV_8,
> wxPAPER_PENV_9,
> wxPAPER_PENV_10,
> wxPAPER_P16K_ROTATED,
> wxPAPER_P32K_ROTATED,
> wxPAPER_P32KBIG_ROTATED,
> wxPAPER_PENV_1_ROTATED,
> wxPAPER_PENV_2_ROTATED,
> wxPAPER_PENV_3_ROTATED,
> wxPAPER_PENV_4_ROTATED,
> wxPAPER_PENV_5_ROTATED,
> wxPAPER_PENV_6_ROTATED,
> wxPAPER_PENV_7_ROTATED,
> wxPAPER_PENV_8_ROTATED,
> wxPAPER_PENV_9_ROTATED,
> wxPAPER_PENV_10_ROTATED

};
enum wxPrintQuality // actually not an enum, but a typedef int
{

> wxPRINT_QUALITY_DRAFT,
> wxPRINT_QUALITY_HIGH,
> wxPRINT_QUALITY_LOW,
> wxPRINT_QUALITY_MEDIUM

};
enum wxPrintMode
{

> wxPRINT_MODE_FILE,
> wxPRINT_MODE_NONE,
> wxPRINT_MODE_PREVIEW,
> wxPRINT_MODE_PRINTER

};
#if %wxchkver_2_6
enum wxPrintBin
{

> wxPRINTBIN_DEFAULT,
> wxPRINTBIN_ONLYONE,
> wxPRINTBIN_LOWER,
> wxPRINTBIN_MIDDLE,
> wxPRINTBIN_MANUAL,
> wxPRINTBIN_ENVELOPE,
> wxPRINTBIN_ENVMANUAL,
> wxPRINTBIN_AUTO,
> wxPRINTBIN_TRACTOR,
> wxPRINTBIN_SMALLFMT,
> wxPRINTBIN_LARGEFMT,
> wxPRINTBIN_LARGECAPACITY,
> wxPRINTBIN_CASSETTE,
> wxPRINTBIN_FORMSOURCE,
> wxPRINTBIN_USER

};
#endif
class %delete wxPrintData : public wxObject
{

> wxPrintData( );
> wxPrintData(const wxPrintData& data );
> wxPrintData *Copy( );
> // copied straight from cmndata.h not docs
> int GetNoCopies() const;
> bool GetCollate() const;
> int GetOrientation() const;
> bool Ok() const;
> wxString GetPrinterName() const;
> bool GetColour() const;
> wxDuplexMode GetDuplex() const;
> %wxchkver_2_8 int GetMedia() const;
> wxPaperSize GetPaperId() const;
> wxSize GetPaperSize() const;
> wxPrintQuality GetQuality() const;
> wxPrintBin GetBin() const;
> wxPrintMode GetPrintMode() const;
> %wxchkver_2_8 bool IsOrientationReversed() const;
> void SetNoCopies(int v );
> void SetCollate(bool flag );
> void SetOrientation(int orient );
> void SetPrinterName(const wxString& name );
> void SetColour(bool colour );
> void SetDuplex(wxDuplexMode duplex );
> %wxchkver_2_8 void SetOrientationReversed(bool reversed );
> %wxchkver_2_8 void SetMedia(int media );
> void SetPaperId(wxPaperSize sizeId );
> void SetPaperSize(const wxSize& sz );
> void SetQuality(wxPrintQuality quality );
> void SetBin(wxPrintBin bin );
> void SetPrintMode(wxPrintMode printMode );
> wxString GetFilename() const;
> void SetFilename( const wxString &filename );
> void operator=(const wxPrintData& data );
> // these are all WXWIN_COMPATIBILITY_2_4 and for postscript printing only
> //!%wxchkver_2_8 wxString GetPrinterCommand( );
> //!%wxchkver_2_8 wxString GetPrinterOptions( );
> //!%wxchkver_2_8 wxString GetPreviewCommand( );
> //!%wxchkver_2_8 const wxString& GetFontMetricPath( );
> //!%wxchkver_2_8 double GetPrinterScaleX( );
> //!%wxchkver_2_8 double GetPrinterScaleY( );
> //!%wxchkver_2_8 long GetPrinterTranslateX( );
> //!%wxchkver_2_8 long GetPrinterTranslateY( );
> //!%wxchkver_2_8 void SetPrinterCommand(const wxString& command );
> //!%wxchkver_2_8 void SetPrinterOptions(const wxString& options );
> //!%wxchkver_2_8 void SetPreviewCommand(const wxString& command );
> //!%wxchkver_2_8 void SetFontMetricPath(const wxString& path );
> //!%wxchkver_2_8 void SetPrinterScaleX(double x );
> //!%wxchkver_2_8 void SetPrinterScaleY(double y );
> //!%wxchkver_2_8 void SetPrinterScaling(double x, double y );
> //!%wxchkver_2_8 void SetPrinterTranslateX(long x );
> //!%wxchkver_2_8 void SetPrinterTranslateY(long y );
> //!%wxchkver_2_8 void SetPrinterTranslation(long x, long y );

};
// ---------------------------------------------------------------------------
// wxPageSetupDialogData
class %delete wxPageSetupDialogData : public wxObject
{

> wxPageSetupDialogData( );
> wxPageSetupDialogData(const wxPageSetupDialogData& data );
> wxPageSetupDialogData *Copy( );
> // copied straight from cmndata.h not docs
> wxSize GetPaperSize() const;
> wxPaperSize GetPaperId() const;
> wxPoint GetMinMarginTopLeft() const;
> wxPoint GetMinMarginBottomRight() const;
> wxPoint GetMarginTopLeft() const;
> wxPoint GetMarginBottomRight() const;
> bool GetDefaultMinMargins() const;
> bool GetEnableMargins() const;
> bool GetEnableOrientation() const;
> bool GetEnablePaper() const;
> bool GetEnablePrinter() const;
> bool GetDefaultInfo() const;
> bool GetEnableHelp() const;
> bool Ok() const;
> void SetPaperSize(const wxSize& sz );
> void SetPaperSize(wxPaperSize id );
> void SetPaperId(wxPaperSize id );
> void SetMinMarginTopLeft(const wxPoint& pt );
> void SetMinMarginBottomRight(const wxPoint& pt );
> void SetMarginTopLeft(const wxPoint& pt );
> void SetMarginBottomRight(const wxPoint& pt );
> void SetDefaultMinMargins(bool flag );
> void SetDefaultInfo(bool flag );
> void EnableMargins(bool flag );
> void EnableOrientation(bool flag );
> void EnablePaper(bool flag );
> void EnablePrinter(bool flag );
> void EnableHelp(bool flag );
> void CalculateIdFromPaperSize( );
> void CalculatePaperSizeFromId( );
> wxPrintData& GetPrintData( );
> void SetPrintData(const wxPrintData& printData );
> //wxPageSetupDialogData& operator=(const wxPageSetupData& data );
> //wxPageSetupDialogData& operator=(const wxPrintData& data );

};
// ---------------------------------------------------------------------------
// wxPageSetupDialog
#include "wx/printdlg.h"
//typedef wxPageSetupDialogBase wxPageSetupDialog
class %delete wxPageSetupDialog : public wxObject // NOT a wxDialog in 2.8
{

> wxPageSetupDialog(wxWindow* parent, wxPageSetupDialogData* data = NULL );
> wxPageSetupDialogData& GetPageSetupDialogData( );
> int ShowModal( );

};
// ---------------------------------------------------------------------------
// wxPrintDialog
class %delete wxPrintDialog : public wxObject // NOT a wxDialog in 2.8
{

> wxPrintDialog(wxWindow* parent, wxPrintDialogData* data = NULL );
> wxPrintDialogData& GetPrintDialogData( );
> wxPrintData& GetPrintData();
> wxDC* GetPrintDC( );
> int ShowModal( );

};
// ---------------------------------------------------------------------------
// wxPrintDialogData
class %delete wxPrintDialogData : public wxObject
{

> wxPrintDialogData( );
> wxPrintDialogData(const wxPrintDialogData& dialogData );
> wxPrintDialogData(const wxPrintData& data );
> // copied straight from cmndata.h not docs
> int GetFromPage() const;
> int GetToPage() const;
> int GetMinPage() const;
> int GetMaxPage() const;
> int GetNoCopies() const;
> bool GetAllPages() const;
> bool GetSelection() const;
> bool GetCollate() const;
> bool GetPrintToFile() const;
> // WXWIN_COMPATIBILITY_2_4 //bool GetSetupDialog() const;
> void SetFromPage(int v );
> void SetToPage(int v );
> void SetMinPage(int v );
> void SetMaxPage(int v );
> void SetNoCopies(int v );
> void SetAllPages(bool flag );
> void SetSelection(bool flag );
> void SetCollate(bool flag );
> void SetPrintToFile(bool flag );
> // WXWIN_COMPATIBILITY_2_4 //void SetSetupDialog(bool flag) { m_printSetupDialog = flag; };
> void EnablePrintToFile(bool flag );
> void EnableSelection(bool flag );
> void EnablePageNumbers(bool flag );
> void EnableHelp(bool flag );
> bool GetEnablePrintToFile() const;
> bool GetEnableSelection() const;
> bool GetEnablePageNumbers() const;
> bool GetEnableHelp() const;
> bool Ok() const;
> wxPrintData& GetPrintData( );
> void SetPrintData(const wxPrintData& printData );
> void operator=(const wxPrintDialogData& data );

};
// ---------------------------------------------------------------------------
// wxPreviewCanvas
class wxPreviewCanvas : public wxWindow
{

> wxPreviewCanvas(wxPrintPreview *preview, wxWindow *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxPreviewCanvas" );

};
// ---------------------------------------------------------------------------
// wxPreviewControlBar
#define wxPREVIEW_PRINT
#define wxPREVIEW_PREVIOUS
#define wxPREVIEW_NEXT
#define wxPREVIEW_ZOOM
#define wxPREVIEW_FIRST
#define wxPREVIEW_LAST
#define wxPREVIEW_GOTO
#define wxID_PREVIEW_CLOSE
#define wxID_PREVIEW_NEXT
#define wxID_PREVIEW_PREVIOUS
#define wxID_PREVIEW_PRINT
#define wxID_PREVIEW_ZOOM
#define wxID_PREVIEW_FIRST
#define wxID_PREVIEW_LAST
#define wxID_PREVIEW_GOTO
class wxPreviewControlBar : public wxWindow
{

> wxPreviewControlBar(wxPrintPreview* preview, long buttons, wxWindow* parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxPreviewControlBar" );
> //void CreateButtons( );
> virtual void SetZoomControl(int zoom );
> virtual int GetZoomControl( );
> //virtual wxPrintPreviewBase *GetPrintPreview() const;

};
// ---------------------------------------------------------------------------
// wxPrintPreview
#if wxLUA_USE_wxLuaPrintout
class wxPrintPreview : public wxObject
{

> wxPrintPreview(wxLuaPrintout* printout, wxLuaPrintout* printoutForPrinting, wxPrintData* data=NULL );
> bool DrawBlankPage(wxPreviewCanvas* window, wxDC& dc );
> wxPreviewCanvas* GetCanvas( );
> int GetCurrentPage( );
> wxFrame * GetFrame( );
> int GetMaxPage( );
> int GetMinPage( );
> wxPrintout* GetPrintout( );
> wxPrintout* GetPrintoutForPrinting( );
> bool Ok( );
> bool PaintPage(wxPreviewCanvas* window, wxDC &dc );
> bool Print(bool prompt );
> bool RenderPage(int pageNum );
> void SetCanvas(wxPreviewCanvas* window );
> void SetCurrentPage(int pageNum );
> void SetFrame(wxFrame *frame );
> void SetPrintout(wxLuaPrintout *printout );
> void SetZoom(int percent );

};
// ---------------------------------------------------------------------------
// wxPreviewFrame
class wxPreviewFrame : public wxFrame
{

> wxPreviewFrame(wxPrintPreview *preview, wxFrame *parent, const wxString &title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString &name = "wxPreviewFrame" );
> void CreateControlBar( );
> void CreateCanvas( );
> void Initialize( );
> wxPreviewControlBar* GetControlBar() const;

};
#endif //wxLUA_USE_wxLuaPrintout
// ---------------------------------------------------------------------------
// wxPostScriptDC
#if wxUSE_POSTSCRIPT
#include "wx/dcps.h"
class %delete wxPostScriptDC : public wxDC
{

> wxPostScriptDC(const wxPrintData& printData );
> !%wxchkver_2_9_2 static void SetResolution(int ppi );
> !%wxchkver_2_9_2 static int GetResolution( );
> %wxchkver_2_9_2 int GetResolution( );

};
#endif //wxUSE_POSTSCRIPT
// ---------------------------------------------------------------------------
// wxPrinterDC
#if %msw|%mac
#include "wx/dcprint.h"
class %delete wxPrinterDC : public wxDC
{

> wxPrinterDC(const wxPrintData& printData );

};
#endif // %msw|%mac
#endif //wxLUA_USE_wxPrint && wxUSE_PRINTING_ARCHITECTURE

## wxwidgets/wxcore_sizer.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxSizers and wxLayoutConstraints
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxSizer
#if %wxchkver_2_8
// ---------------------------------------------------------------------------
// wxSizerFlags
class %delete wxSizerFlags
{

> wxSizerFlags(int proportion = 0 );
> // setters for all sizer flags, they all return the object itself so that
> // calls to them can be chained
> wxSizerFlags& Proportion(int proportion );
> wxSizerFlags& Align(int alignment); // combination of wxAlignment values
> wxSizerFlags& Expand(); // wxEXPAND
> // some shortcuts for Align( );
> wxSizerFlags& Centre(); // { return Align(wxCENTRE); }
> wxSizerFlags& Center(); // { return Centre(); }
> wxSizerFlags& Left(); // { return Align(wxALIGN_LEFT); }
> wxSizerFlags& Right(); // { return Align(wxALIGN_RIGHT); }
> wxSizerFlags& Top(); // { return Align(wxALIGN_TOP); }
> wxSizerFlags& Bottom(); // { return Align(wxALIGN_BOTTOM); }
> static int GetDefaultBorder(); // default border size used by Border() below
> wxSizerFlags& Border(int direction, int borderInPixels );
> wxSizerFlags& Border(int direction = wxALL );
> wxSizerFlags& DoubleBorder(int direction = wxALL );
> wxSizerFlags& TripleBorder(int direction = wxALL );
> wxSizerFlags& HorzBorder( );
> wxSizerFlags& DoubleHorzBorder( );
> wxSizerFlags& Shaped( );
> wxSizerFlags& FixedMinSize( );
> #if (wxABI_VERSION >= 20808 );
> wxSizerFlags& ReserveSpaceEvenIfHidden( );
> #endif
> // accessors for wxSizer only
> int GetProportion() const;
> int GetFlags() const;
> int GetBorderInPixels() const;

};
// ----------------------------------------------------------------------------
// wxSizerSpacer - No real need to create one of these in wxLua
//class wxSizerSpacer
//{
// wxSizerSpacer(const wxSize& size );
// void SetSize(const wxSize& size );
// const wxSize& GetSize() const;
// void Show(bool show );
// bool IsShown() const;
//};
// ---------------------------------------------------------------------------
// wxSizerItem
class wxSizerItem : public wxObject
{

> wxSizerItem(int width, int height, int proportion, int flag, int border, %ungc wxObject* userData );
> wxSizerItem(wxWindow* window, int proportion, int flag, int border, %ungc wxObject* userData );
> wxSizerItem(wxSizer* sizer, int proportion, int flag, int border, %ungc wxObject* userData );
> wxSizerItem(wxWindow* window, const wxSizerFlags& flags );
> wxSizerItem(wxSizer* window, const wxSizerFlags& flags );
> wxSize CalcMin( );
> void DeleteWindows( );
> void DetachSizer( );
> int GetBorder() const;
> int GetFlag() const;
> wxSize GetMinSize() const;
> wxSize GetMinSizeWithBorder() const;
> wxPoint GetPosition() const;
> int GetProportion() const;
> float GetRatio() const;
> wxRect GetRect( );
> wxSize GetSize() const;
> wxSizer* GetSizer() const;
> wxSize GetSpacer() const;
> wxObject* GetUserData() const;
> wxWindow* GetWindow() const;
> bool IsShown() const;
> bool IsSizer() const;
> bool IsSpacer() const;
> bool IsWindow() const;
> void SetBorder(int border );
> void SetDimension(const wxPoint& pos, const wxSize& size );
> void SetFlag(int flag );
> void SetInitSize(int x, int y );
> void SetMinSize(const wxSize& size );
> void SetMinSize( int x, int y );
> void SetProportion(int proportion );
> void SetRatio(int width, int height );
> void SetRatio(const wxSize& size );
> void SetRatio(float ratio );
> void SetSizer(wxSizer* sizer );
> void SetSpacer(const wxSize& size );
> void SetSpacer(int width, int height );
> void SetUserData(%ungc wxObject* userData );
> void SetWindow(wxWindow* window );
> void Show(bool show );

};
// ---------------------------------------------------------------------------
// wxSizer
class wxSizer : public wxObject
{

> // base class no constructors
> wxSizerItem* Add(wxWindow* window, int proportion = 0,int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Add(wxSizer* sizer, int proportion = 0, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Add(int width, int height, int proportion = 0, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Add(wxWindow* window, const wxSizerFlags& flags );
> wxSizerItem* Add(wxSizer* sizer, const wxSizerFlags& flags );
> wxSizerItem* Add( wxSizerItem *item );
> wxSizerItem* AddSpacer(int size );
> wxSizerItem* AddStretchSpacer(int prop = 1 );
> wxSize CalcMin( );
> virtual void Clear( bool delete_windows = false );
> #if (wxABI_VERSION >= 20808 );
> wxSize ComputeFittingClientSize(wxWindow *window );
> wxSize ComputeFittingWindowSize(wxWindow *window );
> #endif
> virtual void DeleteWindows( );
> bool Detach(wxWindow* window );
> bool Detach(wxSizer* sizer );
> bool Detach(size_t index );
> void Fit(wxWindow* window );
> void FitInside(wxWindow* window );
> wxSizerItemList& GetChildren( );
> wxWindow *GetContainingWindow() const;
> wxSizerItem* GetItem(wxWindow* window, bool recursive = false );
> wxSizerItem* GetItem(wxSizer* sizer, bool recursive = false );
> wxSizerItem* GetItem(size_t index );
> wxSize GetSize( );
> wxPoint GetPosition( );
> wxSize GetMinSize( );
> bool Hide( wxSizer *sizer, bool recursive = false );
> bool Hide( wxWindow *window, bool recursive = false );
> bool Hide( size_t index );
> wxSizerItem* Insert(size_t index, wxWindow* window, int proportion = 0,int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Insert(size_t index, wxSizer* sizer, int proportion = 0, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Insert(size_t index, int width, int height, int proportion = 0, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Insert(size_t index, wxWindow* window, const wxSizerFlags& flags );
> wxSizerItem* Insert(size_t index, wxSizer* sizer, const wxSizerFlags& flags );
> virtual wxSizerItem* Insert( size_t index, wxSizerItem *item );
> wxSizerItem* InsertSpacer(size_t index, int size );
> wxSizerItem* InsertStretchSpacer(size_t index, int prop = 1 );
> bool IsShown( wxWindow *window ) const;
> bool IsShown( wxSizer *sizer ) const;
> bool IsShown( size_t index ) const;
> void Layout( );
> void Prepend(wxWindow* window, int proportion = 0, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> void Prepend(wxSizer* sizer, int proportion = 0, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> void Prepend(int width, int height, int proportion = 0, int flag = 0, int border= 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Prepend(wxWindow* window, const wxSizerFlags& flags );
> wxSizerItem* Prepend(wxSizer* sizer, const wxSizerFlags& flags );
> wxSizerItem* Prepend(wxSizerItem *item );
> wxSizerItem* PrependSpacer(int size );
> wxSizerItem* PrependStretchSpacer(int prop = 1 );
> void RecalcSizes( );
> //bool Remove(wxWindow* window) - deprecated use Detach
> //bool Remove(wxSizer* sizer );
> //bool Remove(size_t index );
> virtual bool Replace( wxWindow *oldwin, wxWindow *newwin, bool recursive = false );
> virtual bool Replace( wxSizer *oldsz, wxSizer *newsz, bool recursive = false );
> virtual bool Replace( size_t index, wxSizerItem *newitem );
> void SetContainingWindow(wxWindow *window );
> void SetDimension(int x, int y, int width, int height );
> void SetMinSize(int width, int height );
> void SetMinSize(const wxSize& size );
> void SetItemMinSize(wxWindow* window, int width, int height );
> void SetItemMinSize(wxSizer* sizer, int width, int height );
> void SetItemMinSize(int pos, int width, int height );
> void SetSizeHints(wxWindow* window );
> void SetVirtualSizeHints(wxWindow* window );
> bool Show(wxWindow* window, bool show = true, bool recursive = false );
> bool Show(wxSizer* sizer, bool show = true, bool recursive = false );
> bool Show(size_t index, bool show = true );
> //void Show(bool show) - simply calls ShowItems( );
> virtual void ShowItems (bool show );

};
// ---------------------------------------------------------------------------
// wxSizerItemList
//#if wxLUA_USE_wxSizerItemList && !wxUSE_STL
class wxSizerItemList : public wxList
{

> //wxSizerItemList() - no constructor, just get this from wxSizer::GetChildren( );
> // This is returned from wxSizer::GetChildren(), use wxList methods and
> // wxNode::GetData():DynamicCast("wxSizer") to retrieve the wxSizer
> // Use the wxList methods, see also wxNode

};
//#endif //wxLUA_USE_wxSizerItemList && !wxUSE_STL
// ---------------------------------------------------------------------------
// wxBoxSizer
class wxBoxSizer : public wxSizer
{

> wxBoxSizer(int orient );
> //void RecalcSizes( );
> //wxSize CalcMin( );
> int GetOrientation( );

};
// ---------------------------------------------------------------------------
// wxGridSizer
class wxGridSizer : public wxSizer
{

> wxGridSizer(int cols, int rows, int vgap, int hgap );
> // wxGridSizer(int cols, int vgap = 0, int hgap = 0 );
> int GetCols( );
> int GetHGap( );
> int GetRows( );
> int GetVGap( );
> void SetCols(int cols );
> void SetHGap(int gap );
> void SetRows(int rows );
> void SetVGap(int gap );

};
// ---------------------------------------------------------------------------
// wxFlexGridSizer
enum wxFlexSizerGrowMode
{

> wxFLEX_GROWMODE_NONE,
> wxFLEX_GROWMODE_SPECIFIED,
> wxFLEX_GROWMODE_ALL

};
class wxFlexGridSizer : public wxGridSizer
{

> wxFlexGridSizer(int rows, int cols, int vgap=0, int hgap=0 );
> // wxFlexGridSizer(int cols, int vgap = 0, int hgap = 0); // just use the above constructor
> void AddGrowableCol( size_t idx, int proportion = 0 );
> void AddGrowableRow( size_t idx, int proportion = 0 );
> int GetFlexibleDirection() const;
> wxFlexSizerGrowMode GetNonFlexibleGrowMode() const;
> void RemoveGrowableCol( size_t idx );
> void RemoveGrowableRow( size_t idx );
> void SetFlexibleDirection(int direction );
> void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode );

};
// ---------------------------------------------------------------------------
// wxGridBagSizer
#include "wx/gbsizer.h"
class wxGridBagSizer : public wxFlexGridSizer
{

> wxGridBagSizer(int vgap=0, int hgap=0 );
> wxSizerItem* Add(wxWindow* window, const wxGBPosition& pos, const wxGBSpan& span = wxDefaultSpan, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Add(wxSizer* sizer, const wxGBPosition& pos, const wxGBSpan& span = wxDefaultSpan, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Add(int width, int height, const wxGBPosition& pos, const wxGBSpan& span = wxDefaultSpan, int flag = 0, int border = 0, %ungc wxObject* userData = NULL );
> wxSizerItem* Add(wxGBSizerItem* item );
> bool CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem = NULL );
> bool CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem = NULL );
> wxGBSizerItem* FindItem(wxWindow* window );
> wxGBSizerItem* FindItem(wxSizer* sizer );
> wxGBSizerItem* FindItemAtPoint(const wxPoint& pt );
> wxGBSizerItem* FindItemAtPosition(const wxGBPosition& pos );
> wxGBSizerItem* FindItemWithData(const wxObject* userData );
> wxSize GetCellSize(int row, int col) const;
> wxSize GetEmptyCellSize() const;
> wxGBPosition GetItemPosition(wxWindow* window );
> wxGBPosition GetItemPosition(wxSizer* sizer );
> wxGBPosition GetItemPosition(size_t index );
> wxGBSpan GetItemSpan(wxWindow* window );
> wxGBSpan GetItemSpan(wxSizer* sizer );
> wxGBSpan GetItemSpan(size_t index );
> //void RecalcSizes( );
> void SetEmptyCellSize(const wxSize& sz );
> bool SetItemPosition(wxWindow* window, const wxGBPosition& pos );
> bool SetItemPosition(wxSizer* sizer, const wxGBPosition& pos );
> bool SetItemPosition(size_t index, const wxGBPosition& pos );
> bool SetItemSpan(wxWindow* window, const wxGBSpan& span );
> bool SetItemSpan(wxSizer* sizer, const wxGBSpan& span );
> bool SetItemSpan(size_t index, const wxGBSpan& span );

};
// ---------------------------------------------------------------------------
// wxGBPosition
class %delete wxGBPosition
{

> wxGBPosition(int row=0, int col=0 );
> wxGBPosition(const wxGBPosition& pos );
> int GetRow() const;
> int GetCol() const;
> void SetRow(int row );
> void SetCol(int col );
> bool operator==(const wxGBPosition& p) const;

};
// ---------------------------------------------------------------------------
// wxGBSpan
class %delete wxGBSpan
{

> wxGBSpan(int rowspan=1, int colspan=1 );
> wxGBSpan(const wxGBSpan& span );
> int GetRowspan() const;
> int GetColspan() const;
> void SetRowspan(int rowspan );
> void SetColspan(int colspan );
> bool operator==(const wxGBSpan& o) const;

};
// ---------------------------------------------------------------------------
// wxGBSizerItem
class wxGBSizerItem : public wxSizerItem
{

> wxGBSizerItem( );
> wxGBSizerItem( int width, int height, const wxGBPosition& pos, const wxGBSpan& span, int flag, int border, %ungc wxObject* userData );
> wxGBSizerItem( wxWindow *window, const wxGBPosition& pos, const wxGBSpan& span, int flag, int border, %ungc wxObject* userData );
> wxGBSizerItem( wxSizer *sizer, const wxGBPosition& pos, const wxGBSpan& span, int flag, int border, %ungc wxObject* userData );
> wxGBPosition GetPos() const;
> //void GetPos(int& row, int& col) const;
> wxGBSpan GetSpan() const;
> //void GetSpan(int& rowspan, int& colspan) const;
> bool SetPos( const wxGBPosition& pos );
> bool SetSpan( const wxGBSpan& span );
> bool Intersects(const wxGBSizerItem& other );
> bool Intersects(const wxGBPosition& pos, const wxGBSpan& span );
> // %override [row, col] wxGBSizerItem::GetEndPos( );
> // C++ Func: void GetEndPos(int& row, int& col );
> void GetEndPos( );
> wxGridBagSizer* GetGBSizer() const;
> void SetGBSizer(wxGridBagSizer* sizer );

};
// ---------------------------------------------------------------------------
// wxWrapSizer
#if %wxchkver_2_9
#include "wx/wrapsizer.h"
enum
{
wxEXTEND_LAST_ON_EACH_LINE,
wxREMOVE_LEADING_SPACES,
wxWRAPSIZER_DEFAULT_FLAGS
};
class wxWrapSizer : public wxBoxSizer
{

> wxWrapSizer(int orient = wxHORIZONTAL, int flags = wxWRAPSIZER_DEFAULT_FLAGS);
> // This will probably not be needed to be called by user code.
> bool InformFirstDirection(int direction, int size, int availableOtherDir);

};
#endif
// ---------------------------------------------------------------------------
// wxNotebookSizer - deprecated
#if wxUSE_NOTEBOOK && (!%wxchkver_2_6 );
class wxNotebookSizer : public wxSizer
{

> wxNotebookSizer(wxNotebook* notebook );
> wxNotebook* GetNotebook( );

};
#endif //wxUSE_NOTEBOOK && (!%wxchkver_2_6 );
// ---------------------------------------------------------------------------
// wxBookCtrlSizer - also depricated since 2.6
// ---------------------------------------------------------------------------
// wxStaticBoxSizer
#if wxUSE_STATBOX
class wxStaticBoxSizer : public wxBoxSizer
{

> wxStaticBoxSizer(wxStaticBox* box, int orient );
> wxStaticBoxSizer(int orient, wxWindow *parent, const wxString& label = "" );
> wxStaticBox* GetStaticBox( );

};
#endif //wxUSE_STATBOX
// ---------------------------------------------------------------------------
// wxStdDialogButtonSizer
#if wxUSE_BUTTON
class wxStdDialogButtonSizer : public wxBoxSizer
{

> wxStdDialogButtonSizer( );
> void AddButton(wxButton *button );
> void SetAffirmativeButton( wxButton *button );
> void SetNegativeButton( wxButton *button );
> void SetCancelButton( wxButton *button );
> void Realize( );
> wxButton *GetAffirmativeButton() const;
> wxButton *GetApplyButton() const;
> wxButton *GetNegativeButton() const;
> wxButton *GetCancelButton() const;
> wxButton *GetHelpButton() const;

};
#endif //wxUSE_BUTTON
#endif //wxLUA_USE_wxSizer
// ---------------------------------------------------------------------------
// wxLayoutConstraints - deprecated since 2.2, not updated to 2.6
#if wxLUA_USE_wxLayoutConstraints && (!%wxchkver_2_6 );
#include "wx/layout.h"
enum wxRelationship
{

> wxUnconstrained,
> wxAsIs,
> wxPercentOf,
> wxAbove,
> wxBelow,
> wxLeftOf,
> wxRightOf,
> wxSameAs,
> wxAbsolute

};
enum wxEdge
{

> wxLeft,
> wxTop,
> wxRight,
> wxBottom,
> wxWidth,
> wxHeight,
> wxCentre,
> wxCenter,
> wxCentreX,
> wxCentreY

};
class wxLayoutConstraints : public wxObject
{

> wxLayoutConstraints( );

};
// ---------------------------------------------------------------------------
// wxIndividualLayoutConstraint
#include "wx/layout.h"
class wxIndividualLayoutConstraint : public wxObject
{

> wxIndividualLayoutConstraint( );
> void Above(wxWindow *otherWin, int margin = 0 );
> void Absolute(int value );
> void AsIs( );
> void Below(wxWindow *otherWin, int margin = 0 );
> void Unconstrained( );
> void LeftOf(wxWindow *otherWin, int margin = 0 );
> void PercentOf(wxWindow *otherWin, wxEdge edge, int per );
> void RightOf(wxWindow *otherWin, int margin = 0 );
> void SameAs(wxWindow *otherWin, wxEdge edge, int margin = 0 );
> void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value = 0, int margin = 0 );

};
#endif //wxLUA_USE_wxLayoutConstraints && (!%wxchkver_2_6 );

## wxwidgets/wxcore_windows.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxWindow and other container type windows
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
%wxchkver_2_8 wxWindow* wxFindFocusDescendant(wxWindow* ancestor );
// ---------------------------------------------------------------------------
// wxTooltip
#if wxLUA_USE_wxTooltip && wxUSE_TOOLTIPS
#include "wx/tooltip.h"
class %delete wxToolTip : public wxObject
{

> wxToolTip(const wxString &tip );
> static void Enable(bool flag );
> static void SetDelay(long milliseconds );
> void SetTip(const wxString& tip );
> wxString GetTip( );
> wxWindow *GetWindow() const;

};
#endif //wxLUA_USE_wxTooltip && wxUSE_TOOLTIPS
// ---------------------------------------------------------------------------
// wxWindowDisabler
#include "wx/utils.h"
class %delete wxWindowDisabler
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxWindowDisabler(wxWindow *winToSkip = NULL );

};
// ---------------------------------------------------------------------------
// wxWindowUpdateLocker - Note this only calls wxWindow::Freeze() -> Thaw( );
#include "wx/wupdlock.h"
class %delete wxWindowUpdateLocker
{

> // NOTE: ALWAYS delete() this when done since Lua's gc may not delete it soon enough
> wxWindowUpdateLocker(wxWindow *winToLock = NULL );

};
// ---------------------------------------------------------------------------
// wxWindow
#define wxSIMPLE_BORDER
#define wxDOUBLE_BORDER
#define wxSUNKEN_BORDER
#define wxRAISED_BORDER
#define wxSTATIC_BORDER
//#define wxNO_BORDER in defsutils.i
#define wxTRANSPARENT_WINDOW
// #define wxNO_3D %wxcompat_2_6
#define wxTAB_TRAVERSAL
#define wxWANTS_CHARS
#define wxVSCROLL
#define wxHSCROLL
#define wxALWAYS_SHOW_SB
#define wxCLIP_CHILDREN
#define wxNO_FULL_REPAINT_ON_RESIZE
#define wxFULL_REPAINT_ON_RESIZE
#define wxWS_EX_VALIDATE_RECURSIVELY
#define wxWS_EX_BLOCK_EVENTS
#define wxWS_EX_TRANSIENT
#define wxWS_EX_PROCESS_IDLE
#define wxWS_EX_PROCESS_UI_UPDATES
enum wxWindowVariant
{

> wxWINDOW_VARIANT_NORMAL,
> wxWINDOW_VARIANT_SMALL,
> wxWINDOW_VARIANT_MINI,
> wxWINDOW_VARIANT_LARGE,
> wxWINDOW_VARIANT_MAX

};
enum wxUpdateUI
{

> wxUPDATE_UI_NONE,
> wxUPDATE_UI_RECURSE,
> wxUPDATE_UI_FROMIDLE

};
//%mac|%x11|%motif typedef void* WXWidget
//%gtk typedef unsigned long WXWidget // GtkWidget* what could you do with it?
//%mgl typedef window_t WXWidget
//%msw|%os2 typedef unsigned long WXWidget
class %delete wxVisualAttributes
{

> wxFont font;
> wxColour colFg;
> wxColour colBg;

};
class wxWindow : public wxEvtHandler
{

> wxWindow( );
> wxWindow(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxWindow" );
> bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxWindow" );
> virtual void AddChild(wxWindow* child );
> void CacheBestSize(const wxSize& size) const;
> virtual void CaptureMouse( );
> void Center(int direction = wxBOTH );
> void CenterOnParent(int direction = wxBOTH );
> !%wxchkver_2_8 void CenterOnScreen(int direction = wxBOTH );
> void Centre(int direction = wxBOTH );
> void CentreOnParent(int direction = wxBOTH );
> !%wxchkver_2_8 void CentreOnScreen(int direction = wxBOTH );
> !%wxchkver_2_6 void Clear( );
> %wxchkver_2_6 void ClearBackground( );
> // %override [int x, int y] ClientToScreen(int x, int y) const;
> // C++ Func: virtual void ClientToScreen(int* x, int* y) const;
> %override_name wxLua_wxWindow_ClientToScreenXY virtual void ClientToScreen(int x, int y) const;
> virtual wxPoint ClientToScreen(const wxPoint& pt) const;
> virtual bool Close(bool force = false );
> wxPoint ConvertDialogToPixels(const wxPoint& pt );
> wxSize ConvertDialogToPixels(const wxSize& sz );
> wxPoint ConvertPixelsToDialog(const wxPoint& pt );
> wxSize ConvertPixelsToDialog(const wxSize& sz );
> virtual bool Destroy( );
> virtual void DestroyChildren( );
> bool Disable( );
> // virtual wxSize DoGetBestSize() const; // protected
> //virtual void DoUpdateWindowUI(wxUpdateUIEvent& event );
> %win virtual void DragAcceptFiles(bool accept );
> virtual void Enable(bool enable );
> static wxWindow* FindFocus( );
> wxWindow* FindWindow(long id );
> wxWindow* FindWindow(const wxString& name );
> static wxWindow* FindWindowById(long id, wxWindow* parent = NULL );
> static wxWindow* FindWindowByName(const wxString& name, wxWindow* parent = NULL );
> static wxWindow* FindWindowByLabel(const wxString& label, wxWindow* parent = NULL );
> virtual void Fit( );
> virtual void FitInside( );
> virtual void Freeze( );
> wxAcceleratorTable* GetAcceleratorTable() const;
> //wxAccessible* GetAccessible( );
> !%wxchkver_2_8 wxSize GetAdjustedBestSize() const;
> virtual wxColour GetBackgroundColour() const;
> virtual wxBackgroundStyle GetBackgroundStyle() const;
> wxSize GetBestFittingSize() const; // deprecated in 2.8 use GetEffectiveMinSize
> virtual wxSize GetBestSize() const;
> wxCaret* GetCaret() const;
> static wxWindow* GetCapture( );
> virtual int GetCharHeight() const;
> virtual int GetCharWidth() const;
> wxWindowList& GetChildren( );
> //static wxVisualAttributes GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL );
> // %override [int width, int height] wxWindow::GetClientSizeWH() const;
> // C++ Func: virtual void GetClientSize(int* width, int* height) const;
> %rename GetClientSizeWH virtual void GetClientSize() const;
> wxSize GetClientSize() const;
> !%wxchkver_2_6 wxLayoutConstraints* GetConstraints() const; // deprecated use sizers
> const wxSizer* GetContainingSizer() const;
> wxCursor GetCursor() const;
> virtual wxVisualAttributes GetDefaultAttributes() const;
> !%wxchkver_2_8 wxWindow* GetDefaultItem() const;
> wxDropTarget* GetDropTarget() const;
> wxEvtHandler* GetEventHandler() const;
> long GetExtraStyle() const;
> wxFont GetFont() const;
> virtual wxColour GetForegroundColour( );
> wxWindow* GetGrandParent() const;
> void* GetHandle() const;
> virtual wxString GetHelpText() const;
> int GetId() const;
> virtual wxString GetLabel() const;
> wxSize GetMaxSize() const;
> wxSize GetMinSize() const;
> virtual wxString GetName() const;
> virtual wxWindow* GetParent() const;
> // %override [int x, int y] wxWindow::GetPosition() const;
> // C++ Func: virtual void GetPosition(int* x, int* y) const;
> %override_name wxLua_wxWindow_GetPositionXY %rename GetPositionXY virtual void GetPosition() const;
> wxPoint GetPosition() const;
> virtual wxRect GetRect() const;
> // %override [int x, int y] wxWindow::GetScreenPosition() const;
> // C++ Func: virtual void GetScreenPosition(int* x, int* y) const;
> %override_name wxLua_wxWindow_GetScreenPositionXY %rename GetScreenPositionXY virtual void GetScreenPosition() const;
> virtual wxPoint GetScreenPosition( );
> virtual wxRect GetScreenRect() const;
> virtual int GetScrollPos(int orientation );
> virtual int GetScrollRange(int orientation );
> virtual int GetScrollThumb(int orientation );
> virtual wxSize GetSize() const;
> // %override [int width, int height] wxWindow::GetSizeWH() const;
> // C++ Func: virtual void GetSize(int* width, int* height) const;
> %rename GetSizeWH virtual void GetSize() const;
> wxSizer* GetSizer() const;
> // %override [int x, int y, int descent, int externalLeading] int wxWindow::GetTextExtent(const wxString& string, const wxFont* font = NULL ) const;
> // Note: Cannot use use16 from Lua, virtual void GetTextExtent(const wxString& string, int* x, int* y, int* descent = NULL, int* externalLeading = NULL, const wxFont* font = NULL, bool use16 = false) const;
> // C++ Func: virtual void GetTextExtent(const wxString& string, int* x, int* y, int* descent = NULL, int* externalLeading = NULL, const wxFont* font = NULL ) const;
> virtual void GetTextExtent(const wxString& string, const wxFont* font = NULL ) const;
> !%wxchkver_2_8 virtual wxString GetTitle( );
> wxToolTip* GetToolTip() const;
> virtual wxRegion GetUpdateRegion() const;
> wxValidator* GetValidator() const;
> // %override [int width, int height] wxWindow::GetVirtualSizeWH() const;
> // C++ Func: void GetVirtualSize(int* width, int* height) const;
> %override_name wxLua_wxWindow_GetVirtualSizeWH %rename GetVirtualSizeWH void GetVirtualSize() const;
> wxSize GetVirtualSize() const;
> %wxchkver_2_9_4 virtual wxSize GetBestVirtualSize() const;
> %wxchkver_2_9_5 virtual double GetContentScaleFactor() const;
> long GetWindowStyleFlag() const;
> wxWindowVariant GetWindowVariant() const;
> %wxchkver_2_4 bool HasCapture() const;
> virtual bool HasScrollbar(int orient) const;
> virtual bool HasTransparentBackground() const;
> bool Hide( );
> void InheritAttributes( );
> void InitDialog( );
> void InvalidateBestSize( );
> virtual bool IsEnabled() const;
> bool IsExposed(int x, int y) const;
> bool IsExposed(const wxPoint &pt) const;
> bool IsExposed(int x, int y, int w, int h) const;
> bool IsExposed(const wxRect &rect) const;
> virtual bool IsRetained() const;
> virtual bool IsShown() const;
> bool IsTopLevel() const;
> void Layout( );
> void Lower( );
> virtual void MakeModal(bool flag );
> void Move(int x, int y );
> void Move(const wxPoint& pt );
> void MoveAfterInTabOrder(wxWindow *win );
> void MoveBeforeInTabOrder(wxWindow *win );
> bool Navigate(int flags = wxNavigationKeyEvent::IsForward );
> wxEvtHandler* PopEventHandler(bool deleteHandler = false) const;
> bool PopupMenu(wxMenu* menu, const wxPoint& pos = wxDefaultPosition );
> bool PopupMenu(wxMenu* menu, int x, int y );
> void PushEventHandler(wxEvtHandler* handler );
> void Raise( );
> virtual void Refresh(bool eraseBackground = true, const wxRect* rect = NULL );
> // don't need to worry about rect, void RefreshRect(const wxRect& rect, bool eraseBackground = true );
> // %win bool RegisterHotKey(int hotkeyId, int modifiers, int virtualKeyCode) - only under WinCE
> virtual void ReleaseMouse( );
> virtual void RemoveChild(wxWindow* child );
> bool RemoveEventHandler(wxEvtHandler *handler );
> virtual bool Reparent(wxWindow* newParent );
> virtual wxPoint ScreenToClient(const wxPoint& pt) const;
> // %override [int x, int y] wxWindow::ScreenToClient(int x, int y) const;
> // C++ Func: virtual void ScreenToClient(int* x, int* y) const;
> %override_name wxLua_wxWindow_ScreenToClientXY virtual void ScreenToClient(int x, int y) const;
> virtual bool ScrollLines(int lines );
> virtual bool ScrollPages(int pages );
> virtual void ScrollWindow(int dx, int dy, const wxRect* rect = NULL );
> virtual void SetAcceleratorTable(const wxAcceleratorTable& accel );
> //void SetAccessible(wxAccessible* accessible );
> void SetAutoLayout(bool autoLayout );
> virtual void SetBackgroundColour(const wxColour& colour );
> virtual void SetBackgroundStyle(wxBackgroundStyle style );
> !%wxchkver_2_8 void SetBestFittingSize(const wxSize& size = wxDefaultSize); // deprecated in 2.8 use SetInitialSize
> void SetCaret(wxCaret *caret) const;
> virtual void SetClientSize(const wxSize& size );
> virtual void SetClientSize(int width, int height );
> void SetContainingSizer(wxSizer* sizer );
> virtual void SetCursor(const wxCursor& cursor );
> !%wxchkver_2_6 void SetConstraints(wxLayoutConstraints* constraints );
> !%wxchkver_2_8 wxWindow* SetDefaultItem(wxWindow *win );
> // virtual void SetInitialBestSize(const wxSize& size) protected
> %wxchkver_2_8 void SetInitialSize(const wxSize& size = wxDefaultSize );
> void SetMaxSize(const wxSize& size );
> void SetMinSize(const wxSize& size );
> void SetOwnBackgroundColour(const wxColour& colour );
> void SetOwnFont(const wxFont& font );
> void SetOwnForegroundColour(const wxColour& colour );
> void SetDropTarget(%ungc wxDropTarget* target );
> void SetEventHandler(wxEvtHandler* handler );
> void SetExtraStyle(long exStyle );
> virtual void SetFocus( );
> //virtual void SetFocusFromKbd( );
> void SetFont(const wxFont& font );
> virtual void SetForegroundColour(const wxColour& colour );
> virtual void SetHelpText(const wxString& helpText );
> void SetId(int id );
> virtual void SetLabel(const wxString& label );
> virtual void SetName(const wxString& name );
> // virtual void SetPalette(wxPalette* palette) - obsolete
> virtual void SetScrollbar(int orientation, int position, int thumbSize, int range, bool refresh = true );
> virtual void SetScrollPos(int orientation, int pos, bool refresh = true );
> virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO );
> virtual void SetSize(int width, int height );
> void SetSize(const wxSize& size );
> virtual void SetSize(const wxRect& rect );
> virtual void SetSizeHints(int minW, int minH, int maxW=-1, int maxH=-1, int incW=-1, int incH=-1 );
> void SetSizeHints(const wxSize& minSize, const wxSize& maxSize=wxDefaultSize, const wxSize& incSize=wxDefaultSize );
> void SetSizer(wxSizer* sizer, bool deleteOld=true );
> void SetSizerAndFit(wxSizer* sizer, bool deleteOld=true );
> !%wxchkver_2_8 virtual void SetTitle(const wxString& title );
> virtual void SetThemeEnabled(bool enable );
> void SetToolTip(const wxString& tip );
> void SetToolTip(%ungc wxToolTip* tip );
> virtual void SetValidator(const wxValidator& validator );
> void SetVirtualSize(int width, int height );
> void SetVirtualSize(const wxSize& size );
> virtual void SetVirtualSizeHints(int minW,int minH, int maxW=-1, int maxH=-1 );
> void SetVirtualSizeHints(const wxSize& minSize=wxDefaultSize, const wxSize& maxSize=wxDefaultSize );
> void SetWindowStyle(long style );
> virtual void SetWindowStyleFlag(long style );
> void SetWindowVariant(wxWindowVariant variant );
> virtual bool ShouldInheritColours( );
> virtual bool Show(bool show = true );
> virtual void Thaw( );
> virtual bool TransferDataFromWindow( );
> virtual bool TransferDataToWindow( );
> //%win bool UnregisterHotKey(int hotkeyId) - only under WinCE
> virtual void Update( );
> virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE );
> virtual bool Validate( );
> void WarpPointer(int x, int y );

};
// ---------------------------------------------------------------------------
// wxWindowList
#if wxLUA_USE_wxWindowList && !wxUSE_STL
class wxWindowList : public wxList
{

> //wxWindowList() - no constructor, just get this from wxWindow::GetChildren( );
> // This is returned from wxWindow::GetChildren(), use wxList methods and
> // wxNode::GetData():DynamicCast("wxWindow") to retrieve the wxWindow
> // Use the wxList methods, see also wxNode

};
#endif //wxLUA_USE_wxWindowList && !wxUSE_STL
// ---------------------------------------------------------------------------
// wxPanel
class wxPanel : public wxWindow
{

> wxPanel( );
> wxPanel(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL, const wxString& name = "wxPanel" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL, const wxString& name = "wxPanel" );
> //!%wxchkver_2_8 wxWindow* GetDefaultItem() const; // - see wxWindow
> // void InitDialog() see wxWindow
> //!%wxchkver_2_8 wxWindow* SetDefaultItem(wxWindow *win) - see wxWindow
> //virtual void SetFocus() - see wxWindow
> virtual void SetFocusIgnoringChildren( );

};
// ---------------------------------------------------------------------------
// wxControl
#include "wx/control.h"
class wxControl : public wxWindow
{

> wxControl( );
> wxControl(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxControl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxControl" );
> void Command(wxCommandEvent& event );
> // wxString GetLabel(); // see wxWindow
> // void SetLabel(const wxString& label); // see wxWindow
> //static wxString GetLabelText(const wxString& label) translates arbitrary string, removes mnemonic characters ('&' );
> %wxchkver_2_8 wxString GetLabelText() const;

};
// ---------------------------------------------------------------------------
// wxBookCtrlBase
#if wxLUA_USE_wxNotebook && wxUSE_BOOKCTRL
#include "wx/bookctrl.h"
#if %wxchkver_2_8
#define wxBK_DEFAULT
#define wxBK_TOP
#define wxBK_LEFT
#define wxBK_RIGHT
#define wxBK_BOTTOM
#define wxBK_ALIGN_MASK
enum
{
wxBK_HITTEST_NOWHERE,
wxBK_HITTEST_ONICON,
wxBK_HITTEST_ONLABEL,
wxBK_HITTEST_ONITEM,
wxBK_HITTEST_ONPAGE
};
#endif // %wxchkver_2_8
class wxBookCtrlBase : public wxControl
{

> // no constructors, base class
> void AdvanceSelection(bool forward = true );
> virtual bool AddPage(wxWindow *page, const wxString& text, bool bSelect = false, int imageId = -1 );
> //void AssignImageList(wxImageList *imageList );
> virtual wxSize CalcSizeFromPage(const wxSize& sizePage) const;
> virtual bool DeleteAllPages( );
> virtual bool DeletePage(size_t n );
> wxWindow *GetCurrentPage() const;
> wxImageList* GetImageList() const;
> virtual wxWindow *GetPage(size_t n );
> virtual size_t GetPageCount() const;
> virtual int GetPageImage(size_t n) const;
> virtual wxString GetPageText(size_t n) const;
> virtual int GetSelection() const;
> virtual bool InsertPage(size_t n, wxWindow *page, const wxString& text, bool bSelect = false, int imageId = -1 );
> virtual bool RemovePage(size_t n );
> virtual void SetImageList(wxImageList *imageList );
> virtual bool SetPageImage(size_t n, int imageId );
> virtual void SetPageSize(const wxSize& size );
> virtual bool SetPageText(size_t n, const wxString& strText );
> virtual int SetSelection(size_t n );
> #if %wxchkver_2_8
> unsigned int GetInternalBorder() const;
> void SetInternalBorder(unsigned int border );
> void SetControlMargin(int margin );
> int GetControlMargin() const;
> bool IsVertical() const;
> void SetFitToCurrentPage(bool fit );
> bool GetFitToCurrentPage() const;
> %wxchkver_2_8 virtual int ChangeSelection(size_t n );
> //virtual int HitTest(const wxPoint& pt, long* flags = NULL) const; // FIXME add this
> //virtual bool HasMultiplePages() const; // - FIXME do we need this?
> wxSizer* GetControlSizer() const;
> #endif // %wxchkver_2_8

};
// ---------------------------------------------------------------------------
// wxBookCtrlBaseEvent
class %delete wxBookCtrlBaseEvent : public wxNotifyEvent
{

> wxBookCtrlBaseEvent(wxEventType commandType = wxEVT_NULL, int winid = 0, int nSel = -1, int nOldSel = -1 );
> int GetOldSelection() const;
> int GetSelection() const; // note : must override wxCommandEvent func since it's not virtual
> void SetOldSelection(int page );
> void SetSelection(int page );

};
#endif //wxLUA_USE_wxNotebook && wxUSE_BOOKCTRL
// ---------------------------------------------------------------------------
// wxNotebook
#if wxLUA_USE_wxNotebook && wxUSE_NOTEBOOK
#include "wx/notebook.h"
//#if !%wxchkver_2_8|%wxcompat_2_6
#define wxNB_TOP // use wxBK_XXX after 2.6
#define wxNB_LEFT
#define wxNB_RIGHT
#define wxNB_BOTTOM
#define wxNB_FIXEDWIDTH
#define wxNB_MULTILINE
#define wxNB_NOPAGETHEME
//#endif // !%wxchkver_2_8|%wxcompat_2_6
enum
{
wxNB_HITTEST_NOWHERE,
wxNB_HITTEST_ONICON,
wxNB_HITTEST_ONLABEL,
wxNB_HITTEST_ONITEM
};
typedef wxWindow wxNotebookPage
class wxNotebook : public wxBookCtrlBase
{

> wxNotebook( );
> wxNotebook(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxNotebook" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxNotebook" );
> // NOTE: All remmed out functions are located in wxBookCtrlBase
> //bool AddPage(wxNotebookPage* page, const wxString& text, bool select = false, int imageId = -1 );
> //void AdvanceSelection(bool forward = true );
> //void AssignImageList(wxImageList* imageList );
> //bool DeleteAllPages( );
> //bool DeletePage(int page );
> //wxWindow* GetCurrentPage() const;
> //wxImageList* GetImageList() const;
> //wxNotebookPage* GetPage(int page );
> //int GetPageCount() const;
> //int GetPageImage(int nPage) const;
> //wxString GetPageText(int nPage) const;
> int GetRowCount() const;
> //int GetSelection() const;
> wxColour GetThemeBackgroundColour() const;
> // %override [int page, int flags] wxNotebook::HitTest(const wxPoint& pt );
> // C++ Func: int HitTest(const wxPoint& pt, long *flags = NULL );
> int HitTest(const wxPoint& pt );
> //bool InsertPage(int index, wxNotebookPage* page, const wxString& text, bool select = false, int imageId = -1 );
> //bool RemovePage(int page );
> //void SetImageList(wxImageList* imageList );
> void SetPadding(const wxSize& padding );
> //void SetPageSize(const wxSize& size );
> //bool SetPageImage(int page, int image );
> //bool SetPageText(int page, const wxString& text );
> //int SetSelection(int page );

};
// ---------------------------------------------------------------------------
// wxNotebookEvent
class %delete wxNotebookEvent : public wxBookCtrlBaseEvent
{

> %wxEventType wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED // EVT_NOTEBOOK_PAGE_CHANGED(winid, fn );
> %wxEventType wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING // EVT_NOTEBOOK_PAGE_CHANGING(winid, fn );
> wxNotebookEvent(wxEventType eventType = wxEVT_NULL, int id = 0, int sel = -1, int oldSel = -1 );
> // functions in wxBookCtrlBaseEvent
> //int GetOldSelection() const;
> //int GetSelection() const;
> //void SetOldSelection(int page );
> //void SetSelection(int page );

};
#endif //wxLUA_USE_wxNotebook && wxUSE_NOTEBOOK
// ---------------------------------------------------------------------------
// wxListbook
#if wxLUA_USE_wxNotebook && wxLUA_USE_wxListCtrl && wxUSE_LISTBOOK
#include "wx/listbook.h"
#define wxLB_DEFAULT
#define wxLB_TOP
#define wxLB_BOTTOM
#define wxLB_LEFT
#define wxLB_RIGHT
#define wxLB_ALIGN_MASK
class wxListbook : public wxBookCtrlBase
{

> wxListbook( );
> wxListbook(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxListbook" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxListbook" );
> // NOTE: See functions in wxBookCtrlBase
> !%wxchkver_2_8 bool IsVertical() const; // in wxBookCtrlBase in 2.8
> wxListView* GetListView( );

};
// ---------------------------------------------------------------------------
// wxListbookEvent
class %delete wxListbookEvent : public wxBookCtrlBaseEvent
{

> %wxEventType wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED // EVT_LISTBOOK_PAGE_CHANGED(winid, fn );
> %wxEventType wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING // EVT_LISTBOOK_PAGE_CHANGING(winid, fn );
> wxListbookEvent(wxEventType eventType = wxEVT_NULL, int id = 0, int sel = -1, int oldSel = -1 );
> // functions in wxBookCtrlBaseEvent
> //int GetOldSelection() const;
> //int GetSelection() const;
> //void SetOldSelection(int page );
> //void SetSelection(int page );

};
#endif //wxLUA_USE_wxNotebook && wxLUA_USE_wxListCtrl && wxUSE_LISTBOOK
// ---------------------------------------------------------------------------
// wxChoicebook
#if wxLUA_USE_wxNotebook && wxLUA_USE_wxChoice && wxUSE_CHOICEBOOK
#include "wx/choicebk.h"
#define wxCHB_DEFAULT
#define wxCHB_TOP
#define wxCHB_BOTTOM
#define wxCHB_LEFT
#define wxCHB_RIGHT
#define wxCHB_ALIGN_MASK
class wxChoicebook : public wxBookCtrlBase
{

> wxChoicebook( );
> wxChoicebook(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxChoicebook" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxChoicebook" );
> // NOTE: See functions in wxBookCtrlBase
> !%wxchkver_2_8 bool IsVertical() const; // in wxBookCtrlBase in 2.8
> wxChoice* GetChoiceCtrl() const;

};
// ---------------------------------------------------------------------------
// wxChoicebookEvent
class %delete wxChoicebookEvent : public wxBookCtrlBaseEvent
{

> %wxEventType wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED // EVT_CHOICEBOOK_PAGE_CHANGED(winid, fn );
> %wxEventType wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING // EVT_CHOICEBOOK_PAGE_CHANGING(winid, fn );
> wxChoicebookEvent(wxEventType eventType = wxEVT_NULL, int id = 0, int sel = -1, int oldSel = -1 );
> // functions in wxBookCtrlBaseEvent
> //int GetOldSelection() const;
> //int GetSelection() const;
> //void SetOldSelection(int page );
> //void SetSelection(int page );

};
#endif //wxLUA_USE_wxNotebook && wxLUA_USE_wxChoice && wxUSE_CHOICEBOOK
// ---------------------------------------------------------------------------
// wxTreebook
#if %wxchkver_2_8 && wxUSE_TREEBOOK && wxLUA_USE_wxTreebook
#include "wx/treebook.h"
class wxTreebook : public wxBookCtrlBase
{

> wxTreebook( );
> wxTreebook(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxBK_DEFAULT, const wxString& name = "wxTreebook" );
> bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxBK_DEFAULT,const wxString& name = "wxTreebook" );
> virtual bool InsertPage(size_t pos, wxWindow *page, const wxString& text, bool bSelect = false, int imageId = wxNOT_FOUND);
> virtual bool InsertSubPage(size_t pos, wxWindow *page, const wxString& text, bool bSelect = false, int imageId = wxNOT_FOUND);
> virtual bool AddPage(wxWindow *page, const wxString& text, bool bSelect = false, int imageId = wxNOT_FOUND);
> virtual bool AddSubPage(wxWindow *page, const wxString& text, bool bSelect = false, int imageId = wxNOT_FOUND);
> virtual bool IsNodeExpanded(size_t pos) const;
> virtual bool ExpandNode(size_t pos, bool expand = true);
> bool CollapseNode(size_t pos );
> int GetPageParent(size_t pos) const;
> wxTreeCtrl* GetTreeCtrl() const;

};
// ---------------------------------------------------------------------------
// wxTreebookEvent
class %delete wxTreebookEvent : public wxBookCtrlBaseEvent
{

> %wxEventType wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED // EVT_TREEBOOK_PAGE_CHANGED(winid, fn );
> %wxEventType wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING // EVT_TREEBOOK_PAGE_CHANGING(winid, fn );
> %wxEventType wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED // EVT_TREEBOOK_NODE_COLLAPSED(winid, fn );
> %wxEventType wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED // EVT_TREEBOOK_NODE_EXPANDED(winid, fn );
> wxTreebookEvent(const wxTreebookEvent& event );
> wxTreebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0, int nSel = wxNOT_FOUND, int nOldSel = wxNOT_FOUND );

};
#endif // %wxchkver_2_8 && wxUSE_TREEBOOK && wxLUA_USE_wxTreebook
// ---------------------------------------------------------------------------
// wxToolbook
#if %wxchkver_2_8 && wxUSE_TOOLBOOK && wxLUA_USE_wxToolbook
#include "wx/toolbook.h"
class wxToolbook : public wxBookCtrlBase
{

> wxToolbook( );
> wxToolbook(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxToolbook" );
> bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxToolbook" );
> wxToolBarBase* GetToolBar() const;
> // must be called in OnIdle or by application to realize the toolbar and select the initial page.
> void Realize();

};
// ---------------------------------------------------------------------------
// wxToolbookEvent
class %delete wxToolbookEvent : public wxBookCtrlBaseEvent
{

> %wxEventType wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGED // EVT_TOOLBOOK_PAGE_CHANGED(winid, fn );
> %wxEventType wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGING // EVT_TOOLBOOK_PAGE_CHANGING(winid, fn );
> wxToolbookEvent(const wxToolbookEvent& event );
> wxToolbookEvent(wxEventType commandType = wxEVT_NULL, int id = 0, int nSel = wxNOT_FOUND, int nOldSel = wxNOT_FOUND );

};
#endif // %wxchkver_2_8 && wxUSE_TOOLBOOK && wxLUA_USE_wxToolbook
// ---------------------------------------------------------------------------
// wxTabCtrl
#if %wxchkver_2_4 && %msw && wxLUA_USE_wxTabCtrl && wxUSE_TAB_DIALOG // note: wxUSE_TAB_DIALOG is correct
#include "wx/tabctrl.h"
class wxTabCtrl : public wxControl
{

> #define wxTC_RIGHTJUSTIFY
> #define wxTC_FIXEDWIDTH
> #define wxTC_TOP
> #define wxTC_LEFT
> #define wxTC_RIGHT
> #define wxTC_BOTTOM
> #define wxTC_MULTILINE
> #define wxTC_OWNERDRAW
> wxTabCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxTabCtrl" );
> //bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxTabCtrl" );
> bool DeleteAllItems( );
> bool DeleteItem(int item );
> int GetCurFocus() const;
> wxImageList* GetImageList() const;
> int GetItemCount() const;
> wxObject * GetItemData(int item) const;
> int GetItemImage(int item) const;
> bool GetItemRect(int item, wxRect& rect) const;
> wxString GetItemText(int item) const;
> int GetRowCount() const;
> int GetSelection() const;
> int HitTest(const wxPoint& pt, long& flags );
> void InsertItem(int item, const wxString& text, int imageId = -1, wxObject *clientData = NULL );
> bool SetItemData(int item, wxObject * data );
> bool SetItemImage(int item, int image );
> void SetImageList(wxImageList* imageList );
> void SetItemSize(const wxSize& size );
> bool SetItemText(int item, const wxString& text );
> void SetPadding(const wxSize& padding );
> int SetSelection(int item );

};
// ---------------------------------------------------------------------------
// wxTabEvent
class %delete wxTabEvent : public wxCommandEvent
{

> %win %wxEventType wxEVT_COMMAND_TAB_SEL_CHANGED // EVT_TAB_SEL_CHANGED(id, fn );
> %win %wxEventType wxEVT_COMMAND_TAB_SEL_CHANGING // EVT_TAB_SEL_CHANGING(id, fn );
> wxTabEvent(wxEventType commandType = 0, int id = 0 );

};
#endif //%wxchkver_2_4 && %msw && wxLUA_USE_wxTabCtrl && wxUSE_TAB_DIALOG
// ---------------------------------------------------------------------------
// wxScrolledWindow
#if wxLUA_USE_wxScrolledWindow
class wxScrolledWindow : public wxPanel
{

> wxScrolledWindow( );
> wxScrolledWindow(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHSCROLL | wxVSCROLL, const wxString& name = "wxScrolledWindow" );
> bool Create(wxWindow* parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHSCROLL | wxVSCROLL, const wxString& name = "wxScrolledWindow" );
> // %override [int xx, int yy] void wxScrolledWindow::CalcScrolledPosition(int x, int y) const;
> // C++ Func: void CalcScrolledPosition( int x, int y, int *xx, int *yy) const;
> void CalcScrolledPosition( int x, int y) const;
> // %override [int xx, int yy] void wxScrolledWindow::CalcUnscrolledPosition(int x, int y) const;
> // C++ Func: void CalcUnscrolledPosition( int x, int y, int *xx, int *yy) const;
> void CalcUnscrolledPosition( int x, int y) const;
> void EnableScrolling(const bool xScrolling, const bool yScrolling );
> // %override [int xUnit, int yUnit] wxScrolledWindow::GetScrollPixelsPerUnit() const;
> // C++ Func: void GetScrollPixelsPerUnit(int* xUnit, int* yUnit) const;
> void GetScrollPixelsPerUnit() const;
> // %override [int x, int y] wxScrolledWindow::GetViewStart() const;
> // C++ Func: void GetViewStart(int* x, int* y) const;
> void GetViewStart() const;
> //// %override [int x, int y] wxScrolledWindow::GetVirtualSize() const;
> //// C++ Func: void GetVirtualSize(int* x, int* y) const;
> //void GetVirtualSize() const; // see wxWindow::GetVirtualSize
> //bool IsRetained() const; // see wxWindow::IsRetained
> void PrepareDC(wxDC& dc );
> void Scroll(int x, int y );
> void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY, int noUnitsX, int noUnitsY, int xPos = 0, int yPos = 0, bool noRefresh = false );
> void SetScrollRate(int xstep, int ystep );
> void SetTargetWindow(wxWindow* window );
> // void SetVirtualSize(int width, int height) -- see wxWindow
> //void DoPrepareDC(wxDC& dc );

};
#endif //wxLUA_USE_wxScrolledWindow
// ---------------------------------------------------------------------------
// wxSplitterWindow
#if wxLUA_USE_wxSplitterWindow
#include "wx/splitter.h"
#define wxSP_NOBORDER
#define wxSP_NOSASH
#define wxSP_BORDER
#define wxSP_PERMIT_UNSPLIT
#define wxSP_LIVE_UPDATE
#define wxSP_3DSASH
#define wxSP_3DBORDER
// #define wxSP_FULLSASH %wxcompat_2_6 obsolete
#define wxSP_3D
%wxchkver_2_4 #define wxSP_NO_XP_THEME
// #define wxSP_SASH_AQUA %wxcompat_2_6 obsolete
class wxSplitterWindow : public wxWindow
{

> wxSplitterWindow( );
> wxSplitterWindow(wxWindow* parent, wxWindowID id, const wxPoint& point = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style=wxSP_3D, const wxString& name = "wxSplitterWindow" );
> bool Create(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSP_3D|wxCLIP_CHILDREN, const wxString& name = "wxSplitterWindow" );
> int GetMinimumPaneSize() const;
> double GetSashGravity( );
> int GetSashPosition( );
> int GetSplitMode() const;
> wxWindow *GetWindow1() const;
> wxWindow *GetWindow2() const;
> void Initialize(wxWindow* window );
> bool IsSplit() const;
> bool ReplaceWindow(wxWindow * winOld, wxWindow * winNew );
> void SetSashGravity(double gravity );
> void SetSashPosition(int position, const bool redraw = true );
> void SetSashSize(int size );
> void SetMinimumPaneSize(int paneSize );
> void SetSplitMode(int mode );
> bool SplitHorizontally(wxWindow* window1, wxWindow* window2, int sashPosition = 0 );
> bool SplitVertically(wxWindow* window1, wxWindow* window2, int sashPosition = 0 );
> bool Unsplit(wxWindow* toRemove = NULL );
> void UpdateSize( );

};
// ---------------------------------------------------------------------------
// wxSplitterEvent
class %delete wxSplitterEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING // EVT_SPLITTER_SASH_POS_CHANGING(id, fn );
> %wxEventType wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED // EVT_SPLITTER_SASH_POS_CHANGED(id, fn );
> %wxEventType wxEVT_COMMAND_SPLITTER_DOUBLECLICKED // EVT_SPLITTER_DCLICK(id, fn );
> %wxEventType wxEVT_COMMAND_SPLITTER_UNSPLIT // EVT_SPLITTER_UNSPLIT(id, fn );
> wxSplitterEvent(wxEventType type = wxEVT_NULL, wxSplitterWindow *splitter = NULL );
> // NOTE! These functions will assert if you call them for an unspupported
> // event type. Please refer to the wxWidgets C++ manual.
> int GetSashPosition( );
> int GetX( );
> int GetY( );
> wxWindow* GetWindowBeingRemoved( );
> void SetSashPosition(int pos );

};
#endif //wxLUA_USE_wxSplitterWindow
// ---------------------------------------------------------------------------
// wxPopupWindow
#if wxLUA_USE_wxPopupWindow
#include "wx/popupwin.h"
class wxPopupWindow : public wxWindow
{

> wxPopupWindow(wxWindow* parent, int flags = wxBORDER_NONE );
> bool Create(wxWindow* parent, int flags = wxBORDER_NONE );
> virtual void Position(const wxPoint &ptOrigin, const wxSize &sizePopup );

};
#endif // wxLUA_USE_wxPopupWindow
// ---------------------------------------------------------------------------
// wxPopupTransientWindow
#if wxLUA_USE_wxPopupTransientWindow
#include "wx/popupwin.h"
class wxPopupTransientWindow : public wxPopupWindow
{

> wxPopupTransientWindow( );
> wxPopupTransientWindow(wxWindow *parent, int flags = wxBORDER_NONE );
> virtual void Popup(wxWindow *focus = NULL );
> virtual void Dismiss( );
> virtual void ProcessLeftDown(wxMouseEvent &event );

};
#endif // wxLUA_USE_wxPopupTransientWindow
// ---------------------------------------------------------------------------
// wxCollapsiblePane
#if %wxchkver_2_8 && wxLUA_USE_wxCollapsiblePane && wxUSE_COLLPANE
#include "wx/collpane.h"
#define wxCP_DEFAULT_STYLE
class wxCollapsiblePane : public wxControl
{

> wxCollapsiblePane( );
> wxCollapsiblePane(wxWindow *parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxCollapsiblePane" );
> bool Create(wxWindow *parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCP_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxCollapsiblePane" );
> bool IsCollapsed() const;
> bool IsExpanded() const;
> void Collapse(bool collapse = true );
> void Expand( );
> wxWindow* GetPane() const;

};
// ---------------------------------------------------------------------------
// wxCollapsiblePaneEvent
class %delete wxCollapsiblePaneEvent : public wxCommandEvent
{

> %wxEventType wxEVT_COMMAND_COLLPANE_CHANGED // EVT_COLLAPSIBLEPANE_CHANGED(id, fn );
> wxCollapsiblePaneEvent( );
> wxCollapsiblePaneEvent(wxObject *generator, int id, bool collapsed );
> bool GetCollapsed() const;
> void SetCollapsed(bool c );

};
#endif // %wxchkver_2_8 && wxLUA_USE_wxCollapsiblePane && wxUSE_COLLPANE
// ---------------------------------------------------------------------------
// wxStaticBox
#if wxLUA_USE_wxStaticBox && wxUSE_STATBOX
#include "wx/statbox.h"
class wxStaticBox : public wxControl
{

> wxStaticBox( );
> wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxStaticBox" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxStaticBox" );

};
#endif //wxLUA_USE_wxStaticBox && wxUSE_STATBOX
// ---------------------------------------------------------------------------
// wxStaticBitmap
#if wxLUA_USE_wxStaticBitmap && wxUSE_STATBMP
#include "wx/statbmp.h"
class wxStaticBitmap : public wxControl
{

> wxStaticBitmap( );
> wxStaticBitmap(wxWindow* parent, wxWindowID id, const wxBitmap& label = wxNullBitmap, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxStaticBitmap" );
> bool Create(wxWindow* parent, wxWindowID id, const wxBitmap& label = wxNullBitmap, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxStaticBitmap" );
> wxBitmap GetBitmap() const;
> virtual void SetBitmap(const wxBitmap& label );

};
#endif //wxLUA_USE_wxStaticBitmap && wxUSE_STATBMP
// ---------------------------------------------------------------------------
// wxStaticText
#if wxLUA_USE_wxStaticText && wxUSE_STATTEXT
#include "wx/stattext.h"
#define wxST_NO_AUTORESIZE
%wxchkver_2_8 && !%wxchkver_2_9_2 #define wxST_DOTS_MIDDLE
%wxchkver_2_8 && !%wxchkver_2_9_2 #define wxST_DOTS_END
class wxStaticText : public wxControl
{

> wxStaticText( );
> wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxStaticText" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxStaticText" );
> // wxString GetLabel() const; // - see wxWindow
> // void SetLabel(const wxString& label) - see wxWindow
> void Wrap(int width );

};
#endif //wxLUA_USE_wxStaticText && wxUSE_STATTEXT
// ---------------------------------------------------------------------------
// wxStaticLine
#if wxLUA_USE_wxStaticLine && wxUSE_STATLINE
#include "wx/statline.h"
#define wxLI_HORIZONTAL
#define wxLI_VERTICAL
class wxStaticLine : public wxControl
{

> wxStaticLine( );
> wxStaticLine(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxLI_HORIZONTAL, const wxString& name = "wxStaticLine" );
> bool Create(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "wxStaticLine" );
> bool IsVertical() const;
> static int GetDefaultSize( );

};
#endif //wxLUA_USE_wxStaticLine && wxUSE_STATLINE

## wxwidgets/wxadv_adv.i - Lua table = 'wx'

// ===========================================================================
// Purpose: Various wxAdv library classes
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxAboutDialog
#if %wxchkver_2_8 && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
#include "wx/aboutdlg.h"
class %delete wxAboutDialogInfo
{

> wxAboutDialogInfo( );
> void SetName(const wxString& name );
> wxString GetName() const;
> void SetVersion(const wxString& version );
> bool HasVersion() const;
> wxString GetVersion() const;
> void SetDescription(const wxString& desc );
> bool HasDescription() const;
> wxString GetDescription() const;
> void SetCopyright(const wxString& copyright );
> bool HasCopyright() const;
> wxString GetCopyright() const;
> void SetLicence(const wxString& licence );
> void SetLicense(const wxString& licence );
> bool HasLicence() const;
> wxString GetLicence() const;
> void SetIcon(const wxIcon& icon );
> bool HasIcon() const;
> wxIcon GetIcon() const;
> void SetWebSite(const wxString& url, const wxString& desc = "" );
> bool HasWebSite() const;
> wxString GetWebSiteURL() const;
> wxString GetWebSiteDescription() const;
> void SetDevelopers(const wxArrayString& developers );
> void AddDeveloper(const wxString& developer );
> bool HasDevelopers() const;
> const wxArrayString& GetDevelopers() const;
> void SetDocWriters(const wxArrayString& docwriters );
> void AddDocWriter(const wxString& docwriter );
> bool HasDocWriters() const;
> wxArrayString GetDocWriters() const;
> void SetArtists(const wxArrayString& artists );
> void AddArtist(const wxString& artist );
> bool HasArtists() const;
> wxArrayString GetArtists() const;
> void SetTranslators(const wxArrayString& translators );
> void AddTranslator(const wxString& translator );
> bool HasTranslators() const;
> wxArrayString GetTranslators() const;
> // implementation only
> // -------------------
> bool IsSimple() const;
> wxString GetDescriptionAndCredits() const;

};
void wxAboutBox(const wxAboutDialogInfo& info );
#endif //%wxchkver_2_8 && wxUSE_ABOUTDLG && wxLUA_USE_wxAboutDialog
// ---------------------------------------------------------------------------
// wxAnimation
#if %wxchkver_2_8 && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
#include "wx/animate.h"
enum wxAnimationType
{

> wxANIMATION_TYPE_INVALID,
> wxANIMATION_TYPE_GIF,
> wxANIMATION_TYPE_ANI,
> wxANIMATION_TYPE_ANY

};
class %delete wxAnimation : public wxGDIObject // ignore platform independent wxAnimationBase
{

> wxAnimation( );
> wxAnimation(const wxAnimation& anim );
> //wxAnimation(const wxString& name, wxAnimationType type = wxANIMATION_TYPE_ANY); // doesn't exist in 2.8.4
> virtual bool IsOk() const;
> virtual int GetDelay(unsigned int frame) const; // can be -1
> virtual unsigned int GetFrameCount() const;
> virtual wxImage GetFrame(unsigned int frame) const;
> virtual wxSize GetSize() const;
> virtual bool LoadFile(const wxString& name, wxAnimationType type = wxANIMATION_TYPE_ANY );
> virtual bool Load(wxInputStream& stream, wxAnimationType type = wxANIMATION_TYPE_ANY );

};
// ---------------------------------------------------------------------------
// wxAnimationCtrl
#define wxAC_NO_AUTORESIZE
#define wxAC_DEFAULT_STYLE // = wxNO_BORDER
class wxAnimationCtrl : public wxControl
{

> wxAnimationCtrl( );
> wxAnimationCtrl(wxWindow *parent, wxWindowID id, const wxAnimation& anim, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxAC_DEFAULT_STYLE, const wxString& name = "wxAnimationCtrl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxAnimation& anim, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxAC_DEFAULT_STYLE, const wxString& name = "wxAnimationCtrl" );
> virtual bool LoadFile(const wxString& filename, wxAnimationType type = wxANIMATION_TYPE_ANY );
> wxAnimation GetAnimation() const;
> // always return the original bitmap set in this control
> wxBitmap GetInactiveBitmap() const;
> virtual bool IsPlaying() const;
> bool LoadFile(const wxString& file, wxAnimationType animType = wxANIMATION_TYPE_ANY );
> virtual bool Play( );
> virtual void SetAnimation(const wxAnimation &anim );
> virtual void SetInactiveBitmap(const wxBitmap &bmp );
> virtual void Stop( );

};
#endif // %wxchkver_2_8 && wxLUA_USE_wxAnimation && wxUSE_ANIMATIONCTRL
// ---------------------------------------------------------------------------
// wxBitmapComboBox
#if wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
#include "wx/bmpcbox.h"
class wxBitmapComboBox : public wxControl
{

> wxBitmapComboBox( );
> //wxBitmapComboBox(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, int n = 0, const wxString choices[] = NULL, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "comboBox" );
> wxBitmapComboBox(wxWindow* parent, wxWindowID id, const wxString& value, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxBitmapComboBox" );
> //bool Create(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, int n, const wxString choices[], long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxBitmapComboBox" );
> bool Create(wxWindow* parent, wxWindowID id, const wxString& value, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxArrayString& choices = wxLuaNullSmartwxArrayString, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxBitmapComboBox" );
> int Append(const wxString& item, const wxBitmap& bitmap = wxNullBitmap );
> int Append(const wxString& item, const wxBitmap& bitmap, voidptr_long data ); // C++ is (void *clientData) You can put a number here
> int Append(const wxString& item, const wxBitmap& bitmap, wxClientData *clientData );
> wxSize GetBitmapSize() const;
> wxBitmap GetItemBitmap(unsigned int n) const;
> int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos );
> #if !%wxchkver_2_9_0 || %wxchkver_2_9_5 // This function body was missing so you'd get linker errors
> int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos, voidptr_long data ); // C++ is (void *clientData) You can put a number here
> #endif
> int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos, wxClientData *clientData );
> void SetItemBitmap(unsigned int n, const wxBitmap& bitmap );
> void Clear( );
> void Delete(unsigned int n );
> unsigned int GetCount() const;
> wxString GetString(unsigned int n) const;
> void SetString(unsigned int n, const wxString& s );
> int FindString(const wxString& s, bool bCase = false) const;
> void Select(int n );
> int GetSelection() const;
> //void GetSelection(long* from, long* to) const;
> void SetSelection(int n );
> //void SetSelection(long from, long to );
> //int GetWidestItemWidth( );
> //int GetWidestItem( );
> void SetValue(const wxString& value );
> void SetString(unsigned int n, const wxString& s );
> bool SetStringSelection(const wxString& s );

};
#endif //wxLUA_USE_wxBitmapComboBox && wxUSE_BITMAPCOMBOBOX
// ---------------------------------------------------------------------------
// wxCalendarCtrl
#if wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
#include "wx/calctrl.h"
enum
{
wxCAL_SUNDAY_FIRST,
wxCAL_MONDAY_FIRST,
wxCAL_SHOW_HOLIDAYS,
wxCAL_NO_YEAR_CHANGE,
wxCAL_NO_MONTH_CHANGE,
wxCAL_SHOW_SURROUNDING_WEEKS,
wxCAL_SEQUENTIAL_MONTH_SELECTION
};
enum wxCalendarHitTestResult
{

> wxCAL_HITTEST_NOWHERE,
> wxCAL_HITTEST_HEADER,
> wxCAL_HITTEST_DAY,
> wxCAL_HITTEST_INCMONTH,
> wxCAL_HITTEST_DECMONTH,
> wxCAL_HITTEST_SURROUNDING_WEEK

};
enum wxCalendarDateBorder
{

> wxCAL_BORDER_NONE,
> wxCAL_BORDER_SQUARE,
> wxCAL_BORDER_ROUND

};
class wxCalendarCtrl : public wxControl
{

> wxCalendarCtrl(wxWindow* parent, wxWindowID id, const wxDateTime& date = wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCAL_SHOW_HOLIDAYS, const wxString& name = "wxCalendarCtrl" );
> //bool Create(wxWindow* parent, wxWindowID id, const wxDateTime& date = wxDefaultDateTime, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxCAL_SHOW_HOLIDAYS, const wxString& name = "wxCalendarCtrl" );
> void SetDate(const wxDateTime& date );
> wxDateTime GetDate() const;
> #if !%wxchkver_2_9_2
> void EnableYearChange(bool enable = true );
> #endif
> void EnableMonthChange(bool enable = true );
> void EnableHolidayDisplay(bool display = true );
> void SetHeaderColours(const wxColour& colFg, const wxColour& colBg );
> wxColour GetHeaderColourFg() const;
> wxColour GetHeaderColourBg() const;
> void SetHighlightColours(const wxColour& colFg, const wxColour& colBg );
> wxColour GetHighlightColourFg() const;
> wxColour GetHighlightColourBg() const;
> void SetHolidayColours(const wxColour& colFg, const wxColour& colBg );
> wxColour GetHolidayColourFg() const;
> wxColour GetHolidayColourBg() const;
> wxCalendarDateAttr* GetAttr(size_t day) const;
> void SetAttr(size_t day, %ungc wxCalendarDateAttr* attr); // will delete previously set attr as well
> void SetHoliday(size_t day );
> void ResetAttr(size_t day );
> // %override [wxCalendarHitTestResult, wxDateTime date, wxDateTime::WeekDay wd] wxCalendarCtrl::HitTest(const wxPoint& pos );
> // C++ Func: wxCalendarHitTestResult HitTest(const wxPoint& pos, wxDateTime* date = NULL, wxDateTime::WeekDay* wd = NULL );
> wxCalendarHitTestResult HitTest(const wxPoint& pos );

};
// ---------------------------------------------------------------------------
// wxCalendarDateAttr
class %delete wxCalendarDateAttr
{

> wxCalendarDateAttr( );
> wxCalendarDateAttr(const wxColour& colText, const wxColour& colBack = wxNullColour, const wxColour& colBorder = wxNullColour, const wxFont& font = wxNullFont, wxCalendarDateBorder border = wxCAL_BORDER_NONE );
> wxCalendarDateAttr(wxCalendarDateBorder border, const wxColour& colBorder = wxNullColour );
> void SetTextColour(const wxColour& colText );
> void SetBackgroundColour(const wxColour& colBack );
> void SetBorderColour(const wxColour& col );
> void SetFont(const wxFont& font );
> void SetBorder(wxCalendarDateBorder border );
> void SetHoliday(bool holiday );
> bool HasTextColour() const;
> bool HasBackgroundColour() const;
> bool HasBorderColour() const;
> bool HasFont() const;
> bool HasBorder() const;
> bool IsHoliday() const;
> wxColour GetTextColour() const;
> wxColour GetBackgroundColour( );
> wxColour GetBorderColour() const;
> wxFont GetFont() const;
> wxCalendarDateBorder GetBorder( );

};
// ---------------------------------------------------------------------------
// wxDateEvent
#include "wx/dateevt.h"
class %delete wxDateEvent : public wxCommandEvent
{

> %wxEventType wxEVT_DATE_CHANGED // EVT_DATE_CHANGED(id, fn );
> wxDateEvent(wxWindow *win, const wxDateTime& dt, wxEventType type );
> wxDateTime GetDate() const;
> void SetDate(const wxDateTime &date );

};
// ---------------------------------------------------------------------------
// wxCalendarEvent
#include "wx/event.h"
class %delete wxCalendarEvent : public wxDateEvent
{

> %wxEventType wxEVT_CALENDAR_SEL_CHANGED // EVT_CALENDAR_SEL_CHANGED(id, fn );
> %wxEventType wxEVT_CALENDAR_DAY_CHANGED // EVT_CALENDAR_DAY(id, fn );
> %wxEventType wxEVT_CALENDAR_MONTH_CHANGED // EVT_CALENDAR_MONTH(id, fn );
> %wxEventType wxEVT_CALENDAR_YEAR_CHANGED // EVT_CALENDAR_YEAR(id, fn );
> %wxEventType wxEVT_CALENDAR_DOUBLECLICKED // EVT_CALENDAR(id, fn );
> %wxEventType wxEVT_CALENDAR_WEEKDAY_CLICKED // EVT_CALENDAR_WEEKDAY_CLICKED(id, fn );
> %wxchkver_2_9_2 wxCalendarEvent(const wxCalendarEvent& event );
> !%wxchkver_2_9_2 wxCalendarEvent(wxCalendarCtrl *cal, wxEventType type );
> %wxchkver_2_9_2 wxCalendarEvent(wxWindow *win, const wxDateTime& dt, wxEventType type );
> wxDateTime::WeekDay GetWeekDay() const;
> void SetWeekDay(const wxDateTime::WeekDay wd );

};
#endif //wxLUA_USE_wxCalendarCtrl && wxUSE_CALENDARCTRL
// ---------------------------------------------------------------------------
// wxHyperlinkCtrl
#if %wxchkver_2_8 && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
#include "wx/hyperlink.h"
#define wxHL_CONTEXTMENU
#define wxHL_ALIGN_LEFT
#define wxHL_ALIGN_RIGHT
#define wxHL_ALIGN_CENTRE
#define wxHL_DEFAULT_STYLE // (wxHL_CONTEXTMENU|wxNO_BORDER|wxHL_ALIGN_CENTRE );
class wxHyperlinkCtrl : public wxControl
{

> wxHyperlinkCtrl( );
> wxHyperlinkCtrl(wxWindow *parent, wxWindowID id, const wxString& label, const wxString& url, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHL_DEFAULT_STYLE, const wxString& name = "wxHyperlinkCtrl" );
> bool Create(wxWindow *parent, wxWindowID id, const wxString& label, const wxString& url, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHL_DEFAULT_STYLE, const wxString& name = "wxHyperlinkCtrl");
> wxColour GetHoverColour() const;
> wxColour GetNormalColour() const;
> wxColour GetVisitedColour() const;
> bool GetVisited() const;
> wxString GetURL() const;
> void SetHoverColour(const wxColour &colour );
> void SetNormalColour(const wxColour &colour);
> void SetVisitedColour(const wxColour &colour);
> void SetVisited(bool visited = true );
> void SetURL (const wxString &url );

};
// ---------------------------------------------------------------------------
// wxHyperlinkEvent
class %delete wxHyperlinkEvent : public wxCommandEvent
{

> %wxEventType wxEVT_COMMAND_HYPERLINK // EVT_HYPERLINK(id, fn );
> //wxHyperlinkEvent( );
> wxHyperlinkEvent(wxObject *generator, wxWindowID id, const wxString& url );
> wxString GetURL() const;
> void SetURL(const wxString &url );

};
#endif // %wxchkver_2_8 && wxUSE_HYPERLINKCTRL && wxLUA_USE_wxHyperlinkCtrl
// ---------------------------------------------------------------------------
// wxSashWindow
#if wxLUA_USE_wxSashWindow && wxUSE_SASH
#include "wx/sashwin.h"
#define wxSW_3D
#define wxSW_3DSASH
#define wxSW_3DBORDER
#define wxSW_BORDER
enum wxSashEdgePosition
{

> wxSASH_TOP,
> wxSASH_RIGHT,
> wxSASH_BOTTOM,
> wxSASH_LEFT,
> wxSASH_NONE

};
enum wxSashDragStatus
{

> wxSASH_STATUS_OK,
> wxSASH_STATUS_OUT_OF_RANGE

};
class wxSashWindow : public wxWindow
{

> wxSashWindow( );
> wxSashWindow(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = "wxSashWindow" );
> bool GetSashVisible(wxSashEdgePosition edge) const;
> int GetMaximumSizeX() const;
> int GetMaximumSizeY() const;
> int GetMinimumSizeX() const;
> int GetMinimumSizeY() const;
> void SetMaximumSizeX(int min );
> void SetMaximumSizeY(int min );
> void SetMinimumSizeX(int min );
> void SetMinimumSizeY(int min );
> void SetSashVisible(wxSashEdgePosition edge, bool visible );
> %wxcompat_2_6 bool HasBorder(wxSashEdgePosition edge) const;
> %wxcompat_2_6 void SetSashBorder(wxSashEdgePosition edge, bool hasBorder );

};
// ---------------------------------------------------------------------------
// wxSashLayoutWindow
#include "wx/laywin.h"
enum wxLayoutAlignment
{

> wxLAYOUT_NONE,
> wxLAYOUT_TOP,
> wxLAYOUT_LEFT,
> wxLAYOUT_RIGHT,
> wxLAYOUT_BOTTOM

};
enum wxLayoutOrientation
{

> wxLAYOUT_HORIZONTAL,
> wxLAYOUT_VERTICAL

};
class wxSashLayoutWindow : public wxSashWindow
{

> wxSashLayoutWindow( );
> wxSashLayoutWindow(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = "wxSashLayoutWindow" );
> bool Create(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSW_3D|wxCLIP_CHILDREN, const wxString& name = "wxSashLayoutWindow" );
> wxLayoutAlignment GetAlignment() const;
> wxLayoutOrientation GetOrientation() const;
> //void OnCalculateLayout(wxCalculateLayoutEvent& event );
> //void OnQueryLayoutInfo(wxQueryLayoutInfoEvent& event );
> void SetAlignment(wxLayoutAlignment alignment );
> void SetDefaultSize(const wxSize& size );
> void SetOrientation(wxLayoutOrientation orientation );

};
// ---------------------------------------------------------------------------
// wxLayoutAlgorithm - for wxSashLayoutWindow
#include "wx/laywin.h"
class %delete wxLayoutAlgorithm : public wxObject
{

> wxLayoutAlgorithm( );
> bool LayoutFrame(wxFrame* frame, wxWindow* mainWindow = NULL) const;
> bool LayoutMDIFrame(wxMDIParentFrame* frame, wxRect* rect = NULL );
> bool LayoutWindow(wxWindow* frame, wxWindow* mainWindow = NULL );

};
// ---------------------------------------------------------------------------
// wxQueryLayoutInfoEvent - for wxSashLayoutWindow
#include "wx/laywin.h"
class %delete wxQueryLayoutInfoEvent : public wxEvent
{

> %wxEventType wxEVT_QUERY_LAYOUT_INFO // EVT_QUERY_LAYOUT_INFO(func );
> wxQueryLayoutInfoEvent(wxWindowID id = 0 );
> wxLayoutAlignment GetAlignment() const;
> int GetFlags() const;
> wxLayoutOrientation GetOrientation() const;
> int GetRequestedLength() const;
> wxSize GetSize() const;
> void SetAlignment(wxLayoutAlignment alignment );
> void SetFlags(int flags );
> void SetOrientation(wxLayoutOrientation orientation );
> void SetRequestedLength(int length );
> void SetSize(const wxSize& size );

};
// ---------------------------------------------------------------------------
// wxCalculateLayoutEvent - for wxSashLayoutWindow
#include "wx/laywin.h"
class %delete wxCalculateLayoutEvent : public wxEvent
{

> %wxEventType wxEVT_CALCULATE_LAYOUT // EVT_CALCULATE_LAYOUT(func );
> wxCalculateLayoutEvent(wxWindowID id = 0 );
> int GetFlags() const;
> wxRect GetRect() const;
> void SetFlags(int flags );
> void SetRect(const wxRect& rect );

};
// ---------------------------------------------------------------------------
// wxSashEvent
class %delete wxSashEvent : public wxCommandEvent
{

> %wxEventType wxEVT_SASH_DRAGGED // EVT_SASH_DRAGGED(id, fn) EVT_SASH_DRAGGED_RANGE(id1, id2, fn );
> wxSashEvent(int id = 0, wxSashEdgePosition edge = wxSASH_NONE );
> void SetEdge(wxSashEdgePosition edge );
> int GetEdge( );
> void SetDragRect(const wxRect& rect );
> wxRect GetDragRect( );
> void SetDragStatus(wxSashDragStatus status );
> int GetDragStatus( );

};
#endif //wxLUA_USE_wxSashWindow && wxUSE_SASH
// ---------------------------------------------------------------------------
// wxSplashScreen
#if wxLUA_USE_wxSplashScreen
#include "wx/splash.h"
#define wxSPLASH_CENTRE_ON_PARENT
#define wxSPLASH_CENTRE_ON_SCREEN
#define wxSPLASH_NO_CENTRE
#define wxSPLASH_TIMEOUT
#define wxSPLASH_NO_TIMEOUT
class wxSplashScreen : public wxFrame
{

> wxSplashScreen(const wxBitmap& bitmap, long splashStyle, int milliseconds, wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP );
> long GetSplashStyle() const;
> wxSplashScreenWindow* GetSplashWindow() const;
> int GetTimeout() const;

};
class wxSplashScreenWindow : public wxWindow
{

> // don't need to create this, just get it from wxSplashScreen
> void SetBitmap(const wxBitmap& bitmap );
> wxBitmap& GetBitmap( );

};
#endif //wxLUA_USE_wxSplashScreen
// ---------------------------------------------------------------------------
// wxWizard
#if wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
#include "wx/wizard.h"
#define wxWIZARD_EX_HELPBUTTON
class wxWizard : public wxDialog
{

> wxWizard( );
> wxWizard(wxWindow* parent, int id = -1, const wxString& title = "", const wxBitmap& bitmap = wxNullBitmap, const wxPoint& pos = wxDefaultPosition, long style = wxDEFAULT_DIALOG_STYLE );
> bool Create(wxWindow* parent, int id = -1, const wxString& title = "", const wxBitmap& bitmap = wxNullBitmap, const wxPoint& pos = wxDefaultPosition, long style = wxDEFAULT_DIALOG_STYLE );
> wxWizardPage* GetCurrentPage() const;
> virtual wxSizer* GetPageAreaSizer() const;
> wxSize GetPageSize() const;
> virtual bool HasNextPage(wxWizardPage *page );
> virtual bool HasPrevPage(wxWizardPage *page );
> bool RunWizard(wxWizardPage* firstPage );
> void SetPageSize(const wxSize& sizePage );
> void SetBorder(int border );

};
// ---------------------------------------------------------------------------
// wxWizardPage - this has virtual functions so it can't be used?
class wxWizardPage : public wxPanel
{

> //wxWizardPage(wxWizard* parent, const wxBitmap& bitmap = wxNullBitmap, const wxChar *resource = NULL );
> //virtual wxWizardPage* GetPrev() const; // FIXME not virtual for wxLua
> //virtual wxWizardPage* GetNext() const;
> wxBitmap GetBitmap() const;

};
// ---------------------------------------------------------------------------
// wxWizardPageSimple - use this
class wxWizardPageSimple : public wxWizardPage
{

> wxWizardPageSimple(wxWizard* parent = NULL, wxWizardPage* prev = NULL, wxWizardPage* next = NULL, const wxBitmap& bitmap = wxNullBitmap );
> virtual wxWizardPage* GetPrev() const;
> virtual wxWizardPage* GetNext() const;
> void SetPrev(wxWizardPage* prev );
> void SetNext(wxWizardPage* next );
> static void Chain(wxWizardPageSimple* first, wxWizardPageSimple* second );

};
// ---------------------------------------------------------------------------
// wxWizardEvent
class %delete wxWizardEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_WIZARD_CANCEL // EVT_WIZARD_CANCEL(id, fn );
> %wxEventType wxEVT_WIZARD_PAGE_CHANGED // EVT_WIZARD_PAGE_CHANGED(id, fn );
> %wxEventType wxEVT_WIZARD_PAGE_CHANGING // EVT_WIZARD_PAGE_CHANGING(id, fn );
> %wxEventType wxEVT_WIZARD_HELP // EVT_WIZARD_HELP(id, fn );
> %wxEventType wxEVT_WIZARD_FINISHED // EVT_WIZARD_FINISHED(id, fn );
> wxWizardEvent(wxEventType type = wxEVT_NULL, int id = -1, bool direction = true );
> bool GetDirection() const;
> wxWizardPage* GetPage() const;

};
#endif //wxUSE_WIZARDDLG && wxLUA_USE_wxWizard
// ---------------------------------------------------------------------------
// wxTaskBarIcon
#if wxLUA_USE_wxTaskBarIcon && defined(wxHAS_TASK_BAR_ICON );
#include "wx/taskbar.h"
class %delete wxTaskBarIcon : public wxEvtHandler
{

> wxTaskBarIcon( );
> // virtual wxMenu* CreatePopupMenu( );
> bool IsIconInstalled( );
> %wxchkver_2_4 bool IsOk( );
> virtual bool PopupMenu(wxMenu* menu );
> // call RemoveIcon() or delete this if you want your program to exit, must have called SetIcon( );
> bool RemoveIcon( );
> // call SetIcon() to have the taskbar icon displayed
> bool SetIcon(const wxIcon& icon, const wxString& tooltip );

};
// ---------------------------------------------------------------------------
// wxTaskBarIconEvent
class %delete wxTaskBarIconEvent : public wxEvent
{

> %wxEventType wxEVT_TASKBAR_MOVE // EVT_TASKBAR_MOVE(func );
> %wxEventType wxEVT_TASKBAR_LEFT_DOWN // EVT_TASKBAR_LEFT_DOWN(func );
> %wxEventType wxEVT_TASKBAR_LEFT_UP // EVT_TASKBAR_LEFT_UP(func );
> %wxEventType wxEVT_TASKBAR_RIGHT_DOWN // EVT_TASKBAR_RIGHT_DOWN(func );
> %wxEventType wxEVT_TASKBAR_RIGHT_UP // EVT_TASKBAR_RIGHT_UP(func );
> %wxEventType wxEVT_TASKBAR_LEFT_DCLICK // EVT_TASKBAR_LEFT_DCLICK(func );
> %wxEventType wxEVT_TASKBAR_RIGHT_DCLICK // EVT_TASKBAR_RIGHT_DCLICK(func );
> wxTaskBarIconEvent(wxEventType evtType, wxTaskBarIcon *tbIcon );

};
#endif //wxLUA_USE_wxTaskBarIcon && defined(wxHAS_TASK_BAR_ICON );
// ---------------------------------------------------------------------------
// wxJoystick
#if wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
#include "wx/joystick.h"
enum
{
wxJOYSTICK1,
wxJOYSTICK2
};
enum
{
wxJOY_BUTTON_ANY,
wxJOY_BUTTON1,
wxJOY_BUTTON2,
wxJOY_BUTTON3,
wxJOY_BUTTON4
};
class %delete wxJoystick : public wxObject
{

> wxJoystick(int joystick = wxJOYSTICK1 );
> int GetButtonState() const;
> int GetManufacturerId() const;
> int GetMovementThreshold() const;
> int GetNumberAxes() const;
> int GetNumberButtons() const;
> %wxchkver_2_8 static int GetNumberJoysticks() const;
> !%wxchkver_2_8 int GetNumberJoysticks() const;
> int GetPollingMax() const;
> int GetPollingMin() const;
> int GetProductId() const;
> wxString GetProductName() const;
> wxPoint GetPosition() const;
> int GetPOVPosition() const;
> int GetPOVCTSPosition() const;
> int GetRudderMax() const;
> int GetRudderMin() const;
> int GetRudderPosition() const;
> int GetUMax() const;
> int GetUMin() const;
> int GetUPosition() const;
> int GetVMax() const;
> int GetVMin() const;
> int GetVPosition() const;
> int GetXMax() const;
> int GetXMin() const;
> int GetYMax() const;
> int GetYMin() const;
> int GetZMax() const;
> int GetZMin() const;
> int GetZPosition() const;
> bool HasPOV() const;
> bool HasPOV4Dir() const;
> bool HasPOVCTS() const;
> bool HasRudder() const;
> bool HasU() const;
> bool HasV() const;
> bool HasZ() const;
> bool IsOk() const;
> bool ReleaseCapture( );
> bool SetCapture(wxWindow* win, int pollingFreq = 0 );
> void SetMovementThreshold(int threshold );

};
// ---------------------------------------------------------------------------
// wxJoystickEvent
#include "wx/event.h"
class %delete wxJoystickEvent : public wxEvent
{

> %wxEventType wxEVT_JOY_BUTTON_DOWN // EVT_JOY_BUTTON_DOWN(func );
> %wxEventType wxEVT_JOY_BUTTON_UP // EVT_JOY_BUTTON_UP(func );
> %wxEventType wxEVT_JOY_MOVE // EVT_JOY_MOVE(func );
> %wxEventType wxEVT_JOY_ZMOVE // EVT_JOY_ZMOVE(func );
> wxJoystickEvent(wxEventType eventType = wxEVT_NULL, int state = 0, int joystick = wxJOYSTICK1, int change = 0 );
> bool ButtonDown(int button = wxJOY_BUTTON_ANY) const;
> bool ButtonIsDown(int button = wxJOY_BUTTON_ANY) const;
> bool ButtonUp(int button = wxJOY_BUTTON_ANY) const;
> int GetButtonChange() const;
> int GetButtonState() const;
> int GetJoystick() const;
> wxPoint GetPosition() const;
> int GetZPosition() const;
> bool IsButton() const;
> bool IsMove() const;
> bool IsZMove() const;

};
#endif //wxLUA_USE_wxJoystick && wxUSE_JOYSTICK
// ---------------------------------------------------------------------------
// wxSound
#if wxLUA_USE_wxWave
wxUSE_SOUND|(%msw&wxUSE_WAVE) #define wxSOUND_SYNC
wxUSE_SOUND|(%msw&wxUSE_WAVE) #define wxSOUND_ASYNC
wxUSE_SOUND|(%msw&wxUSE_WAVE) #define wxSOUND_LOOP
#if %wxchkver_2_6 && wxUSE_SOUND
#include "wx/sound.h"
class %delete wxSound : public wxObject
{

> wxSound( );
> wxSound(const wxString& fileName, bool isResource = false );
> //wxSound(int size, const wxByte* data );
> bool Create(const wxString& fileName, bool isResource = false );
> //bool Create(int size, const wxByte* data );
> bool IsOk() const;
> !%win static bool IsPlaying() const;
> bool Play(unsigned int flags = wxSOUND_ASYNC) const;
> static bool Play(const wxString& filename, unsigned flags = wxSOUND_ASYNC );
> static void Stop( );

};
#endif // %wxchkver_2_6 && wxUSE_SOUND
// ---------------------------------------------------------------------------
// wxWave
#if %msw && !%wxchkver_2_6 && wxUSE_WAVE
#include "wx/wave.h"
class %delete wxWave : public wxObject
{

> wxWave( );
> wxWave(const wxString& fileName, bool isResource = false );
> bool Create(const wxString& fileName, bool isResource = false );
> bool IsOk() const;
> !%wxchkver_2_6 bool Play(bool async = true, bool looped = false) const;
> %wxchkver_2_6 bool Play(unsigned int flags = wxSOUND_ASYNC) const;

};
#endif // %msw && !%wxchkver_2_6 && wxUSE_WAVE
#endif //wxLUA_USE_wxWave

## wxwidgets/wxadv_grid.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxGrid and related classes (Updated using grid.h NOT docs );
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxGrid && wxUSE_GRID
#include "wx/grid.h"
#include "wx/generic/gridctrl.h"
#define WXGRID_DEFAULT_NUMBER_ROWS
#define WXGRID_DEFAULT_NUMBER_COLS
#define WXGRID_DEFAULT_ROW_HEIGHT
#define WXGRID_DEFAULT_COL_WIDTH
#define WXGRID_DEFAULT_COL_LABEL_HEIGHT
#define WXGRID_DEFAULT_ROW_LABEL_WIDTH
#define WXGRID_LABEL_EDGE_ZONE
#define WXGRID_MIN_ROW_HEIGHT
#define WXGRID_MIN_COL_WIDTH
#define WXGRID_DEFAULT_SCROLLBAR_WIDTH
#define_wxstring wxGRID_VALUE_STRING
#define_wxstring wxGRID_VALUE_BOOL
#define_wxstring wxGRID_VALUE_NUMBER
#define_wxstring wxGRID_VALUE_FLOAT
#define_wxstring wxGRID_VALUE_CHOICE
#define_wxstring wxGRID_VALUE_TEXT
#define_wxstring wxGRID_VALUE_LONG
#define_wxstring wxGRID_VALUE_CHOICEINT
#define_wxstring wxGRID_VALUE_DATETIME
%wxchkver_2_8_8 #define wxGRID_AUTOSIZE
// ---------------------------------------------------------------------------
// wxGridCellWorker
class %delete wxGridCellWorker : public wxClientDataContainer
{

> // wxGridCellWorker() - base class only
> void IncRef( );
> void DecRef( );
> virtual void SetParameters(const wxString& params );

};
// ---------------------------------------------------------------------------
// wxGridCellRenderer
class %delete wxGridCellRenderer : public wxGridCellWorker
{

> //wxGridCellRenderer() - no constructor abstract class
> //virtual void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected );
> virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, int row, int col );

};
// ---------------------------------------------------------------------------
// wxGridCellStringRenderer
class %delete wxGridCellStringRenderer : public wxGridCellRenderer
{

> wxGridCellStringRenderer( );

};
// ---------------------------------------------------------------------------
// wxGridCellNumberRenderer
class %delete wxGridCellNumberRenderer : public wxGridCellStringRenderer
{

> wxGridCellNumberRenderer( );

};
// ---------------------------------------------------------------------------
// wxGridCellFloatRenderer
class %delete wxGridCellFloatRenderer : public wxGridCellStringRenderer
{

> wxGridCellFloatRenderer(int width = -1, int precision = -1 );
> int GetWidth() const;
> void SetWidth(int width );
> int GetPrecision() const;
> void SetPrecision(int precision );

};
// ---------------------------------------------------------------------------
// wxGridCellBoolRenderer
class %delete wxGridCellBoolRenderer : public wxGridCellRenderer
{

> wxGridCellBoolRenderer( );

};
// ---------------------------------------------------------------------------
// wxGridCellDateTimeRenderer
class %delete wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
{

> wxGridCellDateTimeRenderer(const wxString& outformat = wxDefaultDateTimeFormat, const wxString& informat = wxDefaultDateTimeFormat );

};
// ---------------------------------------------------------------------------
// wxGridCellEnumRenderer
class %delete wxGridCellEnumRenderer : public wxGridCellStringRenderer
{

> wxGridCellEnumRenderer( const wxString& choices = "" );

};
// ---------------------------------------------------------------------------
// wxGridCellAutoWrapStringRenderer
class %delete wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
{

> wxGridCellAutoWrapStringRenderer( );

};
// ---------------------------------------------------------------------------
// wxGridCellEditor
class %delete wxGridCellEditor : public wxGridCellWorker
{

> // wxGridCellEditor() - no constructor abstract class
> bool IsCreated( );
> wxControl* GetControl( );
> // wxLua Note: The attr will delete the control when it is destroyed.
> void SetControl(%ungc wxControl* control );
> wxGridCellAttr* GetCellAttr( );
> // wxLua Note: the attr must exist for the life of this object since it doesn't take ownership nor call DecRef() on it.
> void SetCellAttr(wxGridCellAttr* attr );
> //virtual void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler );
> virtual void BeginEdit(int row, int col, wxGrid* grid );
> !%wxchkver_2_9_2 virtual bool EndEdit(int row, int col, wxGrid* grid );
> %wxchkver_2_9_2 virtual bool EndEdit(int row, int col, const wxGrid *grid, const wxString& oldval, wxString *newval );
> virtual void Reset( );
> //virtual wxGridCellEditor *Clone() const;
> virtual void SetSize(const wxRect& rect );
> virtual void Show(bool show, wxGridCellAttr *attr = NULL );
> !%wxchkver_2_9_5 virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr );
> //%wxchkver_2_9_5 virtual void PaintBackground(const wxRect& rectCell, const wxGridCellAttr &attr ); // it very briefly had this signature
> %wxchkver_2_9_5 virtual void PaintBackground(wxDC& dc, const wxRect& rectCell, const wxGridCellAttr &attr );
> virtual bool IsAcceptedKey(wxKeyEvent& event );
> virtual void StartingKey(wxKeyEvent& event );
> virtual void StartingClick( );
> virtual void HandleReturn(wxKeyEvent& event );
> virtual void Destroy( );

};
// ---------------------------------------------------------------------------
// wxGridCellTextEditor
class %delete wxGridCellTextEditor : public wxGridCellEditor
{

> wxGridCellTextEditor( );

};
// ---------------------------------------------------------------------------
// wxGridCellNumberEditor
class %delete wxGridCellNumberEditor : public wxGridCellTextEditor
{

> wxGridCellNumberEditor(int min = -1, int max = -1 );

};
// ---------------------------------------------------------------------------
// wxGridCellFloatEditor
class %delete wxGridCellFloatEditor : public wxGridCellTextEditor
{

> wxGridCellFloatEditor(int width = -1, int precision = -1 );

};
// ---------------------------------------------------------------------------
// wxGridCellBoolEditor
class %delete wxGridCellBoolEditor : public wxGridCellEditor
{

> wxGridCellBoolEditor( );

};
// ---------------------------------------------------------------------------
// wxGridCellChoiceEditor
class %delete wxGridCellChoiceEditor : public wxGridCellEditor
{

> wxGridCellChoiceEditor(const wxArrayString& choices, bool allowOthers = false );

};
// ---------------------------------------------------------------------------
// wxGridCellEnumEditor
class %delete wxGridCellEnumEditor : public wxGridCellChoiceEditor
{

> wxGridCellEnumEditor( const wxString& choices = "" );

};
// ---------------------------------------------------------------------------
// wxGridCellAutoWrapStringEditor
class %delete wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
{

> wxGridCellAutoWrapStringEditor( );

};
// ---------------------------------------------------------------------------
// wxGridCellAttr
enum wxGridCellAttr::wxAttrKind
{

> Any,
> Default,
> Cell,
> Row,
> Col,
> Merged

};
class %delete wxGridCellAttr : public wxClientDataContainer
{

> wxGridCellAttr( );
> wxGridCellAttr(const wxColour& colText, const wxColour& colBack, const wxFont& font, int hAlign, int vAlign );
> void MergeWith(wxGridCellAttr *mergefrom );
> void IncRef( );
> void DecRef( );
> void SetTextColour(const wxColour& colText );
> void SetBackgroundColour(const wxColour& colBack );
> void SetFont(const wxFont& font );
> void SetAlignment(int hAlign, int vAlign );
> void SetSize(int num_rows, int num_cols );
> void SetOverflow(bool allow = true );
> void SetReadOnly(bool isReadOnly = true );
> // wxLua calls IncRef() on the input renderer since the attr will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the renderer as you would in C++.
> void SetRenderer(%IncRef wxGridCellRenderer *renderer );
> // wxLua calls IncRef() on the input editor since the attr will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the editor as you would in C++.
> void SetEditor(%IncRef wxGridCellEditor* editor );
> void SetKind(wxGridCellAttr::wxAttrKind kind );
> bool HasTextColour() const;
> bool HasBackgroundColour() const;
> bool HasFont() const;
> bool HasAlignment() const;
> bool HasRenderer() const;
> bool HasEditor() const;
> bool HasReadWriteMode() const;
> bool HasOverflowMode() const;
> bool HasSize() const;
> wxColour GetTextColour() const;
> wxColour GetBackgroundColour() const;
> wxFont GetFont() const;
> // %override [int horiz, int vert] wxGridCellAttr::GetAlignment() const;
> // C++ Func: void GetAlignment(int *horz, int *vert) const;
> void GetAlignment() const;
> // %override [int num_rows, int num_cols] wxGridCellAttr::GetSize() const;
> // C++ Func: void GetSize(int *num_rows, int *num_cols) const;
> void GetSize() const;
> bool GetOverflow() const;
> // wxLua Note: The attr calls IncRef() on the returned renderer so wxLua will garbage collect it.
> %gc wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
> // wxLua Note: The attr calls IncRef() on the returned editor so wxLua will garbage collect it.
> %gc wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
> bool IsReadOnly() const;
> wxGridCellAttr::wxAttrKind GetKind( );
> // wxLua Note: the attr must exist for the life of this object and it doesn't take ownership
> void SetDefAttr(wxGridCellAttr* defAttr );

};
// ---------------------------------------------------------------------------
// wxGridCellAttrProvider
class %delete wxGridCellAttrProvider : public wxClientDataContainer
{

> wxGridCellAttrProvider( );
> // wxLua Note: The attrprovider calls IncRef() on the returned attribute so wxLua will garbage collect it.
> %gc wxGridCellAttr *GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind) const;
> // wxLua calls IncRef() on the input attr since the attrprovider will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetAttr(%IncRef wxGridCellAttr *attr, int row, int col );
> // wxLua calls IncRef() on the input attr since the attrprovider will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetRowAttr(%IncRef wxGridCellAttr *attr, int row );
> // wxLua calls IncRef() on the input attr since the attrprovider will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetColAttr(%IncRef wxGridCellAttr *attr, int col );
> void UpdateAttrRows( size_t pos, int numRows );
> void UpdateAttrCols( size_t pos, int numCols );

};
// ---------------------------------------------------------------------------
// wxGridTableBase
class wxGridTableBase : public wxObject //, public wxClientDataContainer
{

> // no constructor pure virtual base class
> virtual int GetNumberRows( );
> virtual int GetNumberCols( );
> virtual bool IsEmptyCell( int row, int col );
> virtual wxString GetValue( int row, int col );
> virtual void SetValue( int row, int col, const wxString& value );
> virtual wxString GetTypeName( int row, int col );
> virtual bool CanGetValueAs( int row, int col, const wxString& typeName );
> virtual bool CanSetValueAs( int row, int col, const wxString& typeName );
> virtual bool GetValueAsBool( int row, int col );
> virtual long GetValueAsLong( int row, int col );
> virtual double GetValueAsDouble( int row, int col );
> virtual void SetValueAsBool( int row, int col, bool value );
> virtual void SetValueAsLong( int row, int col, long value );
> virtual void SetValueAsDouble( int row, int col, double value );
> //virtual void* GetValueAsCustom( int row, int col, const wxString& typeName );
> //virtual void SetValueAsCustom( int row, int col, const wxString& typeName, void* value );
> virtual void SetView( wxGrid *grid );
> virtual wxGrid * GetView() const;
> virtual void Clear( );
> virtual bool InsertRows( size_t pos = 0, size_t numRows = 1 );
> virtual bool AppendRows( size_t numRows = 1 );
> virtual bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
> virtual bool InsertCols( size_t pos = 0, size_t numCols = 1 );
> virtual bool AppendCols( size_t numCols = 1 );
> virtual bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
> virtual wxString GetRowLabelValue( int row );
> virtual wxString GetColLabelValue( int col );
> virtual void SetRowLabelValue( int row, const wxString& value );
> virtual void SetColLabelValue( int col, const wxString& value );
> void SetAttrProvider(wxGridCellAttrProvider *attrProvider );
> wxGridCellAttrProvider *GetAttrProvider() const;
> virtual bool CanHaveAttributes( );
> // wxLua Note: The table calls IncRef() on the returned attribute so wxLua will garbage collect it.
> virtual %gc wxGridCellAttr* GetAttr( int row, int col, wxGridCellAttr::wxAttrKind kind );
> // wxLua calls IncRef() on the input attr since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetAttr(%IncRef wxGridCellAttr* attr, int row, int col );
> // wxLua calls IncRef() on the input attr since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetRowAttr(%IncRef wxGridCellAttr *attr, int row );
> // wxLua calls IncRef() on the input attr since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetColAttr(%IncRef wxGridCellAttr *attr, int col );

};
// ---------------------------------------------------------------------------
// wxLuaGridTableBase
#include "wxbind/include/wxadv_wxladv.h"
class %delete wxLuaGridTableBase : public wxGridTableBase
{

> // %override - the C++ function takes the wxLuaState as the first param
> wxLuaGridTableBase( );
> // The functions below are all virtual functions that you override in Lua.
> // You must override these functions in a derived table class
> //
> //virtual int GetNumberRows();
> //virtual int GetNumberCols();
> //virtual bool IsEmptyCell( int row, int col );
> //virtual wxString GetValue( int row, int col );
> //virtual void SetValue( int row, int col, const wxString& value );
> //
> // Data type determination and value access
> //virtual wxString GetTypeName( int row, int col );
> //virtual bool CanGetValueAs( int row, int col, const wxString& typeName );
> //virtual bool CanSetValueAs( int row, int col, const wxString& typeName );
> //
> //virtual long GetValueAsLong( int row, int col );
> //virtual double GetValueAsDouble( int row, int col );
> //virtual bool GetValueAsBool( int row, int col );
> //
> //virtual void SetValueAsLong( int row, int col, long value );
> //virtual void SetValueAsDouble( int row, int col, double value );
> //virtual void SetValueAsBool( int row, int col, bool value );
> //
> // For user defined types - Custom values probably don't make too much sense for wxLua
> // wxLua NOT overridable - virtual void* GetValueAsCustom( int row, int col, const wxString& typeName );
> // wxLua NOT overridable - virtual void SetValueAsCustom( int row, int col, const wxString& typeName, void* value );
> //
> // Overriding these is optional
> //
> // wxLua NOT overridable - virtual void SetView( wxGrid *grid ) { m_view = grid; }
> // wxLua NOT overridable - virtual wxGrid * GetView() const { return m_view; }
> //
> //virtual void Clear() {}
> //virtual bool InsertRows( size_t pos = 0, size_t numRows = 1 );
> //virtual bool AppendRows( size_t numRows = 1 );
> //virtual bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
> //virtual bool InsertCols( size_t pos = 0, size_t numCols = 1 );
> //virtual bool AppendCols( size_t numCols = 1 );
> //virtual bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
> //
> //virtual wxString GetRowLabelValue( int row );
> //virtual wxString GetColLabelValue( int col );
> //virtual void SetRowLabelValue( int WXUNUSED(row), const wxString& ) {}
> //virtual void SetColLabelValue( int WXUNUSED(col), const wxString& ) {}
> //
> // Attribute handling
> //
> // give us the attr provider to use - we take ownership of the pointer
> // wxLua NOT overridable - void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
> //
> // get the currently used attr provider (may be NULL );
> // wxLua NOT overridable - wxGridCellAttrProvider *GetAttrProvider() const { return m_attrProvider; }
> //
> // Does this table allow attributes? Default implementation creates
> // a wxGridCellAttrProvider if necessary.
> //virtual bool CanHaveAttributes();
> //
> // by default forwarded to wxGridCellAttrProvider if any. May be
> // overridden to handle attributes directly in the table.
> //virtual wxGridCellAttr *GetAttr( int row, int col,
> // wxGridCellAttr::wxAttrKind kind );
> //
> // In wxLua it would be much easier to simply store the attributes in your own Lua table and return them in GetAttr( );
> // wxLua NOT overridable - virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
> // wxLua NOT overridable - virtual void SetRowAttr(wxGridCellAttr *attr, int row);
> // wxLua NOT overridable - virtual void SetColAttr(wxGridCellAttr *attr, int col);

};
// ---------------------------------------------------------------------------
// wxGridStringTable
class %delete wxGridStringTable : public wxGridTableBase
{

> wxGridStringTable( int numRows=0, int numCols=0 );

};
// ---------------------------------------------------------------------------
// wxGridTableMessage
enum wxGridTableRequest
{

> wxGRIDTABLE_REQUEST_VIEW_GET_VALUES,
> wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES,
> wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
> wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
> wxGRIDTABLE_NOTIFY_ROWS_DELETED,
> wxGRIDTABLE_NOTIFY_COLS_INSERTED,
> wxGRIDTABLE_NOTIFY_COLS_APPENDED,
> wxGRIDTABLE_NOTIFY_COLS_DELETED

};
class %delete wxGridTableMessage
{

> wxGridTableMessage( wxGridTableBase *table, int id, int comInt1 = -1, int comInt2 = -1 );
> void SetTableObject( wxGridTableBase *table );
> wxGridTableBase * GetTableObject() const;
> void SetId( int id );
> int GetId( );
> void SetCommandInt( int comInt1 );
> int GetCommandInt( );
> void SetCommandInt2( int comInt2 );
> int GetCommandInt2( );

};
// ---------------------------------------------------------------------------
// wxGridCellCoords
class %delete wxGridCellCoords
{

> #define_object wxGridNoCellCoords
> wxGridCellCoords( int r = -1, int c = -1 );
> int GetRow() const;
> void SetRow( int n );
> int GetCol() const;
> void SetCol( int n );
> void Set(int row, int col );
> wxGridCellCoords& operator=( const wxGridCellCoords& other );
> bool operator==( const wxGridCellCoords& other ) const;
> bool operator!() const;

};
// ---------------------------------------------------------------------------
// wxGridCellCoordsArray
#include "wx/dynarray.h"
class %delete wxGridCellCoordsArray
{

> wxGridCellCoordsArray( );
> wxGridCellCoordsArray(const wxGridCellCoordsArray& array );
> void Add( const wxGridCellCoords& c );
> void Alloc(size_t count );
> void Clear( );
> int GetCount() const;
> bool IsEmpty() const;
> void Insert( const wxGridCellCoords& c, int n, int copies = 1 );
> wxGridCellCoords Item( int n );
> void RemoveAt(size_t index );
> void Shrink( );
> wxGridCellCoords operator[](size_t nIndex );

};
// ---------------------------------------------------------------------------
// wxGrid
enum wxGrid::wxGridSelectionModes
{

> wxGridSelectCells,
> wxGridSelectRows,
> wxGridSelectColumns

};
class wxGrid : public wxScrolledWindow
{

> wxGrid( wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxWANTS_CHARS, const wxString &name = "wxGrid" );
> bool CreateGrid( int numRows, int numCols, wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells );
> void SetSelectionMode(wxGrid::wxGridSelectionModes selmode );
> wxGrid::wxGridSelectionModes GetSelectionMode() const;
> int GetNumberRows( );
> int GetNumberCols( );
> //wxArrayInt CalcRowLabelsExposed( const wxRegion& reg );
> //wxArrayInt CalcColLabelsExposed( const wxRegion& reg );
> //wxGridCellCoordsArray CalcCellsExposed( const wxRegion& reg );
> //void ProcessRowLabelMouseEvent( wxMouseEvent& event );
> //void ProcessColLabelMouseEvent( wxMouseEvent& event );
> //void ProcessCornerLabelMouseEvent( wxMouseEvent& event );
> //void ProcessGridCellMouseEvent( wxMouseEvent& event );
> bool ProcessTableMessage( wxGridTableMessage& msg );
> //void DoEndDragResizeRow();
> //void DoEndDragResizeCol();
> wxGridTableBase * GetTable() const;
> // %override so that takeOwnership releases the table from garbage collection by Lua
> bool SetTable( wxGridTableBase * table, bool takeOwnership = false, wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells );
> void ClearGrid( );
> bool InsertRows( int pos = 0, int numRows = 1, bool updateLabels=true );
> bool AppendRows( int numRows = 1, bool updateLabels=true );
> bool DeleteRows( int pos = 0, int numRows = 1, bool updateLabels=true );
> bool InsertCols( int pos = 0, int numCols = 1, bool updateLabels=true );
> bool AppendCols( int numCols = 1, bool updateLabels=true );
> bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels=true );
> //void DrawGridCellArea( wxDC& dc , const wxGridCellCoordsArray& cells );
> //void DrawGridSpace( wxDC& dc );
> //void DrawCellBorder( wxDC& dc, const wxGridCellCoords& );
> //void DrawAllGridLines( wxDC& dc, const wxRegion& reg );
> //void DrawCell( wxDC& dc, const wxGridCellCoords& );
> //void DrawHighlight(wxDC& dc, const wxGridCellCoordsArray& cells);
> //virtual void DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr );
> //virtual void DrawRowLabels( wxDC& dc, const wxArrayInt& rows );
> //virtual void DrawRowLabel( wxDC& dc, int row );
> //virtual void DrawColLabels( wxDC& dc, const wxArrayInt& cols );
> //virtual void DrawColLabel( wxDC& dc, int col );
> void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&, int horizontalAlignment = wxALIGN_LEFT, int verticalAlignment = wxALIGN_TOP, int textOrientation = wxHORIZONTAL );
> //void DrawTextRectangle( wxDC& dc, const wxArrayString& lines, const wxRect&, int horizontalAlignment = wxALIGN_LEFT, int verticalAlignment = wxALIGN_TOP, int textOrientation = wxHORIZONTAL );
> void StringToLines( const wxString& value, wxArrayString& lines );
> // %override [long width, long height] wxGrid::GetTextBoxSize(wxDC& dc, const wxArrayString& lines );
> // C++ Func: void GetTextBoxSize( wxDC& dc, const wxArrayString& lines, long *width, long *height );
> void GetTextBoxSize( wxDC& dc, const wxArrayString& lines );
> void BeginBatch( );
> void EndBatch( );
> int GetBatchCount( );
> void ForceRefresh( );
> bool IsEditable( );
> void EnableEditing( bool edit );
> void EnableCellEditControl( bool enable = true );
> void DisableCellEditControl( );
> bool CanEnableCellControl() const;
> bool IsCellEditControlEnabled() const;
> bool IsCellEditControlShown() const;
> bool IsCurrentCellReadOnly() const;
> void ShowCellEditControl( );
> void HideCellEditControl( );
> void SaveEditControlValue( );
> void XYToCell( int x, int y, wxGridCellCoords& coords );
> int XToCol( int x );
> int YToRow( int y );
> int XToEdgeOfCol( int x );
> int YToEdgeOfRow( int y );
> wxRect CellToRect( int row, int col );
> //wxRect CellToRect( const wxGridCellCoords& coords );
> int GetGridCursorRow( );
> int GetGridCursorCol( );
> bool IsVisible( int row, int col, bool wholeCellVisible = true );
> //bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = true );
> void MakeCellVisible( int row, int col );
> //void MakeCellVisible( const wxGridCellCoords& coords );
> void SetGridCursor( int row, int col );
> bool MoveCursorUp( bool expandSelection );
> bool MoveCursorDown( bool expandSelection );
> bool MoveCursorLeft( bool expandSelection );
> bool MoveCursorRight( bool expandSelection );
> bool MovePageDown( );
> bool MovePageUp( );
> bool MoveCursorUpBlock( bool expandSelection );
> bool MoveCursorDownBlock( bool expandSelection );
> bool MoveCursorLeftBlock( bool expandSelection );
> bool MoveCursorRightBlock( bool expandSelection );
> int GetDefaultRowLabelSize( );
> int GetRowLabelSize( );
> int GetDefaultColLabelSize( );
> int GetColLabelSize( );
> wxColour GetLabelBackgroundColour( );
> wxColour GetLabelTextColour( );
> wxFont GetLabelFont( );
> // %override [int horiz, int vert] wxGrid::GetRowLabelAlignment( );
> // C++ Func: void GetRowLabelAlignment( int *horiz, int *vert );
> void GetRowLabelAlignment( int *horz, int *vert );
> // %override [int horiz, int vert] wxGrid::GetColLabelAlignment( );
> // C++ Func: void GetColLabelAlignment( int *horiz, int *vert );
> void GetColLabelAlignment( int *horz, int *vert );
> int GetColLabelTextOrientation( );
> wxString GetRowLabelValue( int row );
> wxString GetColLabelValue( int col );
> wxColour GetGridLineColour( );
> wxColour GetCellHighlightColour( );
> int GetCellHighlightPenWidth( );
> int GetCellHighlightROPenWidth( );
> void SetRowLabelSize( int width );
> void SetColLabelSize( int height );
> void SetLabelBackgroundColour( const wxColour& backColour );
> void SetLabelTextColour( const wxColour& textColour );
> void SetLabelFont( const wxFont& labelFont );
> void SetRowLabelAlignment( int horiz, int vert );
> void SetColLabelAlignment( int horiz, int vert );
> void SetRowLabelValue( int row, const wxString& value );
> void SetColLabelValue( int col, const wxString& value );
> void SetGridLineColour( const wxColour& lineColour );
> void SetCellHighlightColour( const wxColour& highlightColour );
> void SetCellHighlightPenWidth(int width );
> void SetCellHighlightROPenWidth(int width );
> void EnableDragRowSize( bool enable = true );
> void DisableDragRowSize( );
> #if !%wxchkver_3_0 || %wxcompat_2_8
> bool CanDragColSize( );
> bool CanDragRowSize( );
> #endif
> #if %wxchkver_3_0
> bool CanDragColSize( int col );
> bool CanDragRowSize( int row );
> #endif
> void EnableDragColSize( bool enable = true );
> void DisableDragColSize( );
> void EnableDragGridSize(bool enable = true );
> void DisableDragGridSize( );
> bool CanDragGridSize( );
> void EnableDragCell( bool enable = true );
> void DisableDragCell( );
> bool CanDragCell( );
> // wxLua calls IncRef() on the input attr since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetAttr(int row, int col, %IncRef wxGridCellAttr *attr );
> // wxLua calls IncRef() on the input attr since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetRowAttr(int row, %IncRef wxGridCellAttr *attr );
> // wxLua calls IncRef() on the input attr since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetColAttr(int col, %IncRef wxGridCellAttr *attr );
> // wxLua Note: The grid calls IncRef() on the returned attribute so wxLua will garbage collect it.
> %gc wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
> void SetColFormatBool(int col );
> void SetColFormatNumber(int col );
> void SetColFormatFloat(int col, int width = -1, int precision = -1 );
> void SetColFormatCustom(int col, const wxString& typeName );
> void EnableGridLines( bool enable = true );
> bool GridLinesEnabled( );
> int GetDefaultRowSize( );
> int GetRowSize( int row );
> int GetDefaultColSize( );
> int GetColSize( int col );
> wxColour GetDefaultCellBackgroundColour( );
> wxColour GetCellBackgroundColour( int row, int col );
> wxColour GetDefaultCellTextColour( );
> wxColour GetCellTextColour( int row, int col );
> wxFont GetDefaultCellFont( );
> wxFont GetCellFont( int row, int col );
> // %override [int horiz, int vert] wxGrid::GetDefaultCellAlignment( );
> // C++ Func: void GetDefaultCellAlignment( int *horiz, int *vert );
> void GetDefaultCellAlignment( int *horiz, int *vert );
> // %override [int horiz, int vert] wxGrid::GetCellAlignment( int row, int col );
> // C++ Func: void GetCellAlignment( int row, int col, int *horiz, int *vert );
> void GetCellAlignment( int row, int col );
> bool GetDefaultCellOverflow( );
> bool GetCellOverflow( int row, int col );
> // %override [int num_rows, int num_cols] wxGrid::GetCellSize( int row, int col );
> // C++ Func: void GetCellSize( int row, int col, int *num_rows, int *num_cols );
> void GetCellSize( int row, int col );
> void SetDefaultRowSize( int height, bool resizeExistingRows = false );
> void SetRowSize( int row, int height );
> void SetDefaultColSize( int width, bool resizeExistingCols = false );
> void SetColSize( int col, int width );
> void AutoSize( );
> void AutoSizeRow( int row, bool setAsMin = true );
> void AutoSizeColumn( int col, bool setAsMin = true );
> void AutoSizeRows( bool setAsMin = true );
> void AutoSizeColumns( bool setAsMin = true );
> void AutoSizeRowLabelSize( int row );
> void AutoSizeColLabelSize( int col );
> void SetColMinimalWidth( int col, int width );
> void SetRowMinimalHeight( int row, int width );
> void SetColMinimalAcceptableWidth( int width );
> void SetRowMinimalAcceptableHeight( int width );
> int GetColMinimalAcceptableWidth() const;
> int GetRowMinimalAcceptableHeight() const;
> void SetDefaultCellBackgroundColour( const wxColour& backColour );
> void SetCellBackgroundColour( int row, int col, const wxColour& backColour );
> void SetDefaultCellTextColour( const wxColour& textColour );
> void SetCellTextColour( int row, int col, const wxColour& textColour );
> void SetDefaultCellFont( const wxFont& cellFont );
> void SetCellFont( int row, int col, const wxFont& cellFont );
> void SetDefaultCellAlignment( int horiz, int vert );
> void SetCellAlignment( int row, int col, int horiz, int vert );
> void SetDefaultCellOverflow( bool allow );
> void SetCellOverflow( int row, int col, bool allow );
> void SetCellSize( int row, int col, int num_rows, int num_cols );
> // wxLua calls IncRef() on the input renderer since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetDefaultRenderer(%IncRef wxGridCellRenderer *renderer );
> // wxLua calls IncRef() on the input renderer since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetCellRenderer(int row, int col, %IncRef wxGridCellRenderer *renderer );
> // wxLua Note: The grid calls IncRef() on the returned renderer so wxLua will garbage collect it.
> %gc wxGridCellRenderer* GetDefaultRenderer() const;
> // wxLua Note: The grid calls IncRef() on the returned renderer so wxLua will garbage collect it.
> %gc wxGridCellRenderer* GetCellRenderer(int row, int col );
> // wxLua calls IncRef() on the input editor since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetDefaultEditor(%IncRef wxGridCellEditor *editor );
> // wxLua calls IncRef() on the input editor since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void SetCellEditor(int row, int col, %IncRef wxGridCellEditor *editor );
> // wxLua Note: The grid calls IncRef() on the returned editor so wxLua will garbage collect it.
> %gc wxGridCellEditor* GetDefaultEditor() const;
> // wxLua Note: The grid calls IncRef() on the returned editor so wxLua will garbage collect it.
> %gc wxGridCellEditor* GetCellEditor(int row, int col );
> wxString GetCellValue( int row, int col );
> // wxString GetCellValue( const wxGridCellCoords& coords );
> void SetCellValue( int row, int col, const wxString& s );
> // void SetCellValue( const wxGridCellCoords& coords, const wxString& s );
> bool IsReadOnly(int row, int col) const;
> void SetReadOnly(int row, int col, bool isReadOnly = true );
> void SelectRow( int row, bool addToSelected = false );
> void SelectCol( int col, bool addToSelected = false );
> void SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol, bool addToSelected = false );
> // void SelectBlock( const wxGridCellCoords& topLeft, const wxGridCellCoords& bottomRight );
> void SelectAll( );
> bool IsSelection( );
> void DeselectRow( int row );
> void DeselectCol( int col );
> void DeselectCell( int row, int col );
> void ClearSelection( );
> bool IsInSelection( int row, int col );
> // bool IsInSelection( const wxGridCellCoords& coords );
> wxGridCellCoordsArray GetSelectedCells() const;
> wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
> wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
> wxArrayInt GetSelectedRows() const;
> wxArrayInt GetSelectedCols() const;
> wxRect BlockToDeviceRect( const wxGridCellCoords& topLeft, const wxGridCellCoords& bottomRight );
> wxColour GetSelectionBackground() const;
> wxColour GetSelectionForeground() const;
> void SetSelectionBackground(const wxColour& c );
> void SetSelectionForeground(const wxColour& c );
> // wxLua calls IncRef() on the input renderer and editor since the table will call DecRef() on it.
> // You should not have to worry about Inc/DecRef() of the attr as you would in C++.
> void RegisterDataType(const wxString& typeName, %IncRef wxGridCellRenderer* renderer, %IncRef wxGridCellEditor* editor );
> // wxLua Note: The grid calls IncRef() on the returned editor so wxLua will garbage collect it.
> %gc wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
> //wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& coords) const;
> // wxLua Note: The grid calls IncRef() on the returned renderer so wxLua will garbage collect it.
> %gc wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
> // wxLua Note: The grid calls IncRef() on the returned editor so wxLua will garbage collect it.
> %gc wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
> // wxLua Note: The grid calls IncRef() on the returned renderer so wxLua will garbage collect it.
> %gc wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
> void SetMargins(int extraWidth, int extraHeight );
> wxWindow* GetGridWindow( );
> wxWindow* GetGridRowLabelWindow( );
> wxWindow* GetGridColLabelWindow( );
> wxWindow* GetGridCornerLabelWindow( );
> //void SetScrollLineX(int x );
> //void SetScrollLineY(int y );
> //int GetScrollLineX() const;
> //int GetScrollLineY() const;
> //int GetScrollX(int x) const;
> //int GetScrollY(int y) const;

};
// ---------------------------------------------------------------------------
// wxGridEvent
class %delete wxGridEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_GRID_CELL_LEFT_CLICK // EVT_GRID_CELL_LEFT_CLICK(fn); // FIXME! wxEVT_CMD_GRID_XXX in > 2.6
> %wxEventType wxEVT_GRID_CELL_RIGHT_CLICK // EVT_GRID_CELL_RIGHT_CLICK(fn );
> %wxEventType wxEVT_GRID_CELL_LEFT_DCLICK // EVT_GRID_CELL_LEFT_DCLICK(fn );
> %wxEventType wxEVT_GRID_CELL_RIGHT_DCLICK // EVT_GRID_CELL_RIGHT_DCLICK(fn );
> %wxEventType wxEVT_GRID_LABEL_LEFT_CLICK // EVT_GRID_LABEL_LEFT_CLICK(fn );
> %wxEventType wxEVT_GRID_LABEL_RIGHT_CLICK // EVT_GRID_LABEL_RIGHT_CLICK(fn );
> %wxEventType wxEVT_GRID_LABEL_LEFT_DCLICK // EVT_GRID_LABEL_LEFT_DCLICK(fn );
> %wxEventType wxEVT_GRID_LABEL_RIGHT_DCLICK // EVT_GRID_LABEL_RIGHT_DCLICK(fn );
> %wxEventType wxEVT_GRID_SELECT_CELL // EVT_GRID_SELECT_CELL(fn );
> %wxEventType wxEVT_GRID_EDITOR_SHOWN // EVT_GRID_EDITOR_SHOWN(fn );
> %wxEventType wxEVT_GRID_EDITOR_HIDDEN // EVT_GRID_EDITOR_HIDDEN(fn );
> %wxEventType wxEVT_GRID_CELL_BEGIN_DRAG // EVT_GRID_CELL_BEGIN_DRAG(fn );
> #if !%wxchkver_3_0 || %wxcompat_2_8
> %wxEventType wxEVT_GRID_CELL_CHANGE // EVT_GRID_CELL_CHANGE(fn );
> #endif
> #if %wxchkver_3_0
> %wxEventType wxEVT_GRID_CELL_CHANGING // EVT_GRID_CELL_CHANGE(fn );
> %wxEventType wxEVT_GRID_CELL_CHANGED // EVT_GRID_CELL_CHANGE(fn );
> #endif
> !%wxchkver_2_9_0 wxGridEvent(int id, wxEventType type, wxObject* obj, int row = -1, int col = -1, int x = -1, int y = -1, bool sel = true, bool control = false, bool shift = false, bool alt = false, bool meta = false );
> virtual int GetRow( );
> virtual int GetCol( );
> wxPoint GetPosition( );
> bool Selecting( );
> bool ControlDown( );
> bool MetaDown( );
> bool ShiftDown( );
> bool AltDown( );

};
// ---------------------------------------------------------------------------
// wxGridSizeEvent
class %delete wxGridSizeEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_GRID_ROW_SIZE // EVT_GRID_CMD_ROW_SIZE(id, fn );
> %wxEventType wxEVT_GRID_COL_SIZE // EVT_GRID_CMD_COL_SIZE(id, fn );
> !%wxchkver_2_9_0 wxGridSizeEvent(int id, wxEventType type, wxObject* obj, int rowOrCol = -1, int x = -1, int y = -1, bool control = false, bool shift = false, bool alt = false, bool meta = false );
> int GetRowOrCol( );
> wxPoint GetPosition( );
> bool ShiftDown( );
> bool ControlDown( );
> bool AltDown( );
> bool MetaDown( );

};
// ---------------------------------------------------------------------------
// wxGridRangeSelectEvent
class %delete wxGridRangeSelectEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_GRID_RANGE_SELECT // EVT_GRID_CMD_RANGE_SELECT(id, fn );
> !%wxchkver_2_9_0 wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj, const wxGridCellCoords& topLeft, const wxGridCellCoords& bottomRight, bool sel = true, bool control = false, bool shift = false, bool alt = false, bool meta = false );
> wxGridCellCoords GetTopLeftCoords( );
> wxGridCellCoords GetBottomRightCoords( );
> int GetTopRow( );
> int GetBottomRow( );
> int GetLeftCol( );
> int GetRightCol( );
> bool Selecting( );
> bool ControlDown( );
> bool ShiftDown( );
> bool MetaDown( );
> bool AltDown( );

};
// ---------------------------------------------------------------------------
// wxGridEditorCreatedEvent
class %delete wxGridEditorCreatedEvent : public wxCommandEvent
{

> %wxEventType wxEVT_GRID_EDITOR_CREATED // EVT_GRID_EDITOR_CREATED(fn );
> wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj, int row, int col, wxControl* ctrl );
> int GetRow( );
> int GetCol( );
> wxControl* GetControl( );
> void SetRow(int row );
> void SetCol(int col );
> void SetControl(wxControl * ctrl );

};
#endif //wxLUA_USE_wxGrid && wxUSE_GRID

## wxwidgets/wxnet_net.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxNet library
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxSocket && wxUSE_SOCKETS
// ---------------------------------------------------------------------------
// wxSocketBase
#include "wx/socket.h"
enum wxSocketError
{

> wxSOCKET_NOERROR,
> wxSOCKET_INVOP,
> wxSOCKET_IOERR,
> wxSOCKET_INVADDR,
> wxSOCKET_INVSOCK,
> wxSOCKET_NOHOST,
> wxSOCKET_INVPORT,
> wxSOCKET_WOULDBLOCK,
> wxSOCKET_TIMEDOUT,
> wxSOCKET_MEMERR

};
enum wxSocketFlags // actually typedef int wxSocketFlags
{

> wxSOCKET_NONE,
> wxSOCKET_NOWAIT,
> wxSOCKET_WAITALL,
> wxSOCKET_BLOCK,
> wxSOCKET_REUSEADDR

};
enum wxSocketNotify
{

> wxSOCKET_INPUT,
> wxSOCKET_OUTPUT,
> wxSOCKET_CONNECTION,
> wxSOCKET_LOST

};
enum wxSocketEventFlags
{

> wxSOCKET_INPUT_FLAG,
> wxSOCKET_OUTPUT_FLAG,
> wxSOCKET_CONNECTION_FLAG,
> wxSOCKET_LOST_FLAG

};
enum wxSocketType
{

> wxSOCKET_UNINIT,
> wxSOCKET_CLIENT,
> wxSOCKET_SERVER,
> wxSOCKET_BASE,
> wxSOCKET_DATAGRAM

};
class wxSocketBase : public wxObject
{

> // wxSocketBase() - No constructor, base class
> void Close( );
> bool Destroy( );
> void Discard( );
> bool Error() const;
> voidptr_long GetClientData() const; // C++ returns (void *) You get a number here
> bool GetLocal(wxSockAddress& addr) const;
> wxSocketFlags GetFlags() const;
> bool GetPeer(wxSockAddress& addr) const;
> void InterruptWait( );
> bool IsConnected() const;
> bool IsData() const;
> bool IsDisconnected() const;
> unsigned long LastCount() const;
> wxSocketError LastError() const; // %gtk|%mac causes link error with Borland C++ w/DLL not exported?
> void Notify(bool notify );
> bool Ok() const;
> void RestoreState( );
> void SaveState( );
> void SetClientData(voidptr_long number); // C++ is (void *clientData) You can put a number here
> void SetEventHandler(wxEvtHandler& handler, int id = -1 );
> void SetFlags(wxSocketFlags flags );
> void SetNotify(wxSocketEventFlags flags );
> void SetTimeout(int seconds );
> // %override [Lua string] wxSocketBase::Peek(unsigned long nbytes );
> // C++ Func: void Peek(void * buffer, unsigned long nbytes );
> void Peek(unsigned long nbytes );
> // %override [Lua string] wxSocketBase::Read(unsigned long nbytes );
> // C++ Func: void Read(unsigned long nbytes );
> void Read(void * buffer, unsigned long nbytes );
> // %override [Lua string] wxSocketBase::ReadMsg(unsigned long nbytes );
> // C++ Func: void ReadMsg(void * buffer, unsigned long nbytes );
> void ReadMsg(unsigned long nbytes );
> // %override void wxSocketBase::Unread(Lua string, [optional unsigned long nbytes] );
> // C++ Func: void Unread(const void * buffer, unsigned long nbytes );
> void Unread(const char* buffer, unsigned long nbytes );
> bool Wait(long seconds = -1, long millisecond = 0 );
> bool WaitForLost(long seconds = -1, long millisecond = 0 );
> bool WaitForRead(long seconds = -1, long millisecond = 0 );
> bool WaitForWrite(long seconds = -1, long millisecond = 0 );
> // %override void wxSocketBase::Write(Lua string, [optional unsigned long nbytes] );
> // C++ Func: void Write(const void * buffer, unsigned long nbytes );
> void Write(const char* buffer, unsigned long nbytes );
> // %override void wxSocketBase::WriteMsg(Lua string, [optional unsigned long nbytes] );
> // C++ Func: void WriteMsg(const void * buffer, wxUint32 nbytes );
> void WriteMsg(const char* buffer, wxUint32 nbytes );

};
// ---------------------------------------------------------------------------
// wxSocketClient
class %delete wxSocketClient : public wxSocketBase
{

> wxSocketClient(wxSocketFlags flags = wxSOCKET_NONE );
> bool Connect(wxSockAddress& address, bool wait = true );
> bool WaitOnConnect(long seconds = -1, long milliseconds = 0 );

};
// ---------------------------------------------------------------------------
// wxSocketServer
class %delete wxSocketServer : public wxSocketBase
{

> wxSocketServer(wxSockAddress& address, wxSocketFlags flags = wxSOCKET_NONE );
> wxSocketBase* Accept(bool wait = true );
> bool AcceptWith(wxSocketBase& socket, bool wait = true );
> bool WaitForAccept(long seconds = -1, long millisecond = 0 );

};
// ---------------------------------------------------------------------------
// wxSocketEvent
class %delete wxSocketEvent : public wxEvent
{

> %wxEventType wxEVT_SOCKET // EVT_SOCKET(id, func );
> wxSocketEvent(int id = 0 );
> voidptr_long GetClientData(); // C++ returns (void *) You get a number here
> wxSocketBase * GetSocket() const;
> wxSocketNotify GetSocketEvent() const;

};
// ---------------------------------------------------------------------------
// wxSockAddress
class wxSockAddress : public wxObject
{

> // wxSockAddress() virtual base class
> void Clear( );
> //int SockAddrLen(); // Does not exist

};
// ---------------------------------------------------------------------------
// wxIPAddress
class %delete wxIPaddress : public wxSockAddress
{

> //wxIPaddress() virtual base class
> bool Hostname(const wxString& hostname );
> //bool Hostname(unsigned long addr); // pure virtual, fun in derived classes
> wxString Hostname( );
> wxString IPAddress( );
> bool Service(const wxString& service );
> bool Service(unsigned short service );
> unsigned short Service( );
> bool AnyAddress( );
> bool LocalHost( );
> virtual bool IsLocalHost( );

};
// ---------------------------------------------------------------------------
// wxIPV4address
class %delete wxIPV4address : public wxIPaddress
{

> wxIPV4address( );
> wxIPV4address(const wxIPV4address& other);
> //bool Hostname(const wxString& hostname );
> bool Hostname(unsigned long addr );
> //wxString Hostname( );
> //wxString IPAddress( );
> //bool Service(const wxString& service );
> //bool Service(unsigned short service );
> //unsigned short Service( );
> //bool AnyAddress( );
> //bool LocalHost( );

};
// ---------------------------------------------------------------------------
// wxProtocol
#if wxUSE_PROTOCOL
#include "wx/protocol/protocol.h"
enum wxProtocolError
{

> wxPROTO_NOERR,
> wxPROTO_NETERR,
> wxPROTO_PROTERR,
> wxPROTO_CONNERR,
> wxPROTO_INVVAL,
> wxPROTO_NOHNDLR,
> wxPROTO_NOFILE,
> wxPROTO_ABRT,
> wxPROTO_RCNCT,
> wxPROTO_STREAMING

};
class %delete wxProtocol : public wxSocketClient
{

> //wxProtocol() virtual base class
> bool Reconnect( );
> wxInputStream *GetInputStream(const wxString& path );
> bool Abort( );
> wxProtocolError GetError( );
> wxString GetContentType( );
> void SetUser(const wxString& user );
> void SetPassword(const wxString& user );

};
#endif //wxUSE_PROTOCOL
// ---------------------------------------------------------------------------
// wxHTTP
#if wxUSE_PROTOCOL_HTTP
#include "wx/protocol/http.h"
class %delete wxHTTP : public wxProtocol
{

> wxHTTP( );
> int GetResponse() const;
> // wxInputStream *GetInputStream(const wxString& path) - see wxProtocol
> void SetHeader(const wxString& header, const wxString& h_data );
> wxString GetHeader(const wxString& header );

};
#endif //wxUSE_PROTOCOL_HTTP
// ---------------------------------------------------------------------------
// wxFTP
#if wxUSE_PROTOCOL_FTP
#include "wx/protocol/ftp.h"
enum wxFTP::TransferMode
{

> NONE,
> ASCII,
> BINARY

};
class %delete wxFTP : public wxProtocol
{

> wxFTP( );
> //bool Abort( );
> bool CheckCommand(const wxString& command, char ret );
> char SendCommand(const wxString& command );
> wxString GetLastResult( );
> bool ChDir(const wxString& dir );
> bool MkDir(const wxString& dir );
> bool RmDir(const wxString& dir );
> wxString Pwd( );
> bool Rename(const wxString& src, const wxString& dst );
> bool RmFile(const wxString& path );
> bool SetAscii( );
> bool SetBinary( );
> void SetPassive(bool pasv );
> bool SetTransferMode(wxFTP::TransferMode mode );
> // void SetUser(const wxString& user) - see wxProtocol
> // void SetPassword(const wxString& passwd) - see wxProtocol
> bool FileExists(const wxString& filename );
> int GetFileSize(const wxString& filename );
> bool GetDirList(wxArrayString& files, const wxString& wildcard = "" );
> bool GetFilesList(wxArrayString& files, const wxString& wildcard = "" );
> wxOutputStream * GetOutputStream(const wxString& file );
> // wxInputStream * GetInputStream(const wxString& path) - see wxProtocol

};
#endif //wxUSE_PROTOCOL_FTP
// ---------------------------------------------------------------------------
// wxURI
#include "wx/uri.h"
enum wxURIHostType
{

> wxURI_REGNAME,
> wxURI_IPV4ADDRESS,
> wxURI_IPV6ADDRESS,
> wxURI_IPVFUTURE

};
enum wxURIFieldType
{

> wxURI_SCHEME,
> wxURI_USERINFO,
> wxURI_SERVER,
> wxURI_PORT,
> wxURI_PATH,
> wxURI_QUERY,
> wxURI_FRAGMENT

};
enum wxURIFlags
{

> wxURI_STRICT

};
class %delete wxURI : public wxObject
{

> wxURI( );
> wxURI(const wxString& uri );
> wxURI(const wxURI& uri );
> %wxchkver_2_9_2 bool Create(const wxString& uri );
> !%wxchkver_2_9_2 wxString Create(const wxString& uri );
> bool HasScheme() const;
> bool HasUserInfo() const;
> bool HasServer() const;
> bool HasPort() const;
> bool HasPath() const;
> bool HasQuery() const;
> bool HasFragment() const;
> wxString GetScheme() const;
> wxString GetPath() const;
> wxString GetQuery() const;
> wxString GetFragment() const;
> wxString GetPort() const;
> wxString GetUserInfo() const;
> wxString GetServer() const;
> wxURIHostType GetHostType() const;
> wxString GetUser() const;
> wxString GetPassword() const;
> wxString BuildURI() const;
> wxString BuildUnescapedURI() const;
> void Resolve(const wxURI& base, int flags = wxURI_STRICT );
> bool IsReference() const;
> static wxString Unescape (const wxString& szEscapedURI );
> wxURI& operator = (const wxURI& uri);
> //wxURI& operator = (const wxString& string);
> bool operator == (const wxURI& uri) const;

};
// ---------------------------------------------------------------------------
// wxURL
#if wxUSE_URL
#include "wx/url.h"
enum wxURLError
{

> wxURL_NOERR,
> wxURL_SNTXERR,
> wxURL_NOPROTO,
> wxURL_NOHOST,
> wxURL_NOPATH,
> wxURL_CONNERR,
> wxURL_PROTOERR

};
class %delete wxURL : public wxURI
{

> wxURL(const wxString& sUrl );
> wxURL(const wxURI& url );
> wxProtocol& GetProtocol( );
> wxURLError GetError() const;
> wxString GetURL() const;
> wxInputStream *GetInputStream( );
> #if wxUSE_PROTOCOL_HTTP
> static void SetDefaultProxy(const wxString& url_proxy );
> void SetProxy(const wxString& url_proxy );
> #endif // wxUSE_PROTOCOL_HTTP
> //wxURL& operator = (const wxString& url);
> //wxURL& operator = (const wxURI& url);

};
#endif //wxUSE_URL
// ---------------------------------------------------------------------------
//// wxConnectionBase
//
//%include "wx/ipcbase.h"
//
//enum wxIPCFormat
//{
// wxIPC_INVALID,
// wxIPC_TEXT,
// wxIPC_BITMAP,
// wxIPC_METAFILE,
// wxIPC_SYLK,
// wxIPC_DIF,
// wxIPC_TIFF,
// wxIPC_OEMTEXT,
// wxIPC_DIB,
// wxIPC_PALETTE,
// wxIPC_PENDATA,
// wxIPC_RIFF,
// wxIPC_WAVE,
// wxIPC_UNICODETEXT,
// wxIPC_ENHMETAFILE,
// wxIPC_FILENAME,
// wxIPC_LOCALE,
// wxIPC_PRIVATE
//};
//
//class wxConnectionBase : public wxObject
//{
// // no constructor virtual base class
//
// bool Advise(const wxString& item, char* data, int size = -1, wxIPCFormat format = wxCF_TEXT );
//};
//
// ---------------------------------------------------------------------------
//// wxConnection
//
//class wxConnection : public wxConnectionBase
//{
// wxConnection( );
//};
//
// ---------------------------------------------------------------------------
//// wxClient
//
//class wxClient : public wxObject
//{
// wxClient( );
// wxConnectionBase * MakeConnection(const wxString& host, const wxString& service, const wxString& topic );
//
// //virtual wxConnectionBase * OnMakeConnection( );
// bool ValidHost(const wxString& host );
//};
//
#endif //wxLUA_USE_wxSocket && wxUSE_SOCKETS

## wxwidgets/wxmedia_media.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxMedia library
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxMediaCtrl
#if wxLUA_USE_wxMediaCtrl && wxUSE_MEDIACTRL
#include "wx/mediactrl.h"
enum wxMediaState
{

> wxMEDIASTATE_STOPPED,
> wxMEDIASTATE_PAUSED,
> wxMEDIASTATE_PLAYING

};
enum wxMediaCtrlPlayerControls
{

> wxMEDIACTRLPLAYERCONTROLS_NONE,
> wxMEDIACTRLPLAYERCONTROLS_STEP,
> wxMEDIACTRLPLAYERCONTROLS_VOLUME,
> wxMEDIACTRLPLAYERCONTROLS_DEFAULT

};
#define_wxstring wxMEDIABACKEND_DIRECTSHOW //wxT("wxAMMediaBackend" );
#define_wxstring wxMEDIABACKEND_MCI //wxT("wxMCIMediaBackend" );
#define_wxstring wxMEDIABACKEND_QUICKTIME //wxT("wxQTMediaBackend" );
#define_wxstring wxMEDIABACKEND_GSTREAMER //wxT("wxGStreamerMediaBackend" );
%wxchkver_2_8 #define_wxstring wxMEDIABACKEND_REALPLAYER //wxT("wxRealPlayerMediaBackend" );
%wxchkver_2_8 #define_wxstring wxMEDIABACKEND_WMP10 //wxT("wxWMP10MediaBackend" );
class wxMediaCtrl : public wxControl
{

> wxMediaCtrl( );
> wxMediaCtrl( wxWindow* parent, wxWindowID winid, const wxString& fileName = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& szBackend = "", const wxValidator& val = wxDefaultValidator, const wxString& name = "wxMediaCtrl" );
> bool Create( wxWindow* parent, wxWindowID winid, const wxString& fileName = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& szBackend = "", const wxValidator& val = wxDefaultValidator, const wxString& name = "wxMediaCtrl" );
> wxFileOffset GetDownloadProgress(); // DirectShow only
> wxFileOffset GetDownloadTotal(); // DirectShow only
> wxMediaState GetState( );
> double GetVolume( );
> wxFileOffset Length( );
> bool Load(const wxString& fileName );
> bool Load(const wxURI& location );
> bool Load(const wxURI& location, const wxURI& proxy );
> bool LoadURI(const wxString& fileName); // { return Load(wxURI(fileName)); }
> bool LoadURIWithProxy(const wxString& fileName, const wxString& proxy); // { return Load(wxURI(fileName), wxURI(proxy)); }
> bool Pause( );
> bool Play( );
> wxFileOffset Seek(wxFileOffset where, wxSeekMode mode = wxFromStart );
> bool Stop( );
> bool SetVolume(double dVolume );
> double GetVolume( );
> bool ShowPlayerControls(wxMediaCtrlPlayerControls flags = wxMEDIACTRLPLAYERCONTROLS_DEFAULT );
> wxFileOffset Tell();

};
// ---------------------------------------------------------------------------
// wxMediaEvent
#if !%wxchkver_2_9_2
#define wxMEDIA_FINISHED_ID
#define wxMEDIA_STOP_ID
#define wxMEDIA_LOADED_ID
%wxchkver_2_6_4 #define wxMEDIA_STATECHANGED_ID
%wxchkver_2_6_4 #define wxMEDIA_PLAY_ID
%wxchkver_2_6_4 #define wxMEDIA_PAUSE_ID
#endif
class %delete wxMediaEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_MEDIA_FINISHED // EVT_MEDIA_FINISHED(winid, fn );
> %wxEventType wxEVT_MEDIA_STOP // EVT_MEDIA_STOP(winid, fn );
> %wxEventType wxEVT_MEDIA_LOADED // EVT_MEDIA_LOADED(winid, fn );
> %wxchkver_2_6_4 %wxEventType wxEVT_MEDIA_STATECHANGED // EVT_MEDIA_STATECHANGED(winid, fn );
> %wxchkver_2_6_4 %wxEventType wxEVT_MEDIA_PLAY // EVT_MEDIA_PLAY(winid, fn );
> %wxchkver_2_6_4 %wxEventType wxEVT_MEDIA_PAUSE // EVT_MEDIA_PAUSE(winid, fn );
> wxMediaEvent(wxEventType commandType = wxEVT_NULL, int winid = 0 );

};
#endif //wxLUA_USE_wxMediaCtrl && wxUSE_MEDIACTRL

## wxwidgets/wxgl_gl.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxGL library
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
//#if wxUSE_OPENGL // FIXME ? Is it probably enough to test for wxUSE_GLCANVAS
// ---------------------------------------------------------------------------
// wxGLCanvas
#if wxLUA_USE_wxGLCanvas && wxUSE_GLCANVAS
// FIXME : Need to wrap wxGLApp?
#include "wx/glcanvas.h"
enum
{
WX_GL_RGBA,
WX_GL_BUFFER_SIZE,
WX_GL_LEVEL,
WX_GL_DOUBLEBUFFER,
WX_GL_STEREO,
WX_GL_AUX_BUFFERS,
WX_GL_MIN_RED,
WX_GL_MIN_GREEN,
WX_GL_MIN_BLUE,
WX_GL_MIN_ALPHA,
WX_GL_DEPTH_SIZE,
WX_GL_STENCIL_SIZE,
WX_GL_MIN_ACCUM_RED,
WX_GL_MIN_ACCUM_GREEN,
WX_GL_MIN_ACCUM_BLUE,
WX_GL_MIN_ACCUM_ALPHA
};
class wxGLCanvas : public wxWindow
{

> #if !%wxchkver_3_0
> wxGLCanvas(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style=0, const wxString& name="GLCanvas", int attribList[] = 0, const wxPalette& palette = wxNullPalette );
> wxGLCanvas(wxWindow* parent, wxGLContext* sharedContext, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style=0, const wxString& name="GLCanvas", int attribList[] = 0, const wxPalette& palette = wxNullPalette );
> wxGLCanvas(wxWindow* parent, wxGLCanvas* sharedCanvas, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style=0, const wxString& name="GLCanvas", int attribList[] = 0, const wxPalette& palette = wxNullPalette );
> !%mac wxGLCanvas(wxWindow* parent, wxWindowID id = wxID_ANY, int attribList[] = 0, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style=0, const wxString& name="GLCanvas", const wxPalette& palette = wxNullPalette );
> #endif
> #if %wxchkver_3_0
> !%mac wxGLCanvas(wxWindow* parent, wxWindowID id = wxID_ANY, int attribList[] = 0, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style=0, const wxString& name="GLCanvas", const wxPalette& palette = wxNullPalette );
> #endif
> //wxGLContext* GetContext() const; - removed in wx 3.0
> %mac void SetCurrent( );
> %wxchkver_2_8&!%mac void SetCurrent(const wxGLContext& RC) const;
> void SetColour(const wxString& colour );
> void SwapBuffers( );

};
// ---------------------------------------------------------------------------
// wxGLContext
class wxGLContext : public wxObject
{

> #if %wxchkver_2_8
> !%mac wxGLContext(wxGLCanvas *win, const wxGLContext* other = NULL ); // FIXME
> !%mac | %wxchkver_2_9 void SetCurrent(const wxGLCanvas& win) const;
> %mac & !%wxchkver_2_9 void SetCurrent() const;
> #endif // %wxchkver_2_8
> #if !%wxchkver_2_8
> wxGLContext(bool isRGB, wxGLCanvas* win, const wxPalette& palette = wxNullPalette );
> wxGLContext(bool isRGB, wxGLCanvas* win, const wxPalette& palette = wxNullPalette, const wxGLContext* other = NULL );
> const wxWindow* GetWindow( );
> void SetCurrent( );
> void SetColour(const wxString& colour );
> void SwapBuffers( );
> #endif // !%wxchkver_2_8

};
#endif //wxLUA_USE_wxGLCanvas && wxUSE_GLCANVAS
//#endif wxUSE_OPENGL

## wxwidgets/wxxml_xml.i - Lua table = 'wx'

// ===========================================================================
// Purpose: wxXML library
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxXML && wxUSE_XML
%wxchkver_2_6 #include "wx/xml/xml.h"
enum wxXmlNodeType
{

> wxXML_ELEMENT_NODE,
> wxXML_ATTRIBUTE_NODE,
> wxXML_TEXT_NODE,
> wxXML_CDATA_SECTION_NODE,
> wxXML_ENTITY_REF_NODE,
> wxXML_ENTITY_NODE,
> wxXML_PI_NODE,
> wxXML_COMMENT_NODE,
> wxXML_DOCUMENT_NODE,
> wxXML_DOCUMENT_TYPE_NODE,
> wxXML_DOCUMENT_FRAG_NODE,
> wxXML_NOTATION_NODE,
> wxXML_HTML_DOCUMENT_NODE

};
// ---------------------------------------------------------------------------
// wxXmlNode
class %delete wxXmlNode
{

> wxXmlNode( );
> wxXmlNode(wxXmlNodeType type, const wxString& name, const wxString& content = "" );
> // %override wxXmlNode::wxXmlNode(wxXmlNode *parent, wxXmlNodeType type, const wxString& name, const wxString& content, wxXmlProperty *props, wxXmlNode *next );
> // C++ Func: No change: if parent is not NULL, created node is not garbage collected.
> wxXmlNode(wxXmlNode *parent, wxXmlNodeType type, const wxString& name, const wxString& content, wxXmlProperty *props, wxXmlNode *next );
> void AddChild(%ungc wxXmlNode *child );
> void InsertChild(%ungc wxXmlNode *child, wxXmlNode *before_node );
> // %override bool wxXmlNode::RemoveChild(%gc wxXmlNode *child );
> // C++ Func: No change: only if child is removed will we garbage collect it
> bool RemoveChild(%gc wxXmlNode *child );
> void AddProperty(const wxString& name, const wxString& value );
> bool DeleteProperty(const wxString& name );
> wxXmlNodeType GetType() const;
> wxString GetName() const;
> wxString GetContent() const;
> wxXmlNode *GetParent() const;
> wxXmlNode *GetNext() const;
> wxXmlNode *GetChildren() const;
> wxXmlProperty *GetProperties() const;
> // %override [bool string] wxXmlNode::GetPropValPtr(const wxString& propName) const;
> // C++ Func: bool GetPropVal(const wxString& propName, wxString *value) const;
> %override_name wxLua_wxXmlNode_GetPropValPtr bool GetPropVal(const wxString& propName) const;
> wxString GetPropVal(const wxString& propName, const wxString& defaultVal) const;
> bool HasProp(const wxString& propName) const;
> void SetType(wxXmlNodeType type );
> void SetName(const wxString& name );
> void SetContent(const wxString& con );
> void SetParent(wxXmlNode *parent );
> void SetNext(wxXmlNode *next );
> void SetChildren(%ungc wxXmlNode *child );
> void SetProperties(%ungc wxXmlProperty *prop );
> void AddProperty(%ungc wxXmlProperty *prop );

};
// ---------------------------------------------------------------------------
// wxXmlProperty
class %delete wxXmlProperty
{

> wxXmlProperty( );
> wxXmlProperty(const wxString& name, const wxString& value, wxXmlProperty *next );
> wxString GetName( );
> wxString GetValue( );
> wxXmlProperty *GetNext( );
> void SetName(const wxString& name );
> void SetValue(const wxString& value );
> void SetNext(wxXmlProperty *next );

};
// ---------------------------------------------------------------------------
// wxXmlDocument
class %delete wxXmlDocument : public wxObject
{

> wxXmlDocument();
> wxXmlDocument(const wxString& filename, const wxString& encoding = "UTF-8");
> //wxXmlDocument(wxInputStream& stream, const wxString& encoding = "UTF-8");
> bool Load(const wxString& filename, const wxString& encoding = "UTF-8");
> //bool Load(wxInputStream& stream, const wxString& encoding = "UTF-8");
> bool Save(const wxString& filename) const;
> //bool Save(wxOutputStream& stream) const;
> bool IsOk() const;
> wxXmlNode *GetRoot() const;
> wxString GetVersion() const;
> wxString GetFileEncoding() const;
> void SetRoot(%ungc wxXmlNode *node);
> void SetVersion(const wxString& version);
> void SetFileEncoding(const wxString& encoding);
> // These two are not for unicode
> //wxString GetEncoding() const;
> //void SetEncoding(const wxString& enc);

};
#endif //wxLUA_USE_wxXML && wxUSE_XML

## wxwidgets/wxxrc_xrc.i - Lua table = 'wx'

// ===========================================================================
// Purpose: XRC Resource system
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxXRC && wxUSE_XRC
#include "wx/xrc/xmlres.h"
// ---------------------------------------------------------------------------
// wxXmlResourceHandler - wxLua shouldn't need this
//class wxXmlResourceHandler : public wxObject
//{
//};
enum wxXmlResourceFlags
{

> wxXRC_USE_LOCALE,
> wxXRC_NO_SUBCLASSING,
> wxXRC_NO_RELOADING

};
// ---------------------------------------------------------------------------
// wxXmlResource
class %delete wxXmlResource : public wxObject
{

> //wxXmlResource();
> wxXmlResource(int flags = wxXRC_USE_LOCALE, const wxString& domain = "");
> wxXmlResource(const wxString& filemask, int flags = wxXRC_USE_LOCALE, const wxString& domain = "");
> //void AddHandler(wxXmlResourceHandler* handler);
> bool AttachUnknownControl(const wxString& name, wxWindow* control, wxWindow* parent = NULL);
> void ClearHandlers();
> int CompareVersion(int major, int minor, int release, int revision) const;
> static wxXmlResource* Get();
> int GetFlags( );
> long GetVersion() const;
> static int GetXRCID(const wxString &stringID, int value_if_not_found = wxID_NONE);
> void InitAllHandlers();
> bool Load(const wxString& filemask);
> wxBitmap LoadBitmap(const wxString& name);
> wxDialog* LoadDialog(wxWindow* parent, const wxString& name);
> bool LoadDialog(wxDialog* dlg, wxWindow *parent, const wxString &name);
> bool LoadFrame(wxFrame* frame, wxWindow* parent, const wxString& name);
> wxIcon LoadIcon(const wxString& name);
> wxMenu* LoadMenu(const wxString& name);
> wxMenuBar* LoadMenuBar(wxWindow* parent, const wxString& name);
> wxMenuBar* LoadMenuBar(const wxString& name);
> wxPanel* LoadPanel(wxWindow* parent, const wxString &name);
> bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString &name);
> wxToolBar* LoadToolBar(wxWindow *parent, const wxString& name);
> static %gc wxXmlResource* Set(%ungc wxXmlResource *res);
> void SetDomain(const wxString& domain );
> void SetFlags(int flags);
> bool Unload(const wxString& filename );

};
#endif //wxLUA_USE_wxXRC && wxUSE_XRC

## wxwidgets/wxaui_aui.i - Lua table = 'wxaui'

// ===========================================================================
// Purpose: wxAUI library
// Author: John Labenski
// Created: 07/03/2007
// Copyright: (c) 2007 John Labenski. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.6
// ===========================================================================
// NOTE: This file is mostly copied from wxWidget's include/aui/*.h headers
// to make updating it easier.
#if wxLUA_USE_wxAUI && %wxchkver_2_8 && wxUSE_AUI
#include "wx/aui/aui.h"
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//#include "wx/aui/auibar.h" // already included by aui.h
enum wxAuiToolBarStyle
{

> wxAUI_TB_TEXT, //= 1 << 0,
> wxAUI_TB_NO_TOOLTIPS, //= 1 << 1,
> wxAUI_TB_NO_AUTORESIZE, //= 1 << 2,
> wxAUI_TB_GRIPPER, //= 1 << 3,
> wxAUI_TB_OVERFLOW, //= 1 << 4,
> wxAUI_TB_VERTICAL, //= 1 << 5,
> wxAUI_TB_HORZ_LAYOUT, //= 1 << 6,
> wxAUI_TB_HORZ_TEXT, //= (wxAUI_TB_HORZ_LAYOUT | wxAUI_TB_TEXT),
> wxAUI_TB_DEFAULT_STYLE //= 0

};
enum wxAuiToolBarArtSetting
{

> wxAUI_TBART_SEPARATOR_SIZE, //= 0,
> wxAUI_TBART_GRIPPER_SIZE, //= 1,
> wxAUI_TBART_OVERFLOW_SIZE //= 2

};
enum wxAuiToolBarToolTextOrientation
{

> wxAUI_TBTOOL_TEXT_LEFT, //= 0, // unused/unimplemented
> wxAUI_TBTOOL_TEXT_RIGHT, //= 1,
> wxAUI_TBTOOL_TEXT_TOP, //= 2, // unused/unimplemented
> wxAUI_TBTOOL_TEXT_BOTTOM //= 3

};
// ---------------------------------------------------------------------------
// wxAuiToolBarEvent
class wxAuiToolBarEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN // EVT_AUITOOLBAR_TOOL_DROPDOWN(winid, fn)
> %wxEventType wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK // EVT_AUITOOLBAR_OVERFLOW_CLICK(winid, fn)
> %wxEventType wxEVT_COMMAND_AUITOOLBAR_RIGHT_CLICK // EVT_AUITOOLBAR_RIGHT_CLICK(winid, fn)
> %wxEventType wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK // EVT_AUITOOLBAR_MIDDLE_CLICK(winid, fn)
> %wxEventType wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG // EVT_AUITOOLBAR_BEGIN_DRAG(winid, fn)
> wxAuiToolBarEvent(wxEventType command_type = wxEVT_NULL, int win_id = 0);
> wxAuiToolBarEvent(const wxAuiToolBarEvent& c);
> wxEvent *Clone() const;
> bool IsDropDownClicked() const;
> void SetDropDownClicked(bool c);
> wxPoint GetClickPoint() const;
> void SetClickPoint(const wxPoint& p);
> wxRect GetItemRect() const;
> void SetItemRect(const wxRect& r);
> int GetToolId() const;
> void SetToolId(int id);

};
// ---------------------------------------------------------------------------
// wxAuiToolBarItem
class wxAuiToolBarItem
{

> wxAuiToolBarItem();
> wxAuiToolBarItem(const wxAuiToolBarItem& c);
> wxAuiToolBarItem& operator=(const wxAuiToolBarItem& c);
> void Assign(const wxAuiToolBarItem& c);
> void SetWindow(wxWindow* w);
> wxWindow* GetWindow();
> void SetId(int new_id);
> int GetId() const;
> void SetKind(int new_kind);
> int GetKind() const;
> void SetState(int new_state);
> int GetState() const;
> void SetSizerItem(wxSizerItem* s);
> wxSizerItem* GetSizerItem() const;
> void SetLabel(const wxString& s);
> const wxString& GetLabel() const;
> void SetBitmap(const wxBitmap& bmp);
> const wxBitmap& GetBitmap() const;
> void SetDisabledBitmap(const wxBitmap& bmp);
> const wxBitmap& GetDisabledBitmap() const;
> void SetHoverBitmap(const wxBitmap& bmp);
> const wxBitmap& GetHoverBitmap() const;
> void SetShortHelp(const wxString& s);
> const wxString& GetShortHelp() const;
> void SetLongHelp(const wxString& s);
> const wxString& GetLongHelp() const;
> void SetMinSize(const wxSize& s);
> const wxSize& GetMinSize() const;
> void SetSpacerPixels(int s);
> int GetSpacerPixels() const;
> void SetProportion(int p);
> int GetProportion() const;
> void SetActive(bool b);
> bool IsActive() const;
> void SetHasDropDown(bool b);
> bool HasDropDown() const;
> void SetSticky(bool b);
> bool IsSticky() const;
> void SetUserData(long l);
> long GetUserData() const;

};
// ---------------------------------------------------------------------------
// wxAuiToolBarItemArray
class %delete wxAuiToolBarItemArray
{

> wxAuiToolBarItemArray();
> wxAuiToolBarItemArray(const wxAuiToolBarItemArray& array);
> void Add(const wxAuiToolBarItem& item);
> void Clear();
> int GetCount() const;
> void Insert(const wxAuiToolBarItem& item, int nIndex);
> bool IsEmpty();
> wxAuiToolBarItem Item(size_t nIndex) const;
> void RemoveAt(size_t nIndex);

};
// ---------------------------------------------------------------------------
// wxAuiToolBarArt
class wxAuiToolBarArt
{

> //wxAuiToolBarArt(); - pure virtual class see wxAuiDefaultToolBarArt
> virtual wxAuiToolBarArt* Clone();
> virtual void SetFlags(unsigned int flags);
> virtual void SetFont(const wxFont& font);
> virtual void SetTextOrientation(int orientation);
> virtual void DrawBackground( wxDC& dc, wxWindow* wnd, const wxRect& rect);
> virtual void DrawLabel( wxDC& dc, wxWindow* wnd, const wxAuiToolBarItem& item, const wxRect& rect);
> virtual void DrawButton( wxDC& dc, wxWindow* wnd, const wxAuiToolBarItem& item, const wxRect& rect);
> virtual void DrawDropDownButton( wxDC& dc, wxWindow* wnd, const wxAuiToolBarItem& item, const wxRect& rect);
> virtual void DrawControlLabel( wxDC& dc, wxWindow* wnd, const wxAuiToolBarItem& item, const wxRect& rect);
> virtual void DrawSeparator( wxDC& dc, wxWindow* wnd, const wxRect& rect);
> virtual void DrawGripper( wxDC& dc, wxWindow* wnd, const wxRect& rect);
> virtual void DrawOverflowButton( wxDC& dc, wxWindow* wnd, const wxRect& rect, int state);
> virtual wxSize GetLabelSize( wxDC& dc, wxWindow* wnd, const wxAuiToolBarItem& item);
> virtual wxSize GetToolSize( wxDC& dc, wxWindow* wnd, const wxAuiToolBarItem& item);
> virtual int GetElementSize(int element_id);
> virtual void SetElementSize(int element_id, int size);
> virtual int ShowDropDown( wxWindow* wnd, const wxAuiToolBarItemArray& items);

};
// ---------------------------------------------------------------------------
// wxAuiDefaultToolBarArt
class wxAuiDefaultToolBarArt : public wxAuiToolBarArt
{

> wxAuiDefaultToolBarArt();

};
// ---------------------------------------------------------------------------
// wxAuiToolBar
class wxAuiToolBar : public wxControl
{

> wxAuiToolBar(wxWindow* parent, wxWindowID id = -1, const wxPoint& position = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxAUI_TB_DEFAULT_STYLE);
> void SetWindowStyleFlag(long style);
> long GetWindowStyleFlag() const;
> void SetArtProvider(wxAuiToolBarArt* art);
> wxAuiToolBarArt* GetArtProvider() const;
> bool SetFont(const wxFont& font);
> void AddTool(int tool_id, const wxString& label, const wxBitmap& bitmap, const wxString& short_help_string = wxEmptyString, wxItemKind kind = wxITEM_NORMAL);
> void AddTool(int tool_id, const wxString& label, const wxBitmap& bitmap, const wxBitmap& disabled_bitmap, wxItemKind kind, const wxString& short_help_string, const wxString& long_help_string, wxObject* client_data);
> void AddTool(int tool_id, const wxBitmap& bitmap, const wxBitmap& disabled_bitmap, bool toggle = false, wxObject* client_data = NULL, const wxString& short_help_string = wxEmptyString, const wxString& long_help_string = wxEmptyString);
> void AddLabel(int tool_id, const wxString& label = wxEmptyString, const int width = -1);
> void AddControl(wxControl* control, const wxString& label = wxEmptyString);
> void AddSeparator();
> void AddSpacer(int pixels);
> void AddStretchSpacer(int proportion = 1);
> bool Realize();
> wxControl* FindControl(int window_id);
> wxAuiToolBarItem* FindToolByPosition(wxCoord x, wxCoord y) const;
> wxAuiToolBarItem* FindToolByIndex(int idx) const;
> wxAuiToolBarItem* FindTool(int tool_id) const;
> void ClearTools();
> void Clear();
> bool DeleteTool(int tool_id);
> bool DeleteByIndex(int tool_id);
> size_t GetToolCount() const;
> int GetToolPos(int tool_id) const;
> int GetToolIndex(int tool_id) const;
> bool GetToolFits(int tool_id) const;
> wxRect GetToolRect(int tool_id) const;
> bool GetToolFitsByIndex(int tool_id) const;
> bool GetToolBarFits() const;
> void SetMargins(const wxSize& size);
> void SetMargins(int x, int y);
> void SetMargins(int left, int right, int top, int bottom);
> void SetToolBitmapSize(const wxSize& size);
> wxSize GetToolBitmapSize() const;
> bool GetOverflowVisible() const;
> void SetOverflowVisible(bool visible);
> bool GetGripperVisible() const;
> void SetGripperVisible(bool visible);
> void ToggleTool(int tool_id, bool state);
> bool GetToolToggled(int tool_id) const;
> void EnableTool(int tool_id, bool state);
> bool GetToolEnabled(int tool_id) const;
> void SetToolDropDown(int tool_id, bool dropdown);
> bool GetToolDropDown(int tool_id) const;
> void SetToolBorderPadding(int padding);
> int GetToolBorderPadding() const;
> void SetToolTextOrientation(int orientation);
> int GetToolTextOrientation() const;
> void SetToolPacking(int packing);
> int GetToolPacking() const;
> void SetToolProportion(int tool_id, int proportion);
> int GetToolProportion(int tool_id) const;
> void SetToolSeparation(int separation);
> int GetToolSeparation() const;
> void SetToolSticky(int tool_id, bool sticky);
> bool GetToolSticky(int tool_id) const;
> wxString GetToolLabel(int tool_id) const;
> void SetToolLabel(int tool_id, const wxString& label);
> wxBitmap GetToolBitmap(int tool_id) const;
> void SetToolBitmap(int tool_id, const wxBitmap& bitmap);
> wxString GetToolShortHelp(int tool_id) const;
> void SetToolShortHelp(int tool_id, const wxString& help_string);
> wxString GetToolLongHelp(int tool_id) const;
> void SetToolLongHelp(int tool_id, const wxString& help_string);
> void SetCustomOverflowItems(const wxAuiToolBarItemArray& prepend, const wxAuiToolBarItemArray& append);

};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//#include "wx/aui/auibook.h" // already included by aui.h
enum wxAuiNotebookOption
{

> wxAUI_NB_TOP,
> wxAUI_NB_LEFT, // not implemented yet
> wxAUI_NB_RIGHT, // not implemented yet
> wxAUI_NB_BOTTOM, // not implemented yet
> wxAUI_NB_TAB_SPLIT,
> wxAUI_NB_TAB_MOVE,
> wxAUI_NB_TAB_EXTERNAL_MOVE,
> wxAUI_NB_TAB_FIXED_WIDTH,
> wxAUI_NB_SCROLL_BUTTONS,
> wxAUI_NB_WINDOWLIST_BUTTON,
> wxAUI_NB_CLOSE_BUTTON,
> wxAUI_NB_CLOSE_ON_ACTIVE_TAB,
> wxAUI_NB_CLOSE_ON_ALL_TABS,
> %wxchkver_2_8_6 wxAUI_NB_MIDDLE_CLICK_CLOSE,
> wxAUI_NB_DEFAULT_STYLE //= wxAUI_NB_TOP|wxAUI_NB_TAB_SPLIT|wxAUI_NB_TAB_MOVE|wxAUI_NB_SCROLL_BUTTONS|wxAUI_NB_CLOSE_ON_ACTIVE_TAB|wxAUI_NB_MIDDLE_CLICK_CLOSE

};
// ---------------------------------------------------------------------------
// wxAuiNotebookEvent
class %delete wxAuiNotebookEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE // EVT_AUINOTEBOOK_PAGE_CLOSE(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED // EVT_AUINOTEBOOK_PAGE_CHANGED(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING // EVT_AUINOTEBOOK_PAGE_CHANGING(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_BUTTON // EVT_AUINOTEBOOK_BUTTON(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG // EVT_AUINOTEBOOK_BEGIN_DRAG(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_END_DRAG // EVT_AUINOTEBOOK_END_DRAG(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION // EVT_AUINOTEBOOK_DRAG_MOTION(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND // EVT_AUINOTEBOOK_ALLOW_DND(winid, fn );
> #if %wxchkver_2_8_5
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN // EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP // EVT_AUINOTEBOOK_TAB_MIDDLE_UP(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN // EVT_AUINOTEBOOK_TAB_RIGHT_DOWN(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP // EVT_AUINOTEBOOK_TAB_RIGHT_UP(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED //
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE // EVT_AUINOTEBOOK_DRAG_DONE(winid, fn );
> %wxEventType wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK // EVT_AUINOTEBOOK_BG_DCLICK(winid, fn );
> #endif //%wxchkver_2_8_5
> wxAuiNotebookEvent(wxEventType command_type = wxEVT_NULL, int win_id = 0 );
> wxAuiNotebookEvent(const wxAuiNotebookEvent& c);
> void SetSelection(int s);
> int GetSelection() const;
> void SetOldSelection(int s);
> int GetOldSelection() const;
> void SetDragSource(wxAuiNotebook* s);
> wxAuiNotebook* GetDragSource() const;

};
// ---------------------------------------------------------------------------
// wxAuiNotebookPage
class %delete wxAuiNotebookPage
{

> wxWindow* window; // page's associated window
> wxString caption; // caption displayed on the tab
> wxBitmap bitmap; // tab's bitmap
> wxRect rect; // tab's hit rectangle
> bool active; // true if the page is currently active

};
// ---------------------------------------------------------------------------
// wxAuiNotebookPageArray
class %delete wxAuiNotebookPageArray
{

> wxAuiNotebookPageArray();
> wxAuiNotebookPageArray(const wxAuiNotebookPageArray& array);
> void Add(wxAuiNotebookPage* page);
> void Clear();
> int GetCount() const;
> void Insert(wxAuiNotebookPage* page, int nIndex);
> bool IsEmpty();
> wxAuiNotebookPage Item(size_t nIndex) const;
> void RemoveAt(size_t nIndex);

};
// ---------------------------------------------------------------------------
// wxAuiTabContainerButton
class %delete wxAuiTabContainerButton
{

> int id; // button's id
> !%wxchkver_2_9_3 int cur_state; // current state (normal, hover, pressed, etc. );
> %wxchkver_2_9_3 int curState;
> int location; // buttons location (wxLEFT, wxRIGHT, or wxCENTER );
> wxBitmap bitmap; // button's hover bitmap
> !%wxchkver_2_9_3 wxBitmap dis_bitmap; // button's disabled bitmap
> %wxchkver_2_9_3 wxBitmap disBitmap;
> wxRect rect; // button's hit rectangle

};
//WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiTabContainerButton, wxAuiTabContainerButtonArray, WXDLLIMPEXP_AUI);
// ---------------------------------------------------------------------------
// wxAuiTabArt
class %delete wxAuiTabArt
{

> // wxAuiTabArt() No constructor - base class
> %gc virtual wxAuiTabArt* Clone(); //= 0;
> virtual void SetFlags(unsigned int flags); //= 0;
> virtual void SetSizingInfo(const wxSize& tab_ctrl_size, size_t tab_count); //= 0;
> virtual void SetNormalFont(const wxFont& font); //= 0;
> virtual void SetSelectedFont(const wxFont& font); //= 0;
> virtual void SetMeasuringFont(const wxFont& font); //= 0;
> virtual void DrawBackground( wxDC& dc, wxWindow* wnd, const wxRect& rect); //= 0;
> virtual void DrawTab(wxDC& dc, wxWindow* wnd, const wxAuiNotebookPage& pane, const wxRect& in_rect, int close_button_state, wxRect* out_tab_rect, wxRect* out_button_rect, int* x_extent); //= 0;
> virtual void DrawButton( wxDC& dc, wxWindow* wnd, const wxRect& in_rect, int bitmap_id, int button_state, int orientation, wxRect* out_rect); //= 0;
> virtual wxSize GetTabSize( wxDC& dc, wxWindow* wnd, const wxString& caption, const wxBitmap& bitmap, bool active, int close_button_state, int* x_extent); //= 0;
> virtual int ShowDropDown( wxWindow* wnd, const wxAuiNotebookPageArray& items, int active_idx); //= 0;
> virtual int GetIndentSize(); //= 0;
> virtual int GetBestTabCtrlSize( wxWindow* wnd, const wxAuiNotebookPageArray& pages, const wxSize& required_bmp_size); //= 0;

};
// ---------------------------------------------------------------------------
// wxAuiDefaultTabArt
class %delete wxAuiDefaultTabArt : public wxAuiTabArt
{

> wxAuiDefaultTabArt();

};
// ---------------------------------------------------------------------------
// wxAuiSimpleTabArt
class %delete wxAuiSimpleTabArt : public wxAuiTabArt
{

> wxAuiSimpleTabArt();

};
// ---------------------------------------------------------------------------
// wxAuiTabContainer
//class %delete wxAuiTabContainer
//{
// wxAuiTabContainer();
//
// All methods put into wxAuiTabCtrl since this isn't the base class of anything else
//};
// ---------------------------------------------------------------------------
// wxAuiTabCtrl
class wxAuiTabCtrl : public wxControl //, public wxAuiTabContainer
{

> wxAuiTabCtrl(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0);
> void SetArtProvider(%ungc wxAuiTabArt* art);
> wxAuiTabArt* GetArtProvider() const;
> void SetFlags(unsigned int flags);
> unsigned int GetFlags() const;
> bool AddPage(wxWindow* page, const wxAuiNotebookPage& info);
> bool InsertPage(wxWindow* page, const wxAuiNotebookPage& info, size_t idx);
> bool MovePage(wxWindow* page, size_t new_idx);
> bool RemovePage(wxWindow* page);
> bool SetActivePage(wxWindow* page);
> bool SetActivePage(size_t page);
> void SetNoneActive();
> int GetActivePage() const;
> bool TabHitTest(int x, int y, wxWindow** hit) const;
> bool ButtonHitTest(int x, int y, wxAuiTabContainerButton** hit) const;
> wxWindow* GetWindowFromIdx(size_t idx) const;
> int GetIdxFromWindow(wxWindow* page) const;
> size_t GetPageCount() const;
> wxAuiNotebookPage& GetPage(size_t idx);
> const wxAuiNotebookPage& GetPage(size_t idx) const;
> wxAuiNotebookPageArray& GetPages();
> void SetNormalFont(const wxFont& normal_font);
> void SetSelectedFont(const wxFont& selected_font);
> void SetMeasuringFont(const wxFont& measuring_font);
> void DoShowHide();
> void SetRect(const wxRect& rect);
> void RemoveButton(int id);
> void AddButton(int id, int location, const wxBitmap& normal_bitmap = wxNullBitmap, const wxBitmap& disabled_bitmap = wxNullBitmap);
> size_t GetTabOffset() const;
> void SetTabOffset(size_t offset);
> %wxchkver_2_8_6 bool IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* wnd);
> %wxchkver_2_8_6 void MakeTabVisible(int tabPage, wxWindow* win);
> %wxchkver_2_8_5 bool IsDragging() const;

};
// ---------------------------------------------------------------------------
// wxAuiNotebook
class wxAuiNotebook : public wxControl
{

> wxAuiNotebook();
> wxAuiNotebook(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxAUI_NB_DEFAULT_STYLE);
> bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0);
> void SetWindowStyleFlag(long style);
> void SetArtProvider(%ungc wxAuiTabArt* art);
> wxAuiTabArt* GetArtProvider() const;
> virtual void SetUniformBitmapSize(const wxSize& size);
> virtual void SetTabCtrlHeight(int height);
> bool AddPage(wxWindow* page, const wxString& caption, bool select = false, const wxBitmap& bitmap = wxNullBitmap);
> bool InsertPage(size_t page_idx, wxWindow* page, const wxString& caption, bool select = false, const wxBitmap& bitmap = wxNullBitmap);
> bool DeletePage(size_t page);
> bool RemovePage(size_t page);
> size_t GetPageCount() const;
> wxWindow* GetPage(size_t page_idx) const;
> int GetPageIndex(wxWindow* page_wnd) const;
> bool SetPageText(size_t page, const wxString& text);
> wxString GetPageText(size_t page_idx) const;
> bool SetPageBitmap(size_t page, const wxBitmap& bitmap);
> wxBitmap GetPageBitmap(size_t page_idx) const;
> size_t SetSelection(size_t new_page);
> int GetSelection() const;
> virtual void Split(size_t page, int direction);
> #if %wxchkver_2_8_1 // (wxABI_VERSION >= 20801 );
> const wxAuiManager& GetAuiManager() const;
> #endif
> #if %wxchkver_2_8_5 //(wxABI_VERSION >= 20805 );
> // Sets the normal font
> void SetNormalFont(const wxFont& font);
> // Sets the selected tab font
> void SetSelectedFont(const wxFont& font);
> // Sets the measuring font
> void SetMeasuringFont(const wxFont& font);
> // Sets the tab font
> virtual bool SetFont(const wxFont& font);
> // Gets the tab control height
> int GetTabCtrlHeight() const;
> // Gets the height of the notebook for a given page height
> int GetHeightForPageHeight(int pageHeight);
> // Advances the selection, generation page selection events
> void AdvanceSelection(bool forward = true);
> // Shows the window menu
> bool ShowWindowMenu();
> #if %wxchkver_2_9_4
> wxString GetPageToolTip( size_t pageIdx ) const;
> bool SetPageToolTip( size_t page, const wxString& text );
> #endif

};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//#include "wx/aui/dockart.h"
// ---------------------------------------------------------------------------
// wxAuiDockArt
class %delete wxAuiDockArt
{

> // wxAuiDockArt() - No constructor - base class
> virtual int GetMetric(int id); //= 0;
> virtual void SetMetric(int id, int new_val); //= 0;
> virtual void SetFont(int id, const wxFont& font); //= 0;
> virtual wxFont GetFont(int id); //= 0;
> virtual wxColour GetColour(int id); //= 0;
> virtual void SetColour(int id, const wxColour& colour); //= 0;
> wxColour GetColor(int id);
> void SetColor(int id, const wxColour& color);
> virtual void DrawSash(wxDC& dc, wxWindow* window, int orientation, const wxRect& rect); //= 0;
> virtual void DrawBackground(wxDC& dc, wxWindow* window, int orientation, const wxRect& rect); //= 0;
> virtual void DrawCaption(wxDC& dc, wxWindow* window, const wxString& text, const wxRect& rect, wxAuiPaneInfo& pane); //= 0;
> virtual void DrawGripper(wxDC& dc, wxWindow* window, const wxRect& rect, wxAuiPaneInfo& pane); //= 0;
> virtual void DrawBorder(wxDC& dc, wxWindow* window, const wxRect& rect, wxAuiPaneInfo& pane); //= 0;
> virtual void DrawPaneButton(wxDC& dc, wxWindow* window, int button, int button_state, const wxRect& rect, wxAuiPaneInfo& pane); //= 0;

};
// ---------------------------------------------------------------------------
// wxAuiDefaultDockArt
class %delete wxAuiDefaultDockArt : public wxAuiDockArt
{

> wxAuiDefaultDockArt();

};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//#include "wx/aui/floatpane.h"
// ---------------------------------------------------------------------------
// wxAuiFloatingFrame
class wxAuiFloatingFrame : public wxFrame // wxAuiFloatingFrameBaseClass
{

> wxAuiFloatingFrame(wxWindow* parent, wxAuiManager* owner_mgr, const wxAuiPaneInfo& pane, wxWindowID id = wxID_ANY, long style = wxRESIZE_BORDER|wxSYSTEM_MENU|wxCAPTION|wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT|wxCLIP_CHILDREN);
> void SetPaneWindow(const wxAuiPaneInfo& pane);
> wxAuiManager* GetOwnerManager() const;

};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//#include "wx/aui/framemanager.h"
enum wxAuiManagerDock
{

> wxAUI_DOCK_NONE,
> wxAUI_DOCK_TOP,
> wxAUI_DOCK_RIGHT,
> wxAUI_DOCK_BOTTOM,
> wxAUI_DOCK_LEFT,
> wxAUI_DOCK_CENTER,
> wxAUI_DOCK_CENTRE //= wxAUI_DOCK_CENTER

};
enum wxAuiManagerOption
{

> wxAUI_MGR_ALLOW_FLOATING,
> wxAUI_MGR_ALLOW_ACTIVE_PANE,
> wxAUI_MGR_TRANSPARENT_DRAG,
> wxAUI_MGR_TRANSPARENT_HINT,
> wxAUI_MGR_VENETIAN_BLINDS_HINT,
> wxAUI_MGR_RECTANGLE_HINT,
> wxAUI_MGR_HINT_FADE,
> wxAUI_MGR_NO_VENETIAN_BLINDS_FADE,
> wxAUI_MGR_DEFAULT, //= wxAUI_MGR_ALLOW_FLOATING | wxAUI_MGR_TRANSPARENT_HINT | wxAUI_MGR_HINT_FADE | wxAUI_MGR_NO_VENETIAN_BLINDS_FADE

};
enum wxAuiPaneDockArtSetting
{

> wxAUI_DOCKART_SASH_SIZE,
> wxAUI_DOCKART_CAPTION_SIZE,
> wxAUI_DOCKART_GRIPPER_SIZE,
> wxAUI_DOCKART_PANE_BORDER_SIZE,
> wxAUI_DOCKART_PANE_BUTTON_SIZE,
> wxAUI_DOCKART_BACKGROUND_COLOUR,
> wxAUI_DOCKART_SASH_COLOUR,
> wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR,
> wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR,
> wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR,
> wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR,
> wxAUI_DOCKART_ACTIVE_CAPTION_TEXT_COLOUR,
> wxAUI_DOCKART_INACTIVE_CAPTION_TEXT_COLOUR,
> wxAUI_DOCKART_BORDER_COLOUR,
> wxAUI_DOCKART_GRIPPER_COLOUR,
> wxAUI_DOCKART_CAPTION_FONT,
> wxAUI_DOCKART_GRADIENT_TYPE

};
enum wxAuiPaneDockArtGradients
{

> wxAUI_GRADIENT_NONE,
> wxAUI_GRADIENT_VERTICAL,
> wxAUI_GRADIENT_HORIZONTAL

};
enum wxAuiPaneButtonState
{

> wxAUI_BUTTON_STATE_NORMAL,
> wxAUI_BUTTON_STATE_HOVER,
> wxAUI_BUTTON_STATE_PRESSED,
> wxAUI_BUTTON_STATE_DISABLED,
> wxAUI_BUTTON_STATE_HIDDEN,
> wxAUI_BUTTON_STATE_CHECKED

};
enum wxAuiButtonId
{

> wxAUI_BUTTON_CLOSE,
> wxAUI_BUTTON_MAXIMIZE_RESTORE,
> wxAUI_BUTTON_MINIMIZE,
> wxAUI_BUTTON_PIN,
> wxAUI_BUTTON_OPTIONS,
> wxAUI_BUTTON_WINDOWLIST,
> wxAUI_BUTTON_LEFT,
> wxAUI_BUTTON_RIGHT,
> wxAUI_BUTTON_UP,
> wxAUI_BUTTON_DOWN,
> wxAUI_BUTTON_CUSTOM1,
> wxAUI_BUTTON_CUSTOM2,
> wxAUI_BUTTON_CUSTOM3

};
enum wxAuiPaneInsertLevel
{

> wxAUI_INSERT_PANE,
> wxAUI_INSERT_ROW,
> wxAUI_INSERT_DOCK

};
//WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiDockInfo, wxAuiDockInfoArray, WXDLLIMPEXP_AUI);
//WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiDockUIPart, wxAuiDockUIPartArray, WXDLLIMPEXP_AUI);
//WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiPaneButton, wxAuiPaneButtonArray, WXDLLIMPEXP_AUI);
//WX_DECLARE_USER_EXPORTED_OBJARRAY(wxAuiPaneInfo, wxAuiPaneInfoArray, WXDLLIMPEXP_AUI);
//WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxAuiPaneInfo*, wxAuiPaneInfoPtrArray, class WXDLLIMPEXP_AUI);
//WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxAuiDockInfo*, wxAuiDockInfoPtrArray, class WXDLLIMPEXP_AUI);
// ---------------------------------------------------------------------------
// wxAuiPaneInfo
// NOTE: You can add and subtract flags from this list,
// but do not change the values of the flags, because
// they are stored in a binary integer format in the
// perspective string. If you really need to change the
// values around, you'll have to ensure backwards-compatibility
// in the perspective loading code.
enum wxAuiPaneInfo::wxAuiPaneState
{

> optionFloating,
> optionHidden,
> optionLeftDockable,
> optionRightDockable,
> optionTopDockable,
> optionBottomDockable,
> optionFloatable,
> optionMovable,
> optionResizable,
> optionPaneBorder,
> optionCaption,
> optionGripper,
> optionDestroyOnClose,
> optionToolbar,
> optionActive,
> optionGripperTop,
> optionMaximized,
> buttonClose,
> buttonMaximize,
> buttonMinimize,
> buttonPin,
> buttonCustom1,
> buttonCustom2,
> buttonCustom3,
> savedHiddenState, // used internally
> actionPane // used internally

};
class %delete wxAuiPaneInfo
{

> #define_object wxAuiNullPaneInfo
> wxAuiPaneInfo();
> wxAuiPaneInfo(const wxAuiPaneInfo& c);
> wxAuiPaneInfo& operator=(const wxAuiPaneInfo& c);
> // Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
> // used on loading perspectives etc.
> void SafeSet(wxAuiPaneInfo source);
> bool IsOk() const;
> bool IsFixed() const;
> bool IsResizable() const;
> bool IsShown() const;
> bool IsFloating() const;
> bool IsDocked() const;
> bool IsToolbar() const;
> bool IsTopDockable() const;
> bool IsBottomDockable() const;
> bool IsLeftDockable() const;
> bool IsRightDockable() const;
> bool IsFloatable() const;
> bool IsMovable() const;
> bool IsDestroyOnClose() const;
> bool IsMaximized() const;
> bool HasCaption() const;
> bool HasGripper() const;
> bool HasBorder() const;
> bool HasCloseButton() const;
> bool HasMaximizeButton() const;
> bool HasMinimizeButton() const;
> bool HasPinButton() const;
> bool HasGripperTop() const;
> wxAuiPaneInfo& Window(wxWindow* w);
> wxAuiPaneInfo& Name(const wxString& n);
> wxAuiPaneInfo& Caption(const wxString& c);
> wxAuiPaneInfo& Left();
> wxAuiPaneInfo& Right();
> wxAuiPaneInfo& Top();
> wxAuiPaneInfo& Bottom();
> wxAuiPaneInfo& Center();
> wxAuiPaneInfo& Centre();
> wxAuiPaneInfo& Direction(int direction);
> wxAuiPaneInfo& Layer(int layer);
> wxAuiPaneInfo& Row(int row);
> wxAuiPaneInfo& Position(int pos);
> wxAuiPaneInfo& BestSize(const wxSize& size);
> wxAuiPaneInfo& MinSize(const wxSize& size);
> wxAuiPaneInfo& MaxSize(const wxSize& size);
> wxAuiPaneInfo& BestSize(int x, int y);
> wxAuiPaneInfo& MinSize(int x, int y);
> wxAuiPaneInfo& MaxSize(int x, int y);
> wxAuiPaneInfo& FloatingPosition(const wxPoint& pos);
> wxAuiPaneInfo& FloatingPosition(int x, int y);
> wxAuiPaneInfo& FloatingSize(const wxSize& size);
> wxAuiPaneInfo& FloatingSize(int x, int y);
> wxAuiPaneInfo& Fixed();
> wxAuiPaneInfo& Resizable(bool resizable = true);
> wxAuiPaneInfo& Dock();
> wxAuiPaneInfo& Float();
> wxAuiPaneInfo& Hide();
> wxAuiPaneInfo& Show(bool show = true);
> wxAuiPaneInfo& CaptionVisible(bool visible = true);
> wxAuiPaneInfo& Maximize();
> wxAuiPaneInfo& Restore();
> wxAuiPaneInfo& PaneBorder(bool visible = true);
> wxAuiPaneInfo& Gripper(bool visible = true);
> wxAuiPaneInfo& GripperTop(bool attop = true);
> wxAuiPaneInfo& CloseButton(bool visible = true);
> wxAuiPaneInfo& MaximizeButton(bool visible = true);
> wxAuiPaneInfo& MinimizeButton(bool visible = true);
> wxAuiPaneInfo& PinButton(bool visible = true);
> wxAuiPaneInfo& DestroyOnClose(bool b = true);
> wxAuiPaneInfo& TopDockable(bool b = true);
> wxAuiPaneInfo& BottomDockable(bool b = true);
> wxAuiPaneInfo& LeftDockable(bool b = true);
> wxAuiPaneInfo& RightDockable(bool b = true);
> wxAuiPaneInfo& Floatable(bool b = true);
> wxAuiPaneInfo& Movable(bool b = true);
> wxAuiPaneInfo& Dockable(bool b = true);
> wxAuiPaneInfo& DefaultPane();
> wxAuiPaneInfo& CentrePane();
> wxAuiPaneInfo& CenterPane();
> wxAuiPaneInfo& ToolbarPane();
> wxAuiPaneInfo& SetFlag(unsigned int flag, bool option_state);
> bool HasFlag(unsigned int flag) const;
> wxString name; // name of the pane
> wxString caption; // caption displayed on the window
> wxWindow* window; // window that is in this pane
> wxFrame* frame; // floating frame window that holds the pane
> unsigned int state; // a combination of wxPaneState values
> int dock_direction; // dock direction (top, bottom, left, right, center );
> int dock_layer; // layer number (0 = innermost layer );
> int dock_row; // row number on the docking bar (0 = first row );
> int dock_pos; // position inside the row (0 = first position );
> wxSize best_size; // size that the layout engine will prefer
> wxSize min_size; // minimum size the pane window can tolerate
> wxSize max_size; // maximum size the pane window can tolerate
> wxPoint floating_pos; // position while floating
> wxSize floating_size; // size while floating
> int dock_proportion; // proportion while docked
> //wxAuiPaneButtonArray buttons; // buttons on the pane
> wxRect rect; // current rectangle (populated by wxAUI );

};
// ---------------------------------------------------------------------------
// wxAuiPaneInfoArray
class %delete wxAuiPaneInfoArray
{

> wxAuiPaneInfoArray();
> wxAuiPaneInfoArray(const wxAuiPaneInfoArray& array);
> void Add(wxAuiPaneInfo pi);
> void Clear();
> int GetCount() const;
> //int Index(wxAuiPaneInfo* page);
> void Insert(wxAuiPaneInfo pi, int nIndex);
> bool IsEmpty();
> wxAuiPaneInfo Item(size_t nIndex) const;
> void RemoveAt(size_t nIndex);

};
// ---------------------------------------------------------------------------
// wxAuiManager
class %delete wxAuiManager : public wxEvtHandler
{

> wxAuiManager(wxWindow* managed_wnd = NULL, unsigned int flags = wxAUI_MGR_DEFAULT);
> void UnInit();
> void SetFlags(unsigned int flags);
> unsigned int GetFlags() const;
> void SetManagedWindow(wxWindow* managed_wnd);
> wxWindow* GetManagedWindow() const;
> static wxAuiManager* GetManager(wxWindow* window);
> void SetArtProvider(%ungc wxAuiDockArt* art_provider);
> wxAuiDockArt* GetArtProvider() const;
> wxAuiPaneInfo& GetPane(wxWindow* window);
> wxAuiPaneInfo& GetPane(const wxString& name);
> wxAuiPaneInfoArray& GetAllPanes();
> bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info);
> bool AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info, const wxPoint& drop_pos);
> bool AddPane(wxWindow* window, int direction = wxLEFT, const wxString& caption = wxEmptyString);
> bool InsertPane(wxWindow* window, const wxAuiPaneInfo& insert_location, int insert_level = wxAUI_INSERT_PANE);
> bool DetachPane(wxWindow* window);
> void Update();
> wxString SavePaneInfo(wxAuiPaneInfo& pane);
> void LoadPaneInfo(wxString pane_part, wxAuiPaneInfo &pane);
> wxString SavePerspective();
> bool LoadPerspective(const wxString& perspective, bool update = true);
> void SetDockSizeConstraint(double width_pct, double height_pct);
> void GetDockSizeConstraint(double* width_pct, double* height_pct) const;
> void ClosePane(wxAuiPaneInfo& pane_info);
> void MaximizePane(wxAuiPaneInfo& pane_info);
> void RestorePane(wxAuiPaneInfo& pane_info);
> void RestoreMaximizedPane();
> virtual wxAuiFloatingFrame* CreateFloatingFrame(wxWindow* parent, const wxAuiPaneInfo& p);
> void StartPaneDrag( wxWindow* pane_window, const wxPoint& offset);
> wxRect CalculateHintRect( wxWindow* pane_window, const wxPoint& pt, const wxPoint& offset);
> void DrawHintRect( wxWindow* pane_window, const wxPoint& pt, const wxPoint& offset);
> virtual void ShowHint(const wxRect& rect);
> virtual void HideHint();
> // public events (which can be invoked externally );
> void OnRender(wxAuiManagerEvent& evt);
> void OnPaneButton(wxAuiManagerEvent& evt);

};
// ---------------------------------------------------------------------------
// wxAuiManagerEvent
class %delete wxAuiManagerEvent : public wxEvent
{

> %wxEventType wxEVT_AUI_PANE_BUTTON // EVT_AUI_PANE_BUTTON(func );
> %wxEventType wxEVT_AUI_PANE_CLOSE // EVT_AUI_PANE_CLOSE(func );
> %wxEventType wxEVT_AUI_PANE_MAXIMIZE // EVT_AUI_PANE_MAXIMIZE(func );
> %wxEventType wxEVT_AUI_PANE_RESTORE // EVT_AUI_PANE_RESTORE(func );
> %wxEventType wxEVT_AUI_RENDER // EVT_AUI_RENDER(func );
> %wxEventType wxEVT_AUI_FIND_MANAGER // EVT_AUI_FIND_MANAGER(func );
> wxAuiManagerEvent(wxEventType type=wxEVT_NULL);
> wxAuiManagerEvent(const wxAuiManagerEvent& c);
> void SetManager(wxAuiManager* mgr);
> void SetPane(wxAuiPaneInfo* p);
> void SetButton(int b);
> void SetDC(wxDC* pdc);
> wxAuiManager* GetManager() const;
> wxAuiPaneInfo* GetPane() const;
> int GetButton() const;
> wxDC* GetDC() const;
> void Veto(bool veto = true);
> bool GetVeto() const;
> void SetCanVeto(bool can_veto);
> bool CanVeto() const;

};
// ---------------------------------------------------------------------------
// wxAuiDockInfo
class %delete wxAuiDockInfo
{

> #define_object wxAuiNullDockInfo
> wxAuiDockInfo();
> wxAuiDockInfo(const wxAuiDockInfo& c);
> wxAuiDockInfo& operator=(const wxAuiDockInfo& c);
> bool IsOk() const;
> bool IsHorizontal() const;
> bool IsVertical() const;
> //wxAuiPaneInfoPtrArray panes; // array of panes - FIXME
> wxRect rect; // current rectangle
> int dock_direction; // dock direction (top, bottom, left, right, center );
> int dock_layer; // layer number (0 = innermost layer );
> int dock_row; // row number on the docking bar (0 = first row );
> int size; // size of the dock
> int min_size; // minimum size of a dock (0 if there is no min );
> bool resizable; // flag indicating whether the dock is resizable
> bool toolbar; // flag indicating dock contains only toolbars
> bool fixed; // flag indicating that the dock operates on
> // absolute coordinates as opposed to proportional
> bool reserved1;

};
// ---------------------------------------------------------------------------
// wxAuiDockUIPart
enum wxAuiDockUIPart::dummy
{

> typeCaption,
> typeGripper,
> typeDock,
> typeDockSizer,
> typePane,
> typePaneSizer,
> typeBackground,
> typePaneBorder,
> typePaneButton

};
class %delete wxAuiDockUIPart
{

> int type; // ui part type (see enum above );
> int orientation; // orientation (either wxHORIZONTAL or wxVERTICAL );
> wxAuiDockInfo* dock; // which dock the item is associated with
> wxAuiPaneInfo* pane; // which pane the item is associated with
> wxAuiPaneButton* button; // which pane button the item is associated with
> wxSizer* cont_sizer; // the part's containing sizer
> wxSizerItem* sizer_item; // the sizer item of the part
> wxRect rect; // client coord rectangle of the part itself

};
// ---------------------------------------------------------------------------
// wxAuiPaneButton
class %delete wxAuiPaneButton
{

> int button_id; // id of the button (e.g. buttonClose );

};
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//#include "wx/aui/tabmdi.h"
//-----------------------------------------------------------------------------
// wxAuiMDIParentFrame
//-----------------------------------------------------------------------------
class wxAuiMDIParentFrame : public wxFrame
{

> wxAuiMDIParentFrame();
> wxAuiMDIParentFrame(wxWindow *parent, wxWindowID winid, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL, const wxString& name = "wxAuiMDIParentFrame");
> bool Create(wxWindow *parent, wxWindowID winid, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,const wxString& name = "wxAuiMDIParentFrame" );
> void SetArtProvider(%ungc wxAuiTabArt* provider);
> wxAuiTabArt* GetArtProvider();
> wxAuiNotebook* GetNotebook() const;
> wxMenu* GetWindowMenu() const;
> void SetWindowMenu(wxMenu* pMenu);
> virtual void SetMenuBar(wxMenuBar *pMenuBar);
> void SetChildMenuBar(wxAuiMDIChildFrame *pChild);
> !%wxchkver_2_9_2 virtual bool ProcessEvent(wxEvent& event);
> wxAuiMDIChildFrame *GetActiveChild() const;
> void SetActiveChild(wxAuiMDIChildFrame* pChildFrame);
> wxAuiMDIClientWindow *GetClientWindow() const;
> virtual wxAuiMDIClientWindow *OnCreateClient();
> virtual void Cascade(); //{ /* Has no effect */ }
> virtual void Tile(wxOrientation orient = wxHORIZONTAL);
> virtual void ArrangeIcons(); //{ /* Has no effect */ }
> virtual void ActivateNext();
> virtual void ActivatePrevious();

};
//-----------------------------------------------------------------------------
// wxAuiMDIChildFrame
//-----------------------------------------------------------------------------
class wxAuiMDIChildFrame : public wxPanel
{

> wxAuiMDIChildFrame();
> wxAuiMDIChildFrame(wxAuiMDIParentFrame *parent, wxWindowID winid, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxAuiMDIChildFrame");
> bool Create(wxAuiMDIParentFrame *parent, wxWindowID winid, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "wxAuiMDIChildFrame");
> virtual void SetMenuBar(wxMenuBar *menu_bar);
> virtual wxMenuBar *GetMenuBar() const;
> virtual void SetTitle(const wxString& title);
> virtual wxString GetTitle() const;
> virtual void SetIcons(const wxIconBundle& icons);
> virtual const wxIconBundle& GetIcons() const;
> virtual void SetIcon(const wxIcon& icon);
> virtual const wxIcon& GetIcon() const;
> virtual void Activate();
> virtual bool Destroy();
> #if wxUSE_STATUSBAR
> // no status bars
> //virtual wxStatusBar* CreateStatusBar(int number = 1, long style = 1, wxWindowID winid = 1, const wxString& name = ""); // FIXME
> //virtual wxStatusBar *GetStatusBar() const;
> //virtual void SetStatusText( const wxString &WXUNUSED(text), int WXUNUSED(number)=0 );
> //virtual void SetStatusWidths( int WXUNUSED(n), const int WXUNUSED(widths_field)[] );
> #endif //wxUSE_STATUSBAR
> // no size hints
> //virtual void DoSetSizeHints(int WXUNUSED(minW), int WXUNUSED(minH), int WXUNUSED(maxW) = wxDefaultCoord, int WXUNUSED(maxH) = wxDefaultCoord, int WXUNUSED(incW) = wxDefaultCoord, int WXUNUSED(incH) = wxDefaultCoord) {} - FIXME
> #if wxUSE_TOOLBAR
> // no toolbar bars
> //virtual wxToolBar* CreateToolBar(long WXUNUSED(style), wxWindowID WXUNUSED(winid), const wxString& WXUNUSED(name));
> //virtual wxToolBar *GetToolBar() const;
> #endif //wxUSE_TOOLBAR
> // no maximize etc
> //virtual void Maximize(bool WXUNUSED(maximize) = true) { /* Has no effect */ }
> //virtual void Restore() { /* Has no effect */ }
> //virtual void Iconize(bool WXUNUSED(iconize) = true) { /* Has no effect */ }
> //virtual bool IsMaximized() const;
> //virtual bool IsIconized() const;
> //virtual bool ShowFullScreen(bool WXUNUSED(show), long WXUNUSED(style));
> //virtual bool IsFullScreen() const;
> //virtual bool IsTopLevel() const;
> //void OnMenuHighlight(wxMenuEvent& evt);
> //void OnActivate(wxActivateEvent& evt);
> //void OnCloseWindow(wxCloseEvent& evt);
> void SetMDIParentFrame(wxAuiMDIParentFrame* parent);
> wxAuiMDIParentFrame* GetMDIParentFrame() const;
> // This function needs to be called when a size change is confirmed,
> // we needed this function to prevent anybody from the outside
> // changing the panel... it messes the UI layout when we would allow it.
> void ApplyMDIChildFrameRect();
> void DoShow(bool show);

};
//-----------------------------------------------------------------------------
// wxAuiMDIClientWindow
//-----------------------------------------------------------------------------
class wxAuiMDIClientWindow : public wxAuiNotebook
{

> wxAuiMDIClientWindow();
> wxAuiMDIClientWindow(wxAuiMDIParentFrame *parent, long style = 0);
> virtual bool CreateClient(wxAuiMDIParentFrame *parent, long style = wxVSCROLL | wxHSCROLL);
> virtual int SetSelection(size_t page);

};
#endif // wxLUA_USE_wxAUI && %wxchkver_2_8 && wxUSE_AUI

## wxwidgets/wxhtml_html.i - Lua table = 'wxhtml'

// ===========================================================================
// Purpose: wxHtml library
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#if wxLUA_USE_wxHTML && wxUSE_HTML
// ---------------------------------------------------------------------------
// wxHtmlCell
#include "wx/html/htmlcell.h"
#define wxHTML_COND_ISANCHOR
#define wxHTML_COND_ISIMAGEMAP
#define wxHTML_COND_USER
class %delete wxHtmlCell : public wxObject
{

> wxHtmlCell( );
> // %override [bool, int pagebreak] wxHtmlCell::AdjustPagebreak(int pagebreak );
> // %override bool AdjustPagebreak(int pagebreak); // int* known_pagebreaks, int number_of_pages );
> // C++ Func: bool AdjustPagebreak(int pagebreak, int* known_pagebreaks, int number_of_pages );
> %not_overload !%wxchkver_2_8 virtual bool AdjustPagebreak(int pagebreak); // int* known_pagebreaks, int number_of_pages );
> // %override bool AdjustPagebreak(int pagebreak, wxArrayInt& known_pagebreaks );
> // C++ Func: bool AdjustPagebreak(int pagebreak, wxArrayInt& known_pagebreaks );
> %not_overload %wxchkver_2_8 & !%wxchkver_2_9_4 virtual bool AdjustPagebreak(int pagebreak, wxArrayInt& known_pagebreaks );
> // %override bool AdjustPagebreak(int pagebreak, wxArrayInt& known_pagebreaks, int pageHeight );
> // C++ Func: bool AdjustPagebreak(int pagebreak, wxArrayInt& known_pagebreaks, int pageHeight );
> %not_overload %wxchkver_2_9_4 virtual bool AdjustPagebreak(int pagebreak, wxArrayInt& known_pagebreaks, int pageHeight );
> //virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, wxHtmlRenderingInfo& info );
> //virtual void DrawInvisible(wxDC& dc, int x, int y, wxHtmlRenderingInfo& info );
> // %override wxHtmlCell* wxHtmlCell::Find(int condition, [none, string, or int] );
> // C++ Func: virtual const wxHtmlCell* Find(int condition, void *param = 0 );
> virtual const wxHtmlCell* Find(int condition, void *param = 0 );
> int GetDescent() const;
> wxHtmlCell* GetFirstChild( );
> int GetHeight() const;
> virtual wxString GetId() const;
> virtual wxHtmlLinkInfo* GetLink(int x = 0, int y = 0) const;
> wxHtmlCell* GetNext() const;
> wxHtmlContainerCell* GetParent() const;
> int GetPosX() const;
> int GetPosY() const;
> int GetWidth() const;
> virtual void Layout(int w );
> //virtual void OnMouseClick(wxWindow* parent, int x, int y, const wxMouseEvent& event );
> void SetId(const wxString& id );
> void SetLink(const wxHtmlLinkInfo& link );
> void SetNext(wxHtmlCell *cell );
> void SetParent(wxHtmlContainerCell *p );
> void SetPos(int x, int y );

};
// ---------------------------------------------------------------------------
// wxHtmlWidgetCell
#include "wx/html/htmlcell.h"
class wxHtmlWidgetCell : public wxHtmlCell
{

> wxHtmlWidgetCell(wxWindow* wnd, int w = 0 );

};
// ---------------------------------------------------------------------------
// wxHtmlContainerCell
#include "wx/html/htmlcell.h"
#define wxHTML_UNITS_PIXELS
#define wxHTML_UNITS_PERCENT
#define wxHTML_INDENT_TOP
#define wxHTML_INDENT_BOTTOM
#define wxHTML_INDENT_LEFT
#define wxHTML_INDENT_RIGHT
#define wxHTML_INDENT_HORIZONTAL
#define wxHTML_INDENT_VERTICAL
#define wxHTML_INDENT_ALL
#define wxHTML_ALIGN_LEFT
#define wxHTML_ALIGN_JUSTIFY
#define wxHTML_ALIGN_CENTER
#define wxHTML_ALIGN_RIGHT
#define wxHTML_ALIGN_BOTTOM
#define wxHTML_ALIGN_TOP
class wxHtmlContainerCell : public wxHtmlCell
{

> wxHtmlContainerCell(wxHtmlContainerCell *parent );
> int GetAlignHor() const;
> int GetAlignVer() const;
> wxColour GetBackgroundColour( );
> int GetIndent(int ind) const;
> int GetIndentUnits(int ind) const;
> void InsertCell(wxHtmlCell *cell );
> void SetAlign(const wxHtmlTag& tag );
> void SetAlignHor(int al );
> void SetAlignVer(int al );
> void SetBackgroundColour(const wxColour& clr );
> void SetBorder(const wxColour& clr1, const wxColour& clr2 );
> void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS );
> void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP );
> void SetWidthFloat(int w, int units );
> void SetWidthFloat(const wxHtmlTag& tag, double pixel_scale = 1.0 );
> // %wxchkver_2_6 wxHtmlCell* GetFirstChild() see wxHtmlCell
> // !%wxchkver_2_6 wxHtmlCell* GetFirstCell() - nobody probably uses this

};
// ---------------------------------------------------------------------------
// wxHtmlColourCell
#if %wxchkver_2_8
#include "wx/html/htmlcell.h"
class wxHtmlColourCell : public wxHtmlCell
{

> wxHtmlColourCell(const wxColour& clr, int flags = wxHTML_CLR_FOREGROUND );
> //virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, wxHtmlRenderingInfo& info);
> //virtual void DrawInvisible(wxDC& dc, int x, int y, wxHtmlRenderingInfo& info);

};
#endif // %wxchkver_2_8
// ---------------------------------------------------------------------------
// wxHtmlFontCell
#if %wxchkver_2_8
#include "wx/html/htmlcell.h"
class wxHtmlFontCell : public wxHtmlCell
{

> wxHtmlFontCell(wxFont *font );
> //virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, wxHtmlRenderingInfo& info);
> //virtual void DrawInvisible(wxDC& dc, int x, int y, wxHtmlRenderingInfo& info);

};
#endif // %wxchkver_2_8
// ---------------------------------------------------------------------------
// wxHtmlCellEvent
#if %wxchkver_2_8
#include "wx/html/htmlwin.h"
class %delete wxHtmlCellEvent : public wxCommandEvent
{

> wxHtmlCellEvent( );
> wxHtmlCellEvent(wxEventType commandType, int id, wxHtmlCell *cell, const wxPoint &pt, const wxMouseEvent &ev );
> wxHtmlCell* GetCell() const;
> wxPoint GetPoint() const;
> wxMouseEvent GetMouseEvent() const;
> void SetLinkClicked(bool linkclicked );
> bool GetLinkClicked() const;

};
#endif // %wxchkver_2_8
// ---------------------------------------------------------------------------
// wxHtmlLinkInfo
#include "wx/html/htmlcell.h"
class %delete wxHtmlLinkInfo
{

> wxHtmlLinkInfo(const wxString& href, const wxString& target = "" );
> const wxMouseEvent * GetEvent( );
> const wxHtmlCell * GetHtmlCell( );
> wxString GetHref( );
> wxString GetTarget( );

};
// ---------------------------------------------------------------------------
// wxHtmlTag
#include "wx/html/htmltag.h"
class wxHtmlTag // !%wxchkver_2_9_2 wxObject
{

> //wxHtmlTag(const wxString& source, int pos, int end_pos, wxHtmlTagsCache* cache );
> const wxString GetAllParams() const;
> #if !%wxchkver_3_0 || WXWIN_COMPATIBILITY_2_8
> int GetBeginPos() const;
> int GetEndPos1() const;
> int GetEndPos2() const;
> #endif // !%wxchkver_3_0 || WXWIN_COMPATIBILITY_2_8
> wxString GetName() const;
> wxString GetParam(const wxString& par, bool with_commas = false) const;
> // %override [bool, wxColour] wxHtmlTag::GetParamAsColour(const wxString& par) const;
> // C++ Func: bool GetParamAsColour(const wxString& par, wxColour *clr) const;
> bool GetParamAsColour(const wxString& par) const;
> // %override [bool, int value] wxHtmlTag::GetParamAsInt(const wxString& par) const;
> // C++ Func: bool GetParamAsInt(const wxString& par, int *value) const;
> bool GetParamAsInt(const wxString& par) const;
> bool HasEnding() const;
> bool HasParam(const wxString& par) const;
> //bool IsEnding() const;
> //wxString ScanParam(const wxString& par, const wxString &format, void *value) const;

};
// ---------------------------------------------------------------------------
// wxHtmlWindow
#include "wx/wxhtml.h"
#define wxHW_SCROLLBAR_NEVER
#define wxHW_SCROLLBAR_AUTO
class wxHtmlWindow : public wxScrolledWindow
{

> wxHtmlWindow(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHW_SCROLLBAR_AUTO, const wxString& name = "wxHtmlWindow" );
> //static void AddFilter(wxHtmlFilter *filter );
> bool AppendToPage(const wxString& source );
> wxHtmlContainerCell* GetInternalRepresentation() const;
> wxString GetOpenedAnchor( );
> wxString GetOpenedPage( );
> wxString GetOpenedPageTitle( );
> wxFrame* GetRelatedFrame() const;
> bool HistoryBack( );
> bool HistoryCanBack( );
> bool HistoryCanForward( );
> void HistoryClear( );
> bool HistoryForward( );
> virtual bool LoadFile(const wxFileName& filename );
> bool LoadPage(const wxString& location );
> void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString );
> void SelectAll( );
> wxString SelectionToText( );
> void SelectLine(const wxPoint& pos );
> void SelectWord(const wxPoint& pos );
> void SetBorders(int b );
> // %override void wxHtmlWindow::SetFonts(wxString normal_face, wxString fixed_face, Lua int table );
> // C++ Func: void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes );
> void SetFonts(wxString normal_face, wxString fixed_face, LuaTable intTable );
> bool SetPage(const wxString& source );
> void SetRelatedFrame(wxFrame* frame, const wxString& format );
> void SetRelatedStatusBar(int bar );
> wxString ToText( );
> void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString );

};
// ---------------------------------------------------------------------------
// wxLuaHtmlWindow
#if wxLUA_USE_wxLuaHtmlWindow
#include "wxbind/include/wxhtml_wxlhtml.h"
class wxLuaHtmlWindow : public wxHtmlWindow
{

> wxLuaHtmlWindow(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHW_SCROLLBAR_AUTO, const wxString& name = "wxLuaHtmlWindow" );
> // The functions below are all virtual functions that you can override in Lua.
> // See the html sample and wxHtmlWindow for proper parameters and usage.
> //bool OnCellClicked(wxHtmlCell *cell, wxCoord x, wxCoord y, const wxMouseEvent& event );
> //void OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y );
> //void OnLinkClicked(const wxHtmlLinkInfo& link );
> //void OnSetTitle(const wxString& title );

};
// ---------------------------------------------------------------------------
// wxLuaHtmlWinTagEvent
class %delete wxLuaHtmlWinTagEvent : public wxEvent
{

> %wxEventType wxEVT_HTML_TAG_HANDLER // EVT_HTML_TAG_HANDLER(id, fn );
> const wxHtmlTag *GetHtmlTag() const;
> wxHtmlWinParser *GetHtmlParser() const;
> void SetParseInnerCalled(bool fParseInnerCalled = true );
> bool GetParseInnerCalled() const;

};
#endif //wxLUA_USE_wxLuaHtmlWindow
// ---------------------------------------------------------------------------
// wxHtmlParser
//enum wxHtmlURLType
//{
// wxHTML_URL_PAGE,
// wxHTML_URL_IMAGE,
// wxHTML_URL_OTHER
//};
class wxHtmlParser : public wxObject
{

> //wxHtmlParser( );
> //void AddTag(const wxHtmlTag& tag );
> //void AddTagHandler(wxHtmlTagHandler *handler );
> //void AddWord(const wxString &txt) - not in 2.6?
> %wxchkver_2_9_2 void DoParsing(const wxString::const_iterator& begin_pos, const wxString::const_iterator& end_pos );
> !%wxchkver_2_9_2 void DoParsing(int begin_pos, int end_pos );
> void DoParsing( );
> virtual void DoneParser( );
> //virtual wxObject* GetProduct( );
> //wxString* GetSource( );
> void InitParser(const wxString& source );
> //virtual wxFSFile* OpenURL(wxHtmlURLType type, const wxString& url );
> //wxObject* Parse(const wxString& source );
> //void PushTagHandler(wxHtmlTagHandler* handler, wxString tags );
> //void PopTagHandler( );
> //void SetFS(wxFileSystem *fs );
> //void StopParsing( );

};
// ---------------------------------------------------------------------------
// wxHtmlWinParser
class wxHtmlWinParser : public wxHtmlParser
{

> wxHtmlWinParser(wxHtmlWindow *wnd );
> wxHtmlContainerCell* CloseContainer( );
> wxFont* CreateCurrentFont( );
> wxColour GetActualColor() const;
> int GetAlign() const;
> int GetCharHeight() const;
> int GetCharWidth() const;
> wxHtmlContainerCell* GetContainer() const;
> wxDC* GetDC( );
> //wxEncodingConverter * GetEncodingConverter() const;
> int GetFontBold() const;
> wxString GetFontFace() const;
> int GetFontFixed() const;
> int GetFontItalic() const;
> int GetFontSize() const;
> int GetFontUnderlined() const;
> //wxFontEncoding GetInputEncoding() const;
> const wxHtmlLinkInfo& GetLink() const;
> wxColour GetLinkColor() const;
> //wxFontEncoding GetOutputEncoding() const;
> %wxchkver_2_8 wxHtmlWindowInterface *GetWindowInterface( );
> !%wxchkver_2_8 wxWindow* GetWindow( );
> wxHtmlContainerCell* OpenContainer( );
> void SetActualColor(const wxColour& clr );
> void SetAlign(int a );
> wxHtmlContainerCell* SetContainer(wxHtmlContainerCell *c );
> void SetDC(wxDC *dc, double pixel_scale = 1.0 );
> void SetFontBold(int x );
> void SetFontFace(const wxString& face );
> void SetFontFixed(int x );
> void SetFontItalic(int x );
> void SetFontSize(int s );
> void SetFontUnderlined(int x );
> // %override void wxHtmlWinParser::SetFonts(wxString normal_face, wxString fixed_face, Lua int table );
> // C++ Func: void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes );
> void SetFonts(wxString normal_face, wxString fixed_face, LuaTable intTable );
> void SetLink(const wxHtmlLinkInfo& link );
> void SetLinkColor(const wxColour& clr );

};
// ---------------------------------------------------------------------------
// wxHtmlWindowInterface
#if %wxchkver_2_8
enum wxHtmlWindowInterface::HTMLCursor
{

> HTMLCursor_Default,
> HTMLCursor_Link,
> HTMLCursor_Text

};
class wxHtmlWindowInterface
{

> virtual void SetHTMLWindowTitle(const wxString& title );
> virtual void OnHTMLLinkClicked(const wxHtmlLinkInfo& link );
> //virtual wxHtmlOpeningStatus OnHTMLOpeningURL(wxHtmlURLType type, const wxString& url, wxString *redirect) const;
> virtual wxPoint HTMLCoordsToWindow(wxHtmlCell *cell, const wxPoint& pos) const;
> virtual wxWindow* GetHTMLWindow( );
> virtual wxColour GetHTMLBackgroundColour() const;
> virtual void SetHTMLBackgroundColour(const wxColour& clr );
> virtual void SetHTMLBackgroundImage(const wxBitmap& bmpBg );
> virtual void SetHTMLStatusText(const wxString& text );
> virtual wxCursor GetHTMLCursor(wxHtmlWindowInterface::HTMLCursor type) const;

};
// ----------------------------------------------------------------------------
// wxSimpleHtmlListBox - Use this instead of having to override virtual functions in wxHtmlListBox
#include "wx/htmllbox.h"
#define wxHLB_DEFAULT_STYLE
#define wxHLB_MULTIPLE
class wxSimpleHtmlListBox : public wxPanel, public wxHtmlWindowInterface //: public wxHtmlListBox, public wxItemContainer
{

> wxSimpleHtmlListBox( );
> wxSimpleHtmlListBox(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, const wxArrayString& choices, long style = wxHLB_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxSimpleHtmlListBox" );
> bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, const wxArrayString& choices, long style = wxHLB_DEFAULT_STYLE, const wxValidator& validator = wxDefaultValidator, const wxString& name = "wxSimpleHtmlListBox" );
> void SetSelection(int n );
> int GetSelection() const;
> virtual unsigned int GetCount() const;
> virtual wxString GetString(unsigned int n) const;
> wxArrayString GetStrings() const;
> virtual void SetString(unsigned int n, const wxString& s );
> virtual void Clear( );
> virtual void Delete(unsigned int n );
> void Append(const wxArrayString& strings );
> int Append(const wxString& item );
> int Append(const wxString& item, voidptr_long number); // C++ is (void *clientData) You can put a number here
> int Append(const wxString& item, wxClientData *clientData );

};
#endif //%wxchkver_2_8
// ---------------------------------------------------------------------------
// wxHtmlDCRenderer
#include "wx/html/htmprint.h"
class %delete wxHtmlDCRenderer : public wxObject
{

> wxHtmlDCRenderer( );
> void SetDC(wxDC* dc, double pixel_scale = 1.0 );
> //void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes = NULL );
> void SetSize(int width, int height );
> void SetHtmlText(const wxString& html, const wxString& basepath = "", bool isdir = true );
> !%wxchkver_2_8 int Render(int x, int y, int from = 0, int dont_render = false); //, int *known_pagebreaks = NULL, int number_of_pages = 0 );
> %wxchkver_2_8 int Render(int x, int y, wxArrayInt& known_pagebreaks, int from = 0, int dont_render = false, int to = INT_MAX);
> int GetTotalHeight( );

};
// ---------------------------------------------------------------------------
// wxHtmlEasyPrinting
#include "wx/html/htmprint.h"
class %delete wxHtmlEasyPrinting : public wxObject
{

> wxHtmlEasyPrinting(const wxString& name = "Printing", wxFrame* parent_frame = NULL );
> bool PreviewFile(const wxString& htmlfile );
> bool PreviewText(const wxString& htmltext, const wxString& basepath = "" );
> bool PrintFile(const wxString& htmlfile );
> bool PrintText(const wxString& htmltext, const wxString& basepath = "" );
> %wxchkver_2_4&!%wxchkver_2_6 void PrinterSetup( );
> void PageSetup( );
> //void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes = NULL );
> void SetHeader(const wxString& header, int pg = wxPAGE_ALL );
> void SetFooter(const wxString& footer, int pg = wxPAGE_ALL );
> wxPrintData* GetPrintData( );
> wxPageSetupDialogData* GetPageSetupData( );

};
// ---------------------------------------------------------------------------
// wxHtmlPrintout
#include "wx/html/htmprint.h"
class %delete wxHtmlPrintout : public wxPrintout
{

> wxHtmlPrintout(const wxString& title = "Printout" );
> //void SetFonts(wxString normal_face, wxString fixed_face, const int *sizes = NULL );
> void SetFooter(const wxString& footer, int pg = wxPAGE_ALL );
> void SetHeader(const wxString& header, int pg = wxPAGE_ALL );
> void SetHtmlFile(const wxString& htmlfile );
> void SetHtmlText(const wxString& html, const wxString& basepath = "", bool isdir = true );
> void SetMargins(float top = 25.2, float bottom = 25.2, float left = 25.2, float right = 25.2, float spaces = 5 );

};
// ---------------------------------------------------------------------------
// wxHtmlHelpData
#if wxLUA_USE_wxHtmlHelpController && wxUSE_WXHTML_HELP
//#if !%wxchkver_2_6|%wxcompat_2_4
//struct wxHtmlContentsItem
//{
// // needs access functions
//};
//#endif
#include "wx/html/helpdata.h"
//class %delete wxHtmlBookRecord
//{
// wxHtmlBookRecord(const wxString& bookfile, const wxString& basepath, const wxString& title, const wxString& start );
//
// wxString GetBookFile() const;
// wxString GetTitle() const;
// wxString GetStart() const;
// wxString GetBasePath() const;
// void SetContentsRange(int start, int end );
// int GetContentsStart() const;
// int GetContentsEnd() const;
//
// void SetTitle(const wxString& title );
// void SetBasePath(const wxString& path );
// void SetStart(const wxString& start );
// wxString GetFullPath(const wxString &page) const;
//};
//
//class %delete wxHtmlBookRecArray
//{
// wxHtmlBookRecArray( );
//
// size_t Add(const wxHtmlBookRecord& book, size_t copies = 1 );
// void Clear( );
// int GetCount() const;
// void Insert(const wxHtmlBookRecord& book, int nIndex, size_t copies = 1 );
// wxHtmlBookRecord Item(size_t nIndex) const;
// void Remove(const wxString &sz );
// void RemoveAt(size_t nIndex, size_t count = 1 );
//};
class %delete wxHtmlHelpData : public wxObject
{

> wxHtmlHelpData( );
> bool AddBook(const wxString& book );
> wxString FindPageById(int id );
> wxString FindPageByName(const wxString& page );
> //wxHtmlBookRecArray GetBookRecArray( );
> //wxHtmlHelpDataItems GetContentsArray( );
> //wxHtmlHelpDataItems GetIndexArray( );
> void SetTempDir(const wxString& path );
> // rem these out to get rid of deprecated warnings
> //!%wxchkver_2_6|%wxcompat_2_4 wxHtmlContentsItem* GetContents( );
> //!%wxchkver_2_6|%wxcompat_2_4 int GetContentsCnt( );
> //!%wxchkver_2_6|%wxcompat_2_4 wxHtmlContentsItem* GetIndex( );
> //!%wxchkver_2_6|%wxcompat_2_4 int GetIndexCnt( );

};
// ---------------------------------------------------------------------------
// wxHtmlHelpController
#include "wx/html/helpctrl.h"
#define wxHF_TOOLBAR
#define wxHF_FLAT_TOOLBAR
#define wxHF_CONTENTS
#define wxHF_INDEX
#define wxHF_SEARCH
#define wxHF_BOOKMARKS
#define wxHF_OPEN_FILES
#define wxHF_PRINT
#define wxHF_MERGE_BOOKS
#define wxHF_ICONS_BOOK
#define wxHF_ICONS_FOLDER
#define wxHF_ICONS_BOOK_CHAPTER
#define wxHF_DEFAULT_STYLE
class %delete wxHtmlHelpController : public wxHelpControllerBase
{

> wxHtmlHelpController(int style = wxHF_DEFAULT_STYLE );
> bool AddBook(const wxString& book, bool show_wait_msg );
> bool AddBook(const wxFileName& book_file, bool show_wait_msg );
> //virtual wxHtmlHelpFrame* CreateHelpFrame(wxHtmlHelpData * data );
> void Display(const wxString& x );
> void Display(const int id );
> //void DisplayContents() - see wxHelpControllerBase
> void DisplayIndex( );
> // bool KeywordSearch(const wxString& keyword, wxHelpSearchMode mode = wxHELP_SEARCH_ALL); // see base
> void ReadCustomization(wxConfigBase* cfg, wxString path = "" );
> void SetTempDir(const wxString& path );
> void SetTitleFormat(const wxString& format );
> void UseConfig(wxConfigBase* config, const wxString& rootpath = "" );
> void WriteCustomization(wxConfigBase* cfg, wxString path = "" );

};
#endif //wxLUA_USE_wxHtmlHelpController && wxUSE_WXHTML_HELP
#endif //wxLUA_USE_wxHTML && wxUSE_HTML

## wxwidgets/wxstc_stc.i - Lua table = 'wxstc'

// ===========================================================================
// Purpose: wxStyledTextCtrl library
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.12
// ===========================================================================
// NOTE: This file is mostly copied from wxWidget's stc.h header
// to make updating it easier, the comments help diff follow along better.
#include "wx/stc/stc.h"
//----------------------------------------------------------------------
// STC constants generated section {{{
#define wxSTC_INVALID_POSITION
// Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages
// as many EM_ messages can be used although that use is deprecated.
#define wxSTC_START
#define wxSTC_OPTIONAL_START
#define wxSTC_LEXER_START
#define wxSTC_WS_INVISIBLE
#define wxSTC_WS_VISIBLEALWAYS
#define wxSTC_WS_VISIBLEAFTERINDENT
#define wxSTC_EOL_CRLF
#define wxSTC_EOL_CR
#define wxSTC_EOL_LF
// The SC_CP_UTF8 value can be used to enter Unicode mode.
// This is the same value as CP_UTF8 in Windows
#define wxSTC_CP_UTF8
// The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+.
// #define wxSTC_CP_DBCS - removed in 2.9.5
#define wxSTC_MARKER_MAX
#define wxSTC_MARK_CIRCLE
#define wxSTC_MARK_ROUNDRECT
#define wxSTC_MARK_ARROW
#define wxSTC_MARK_SMALLRECT
#define wxSTC_MARK_SHORTARROW
#define wxSTC_MARK_EMPTY
#define wxSTC_MARK_ARROWDOWN
#define wxSTC_MARK_MINUS
#define wxSTC_MARK_PLUS
// Shapes used for outlining column.
#define wxSTC_MARK_VLINE
#define wxSTC_MARK_LCORNER
#define wxSTC_MARK_TCORNER
#define wxSTC_MARK_BOXPLUS
#define wxSTC_MARK_BOXPLUSCONNECTED
#define wxSTC_MARK_BOXMINUS
#define wxSTC_MARK_BOXMINUSCONNECTED
#define wxSTC_MARK_LCORNERCURVE
#define wxSTC_MARK_TCORNERCURVE
#define wxSTC_MARK_CIRCLEPLUS
#define wxSTC_MARK_CIRCLEPLUSCONNECTED
#define wxSTC_MARK_CIRCLEMINUS
#define wxSTC_MARK_CIRCLEMINUSCONNECTED
// Invisible mark that only sets the line background color.
#define wxSTC_MARK_BACKGROUND
#define wxSTC_MARK_DOTDOTDOT
#define wxSTC_MARK_ARROWS
#define wxSTC_MARK_PIXMAP
#define wxSTC_MARK_FULLRECT
#if %wxchkver_2_9_2
#define wxSTC_MARK_LEFTRECT
#define wxSTC_MARK_AVAILABLE
#define wxSTC_MARK_UNDERLINE
#endif //%wxchkver_2_9_2
%wxchkver_2_9_5 #define wxSTC_MARK_RGBAIMAGE
#define wxSTC_MARK_CHARACTER
// Markers used for outlining column.
#define wxSTC_MARKNUM_FOLDEREND
#define wxSTC_MARKNUM_FOLDEROPENMID
#define wxSTC_MARKNUM_FOLDERMIDTAIL
#define wxSTC_MARKNUM_FOLDERTAIL
#define wxSTC_MARKNUM_FOLDERSUB
#define wxSTC_MARKNUM_FOLDER
#define wxSTC_MARKNUM_FOLDEROPEN
#define wxSTC_MASK_FOLDERS
#define wxSTC_MARGIN_SYMBOL
#define wxSTC_MARGIN_NUMBER
%wxchkver_2_8_12 #define wxSTC_MARGIN_BACK
%wxchkver_2_8_12 #define wxSTC_MARGIN_FORE
%wxchkver_2_9_2 #define wxSTC_MARGIN_TEXT
%wxchkver_2_9_2 #define wxSTC_MARGIN_RTEXT
// Styles in range 32..37 are predefined for parts of the UI and are not used as normal styles.
// Styles 38 and 39 are for future use.
#define wxSTC_STYLE_DEFAULT
#define wxSTC_STYLE_LINENUMBER
#define wxSTC_STYLE_BRACELIGHT
#define wxSTC_STYLE_BRACEBAD
#define wxSTC_STYLE_CONTROLCHAR
#define wxSTC_STYLE_INDENTGUIDE
%wxchkver_2_8_12 #define wxSTC_STYLE_CALLTIP
#define wxSTC_STYLE_LASTPREDEFINED
#define wxSTC_STYLE_MAX
// Character set identifiers are used in StyleSetCharacterSet.
// The values are the same as the Windows *_CHARSET values.
#define wxSTC_CHARSET_ANSI
#define wxSTC_CHARSET_DEFAULT
#define wxSTC_CHARSET_BALTIC
#define wxSTC_CHARSET_CHINESEBIG5
#define wxSTC_CHARSET_EASTEUROPE
#define wxSTC_CHARSET_GB2312
#define wxSTC_CHARSET_GREEK
#define wxSTC_CHARSET_HANGUL
#define wxSTC_CHARSET_MAC
#define wxSTC_CHARSET_OEM
#define wxSTC_CHARSET_RUSSIAN
#define wxSTC_CHARSET_CYRILLIC
#define wxSTC_CHARSET_SHIFTJIS
#define wxSTC_CHARSET_SYMBOL
#define wxSTC_CHARSET_TURKISH
#define wxSTC_CHARSET_JOHAB
#define wxSTC_CHARSET_HEBREW
#define wxSTC_CHARSET_ARABIC
#define wxSTC_CHARSET_VIETNAMESE
#define wxSTC_CHARSET_THAI
#define wxSTC_CHARSET_8859_15
#define wxSTC_CASE_MIXED
#define wxSTC_CASE_UPPER
#define wxSTC_CASE_LOWER
#if %wxchkver_2_9_5
#define wxSTC_FONT_SIZE_MULTIPLIER
#define wxSTC_WEIGHT_NORMAL
#define wxSTC_WEIGHT_SEMIBOLD
#define wxSTC_WEIGHT_BOLD
#endif // %wxchkver_2_9_5
// Indicator style enumeration and some constants
#define wxSTC_INDIC_PLAIN
#define wxSTC_INDIC_SQUIGGLE
#define wxSTC_INDIC_TT
#define wxSTC_INDIC_DIAGONAL
#define wxSTC_INDIC_STRIKE
#define wxSTC_INDIC_HIDDEN
#define wxSTC_INDIC_BOX
%wxchkver_2_8_12 #define wxSTC_INDIC_ROUNDBOX
#if %wxchkver_2_9_5
#define wxSTC_INDIC_STRAIGHTBOX
#define wxSTC_INDIC_DASH
#define wxSTC_INDIC_DOTS
#define wxSTC_INDIC_SQUIGGLELOW
#define wxSTC_INDIC_DOTBOX
#define wxSTC_INDIC_MAX
#define wxSTC_INDIC_CONTAINER
#endif //%wxchkver_2_9_5
#define wxSTC_INDIC0_MASK
#define wxSTC_INDIC1_MASK
#define wxSTC_INDIC2_MASK
#define wxSTC_INDICS_MASK
#if %wxchkver_2_9_5
#define wxSTC_IV_NONE
#define wxSTC_IV_REAL
#define wxSTC_IV_LOOKFORWARD
#define wxSTC_IV_LOOKBOTH
#endif //%wxchkver_2_9_5
// PrintColourMode - use same colours as screen.
#define wxSTC_PRINT_NORMAL
// PrintColourMode - invert the light value of each style for printing.
#define wxSTC_PRINT_INVERTLIGHT
// PrintColourMode - force black text on white background for printing.
#define wxSTC_PRINT_BLACKONWHITE
// PrintColourMode - text stays coloured, but all background is forced to be white for printing.
#define wxSTC_PRINT_COLOURONWHITE
// PrintColourMode - only the default-background is forced to be white for printing.
#define wxSTC_PRINT_COLOURONWHITEDEFAULTBG
#define wxSTC_FIND_WHOLEWORD
#define wxSTC_FIND_MATCHCASE
#define wxSTC_FIND_WORDSTART
#define wxSTC_FIND_REGEXP
#define wxSTC_FIND_POSIX
#define wxSTC_FOLDLEVELBASE
#define wxSTC_FOLDLEVELWHITEFLAG
#define wxSTC_FOLDLEVELHEADERFLAG
!%wxchkver_2_9_2 #define wxSTC_FOLDLEVELBOXHEADERFLAG
!%wxchkver_2_9_2 #define wxSTC_FOLDLEVELBOXFOOTERFLAG
!%wxchkver_2_9_2 #define wxSTC_FOLDLEVELCONTRACTED
!%wxchkver_2_9_2 #define wxSTC_FOLDLEVELUNINDENT
#define wxSTC_FOLDLEVELNUMBERMASK
#define wxSTC_FOLDFLAG_LINEBEFORE_EXPANDED
#define wxSTC_FOLDFLAG_LINEBEFORE_CONTRACTED
#define wxSTC_FOLDFLAG_LINEAFTER_EXPANDED
#define wxSTC_FOLDFLAG_LINEAFTER_CONTRACTED
#define wxSTC_FOLDFLAG_LEVELNUMBERS
!%wxchkver_2_9_2 #define wxSTC_FOLDFLAG_BOX
#define wxSTC_TIME_FOREVER
#define wxSTC_WRAP_NONE
#define wxSTC_WRAP_WORD
#define wxSTC_WRAP_CHAR
#define wxSTC_WRAPVISUALFLAG_NONE
#define wxSTC_WRAPVISUALFLAG_END
#define wxSTC_WRAPVISUALFLAG_START
%wxchkver_2_9_5 #define wxSTC_WRAPVISUALFLAG_MARGIN
#define wxSTC_WRAPVISUALFLAGLOC_DEFAULT
#define wxSTC_WRAPVISUALFLAGLOC_END_BY_TEXT
#define wxSTC_WRAPVISUALFLAGLOC_START_BY_TEXT
%wxchkver_2_9_5 #define wxSTC_WRAPINDENT_FIXED
%wxchkver_2_9_5 #define wxSTC_WRAPINDENT_SAME
%wxchkver_2_9_5 #define wxSTC_WRAPINDENT_INDENT
#define wxSTC_CACHE_NONE
#define wxSTC_CACHE_CARET
#define wxSTC_CACHE_PAGE
#define wxSTC_CACHE_DOCUMENT
// Control font anti-aliasing.
#if %wxchkver_2_9_5
#define wxSTC_EFF_QUALITY_MASK
#define wxSTC_EFF_QUALITY_DEFAULT
#define wxSTC_EFF_QUALITY_NON_ANTIALIASED
#define wxSTC_EFF_QUALITY_ANTIALIASED
#define wxSTC_EFF_QUALITY_LCD_OPTIMIZED
#define wxSTC_MULTIPASTE_ONCE
#define wxSTC_MULTIPASTE_EACH
#endif // %wxchkver_2_9_5
#define wxSTC_EDGE_NONE
#define wxSTC_EDGE_LINE
#define wxSTC_EDGE_BACKGROUND
%wxchkver_2_9_5 #define wxSTC_STATUS_OK
%wxchkver_2_9_5 #define wxSTC_STATUS_FAILURE
%wxchkver_2_9_5 #define wxSTC_STATUS_BADALLOC
#define wxSTC_CURSORNORMAL
%wxchkver_2_9_5 #define wxSTC_CURSORARROW
#define wxSTC_CURSORWAIT
%wxchkver_2_9_5 #define wxSTC_CURSORREVERSEARROW
// Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.
#define wxSTC_VISIBLE_SLOP
#define wxSTC_VISIBLE_STRICT
// Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.
// If CARET_SLOP is set, we can define a slop value: caretSlop.
// This value defines an unwanted zone (UZ) where the caret is... unwanted.
// This zone is defined as a number of pixels near the vertical margins,
// and as a number of lines near the horizontal margins.
// By keeping the caret away from the edges, it is seen within its context,
// so it is likely that the identifier that the caret is on can be completely seen,
// and that the current line is seen with some of the lines following it which are
// often dependent on that line.
#define wxSTC_CARET_SLOP
// If CARET_STRICT is set, the policy is enforced... strictly.
// The caret is centred on the display if slop is not set,
// and cannot go in the UZ if slop is set.
#define wxSTC_CARET_STRICT
// If CARET_JUMPS is set, the display is moved more energetically
// so the caret can move in the same direction longer before the policy is applied again.
#define wxSTC_CARET_JUMPS
// If CARET_EVEN is not set, instead of having symmetrical UZs,
// the left and bottom UZs are extended up to right and top UZs respectively.
// This way, we favour the displaying of useful information: the begining of lines,
// where most code reside, and the lines after the caret, eg. the body of a function.
#define wxSTC_CARET_EVEN
// Selection modes
#define wxSTC_SEL_STREAM
#define wxSTC_SEL_RECTANGLE
#define wxSTC_SEL_LINES
#if %wxchkver_2_9_5
#define wxSTC_SEL_THIN
#define wxSTC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE
#define wxSTC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE
#define wxSTC_CARETSTICKY_OFF
#define wxSTC_CARETSTICKY_ON
#define wxSTC_CARETSTICKY_WHITESPACE
#endif //%wxchkver_2_9_5
%wxchkver_2_8_12 #define wxSTC_ALPHA_TRANSPARENT
%wxchkver_2_8_12 #define wxSTC_ALPHA_OPAQUE
%wxchkver_2_8_12 #define wxSTC_ALPHA_NOALPHA
#if %wxchkver_2_9_5
#define wxSTC_CARETSTYLE_INVISIBLE
#define wxSTC_CARETSTYLE_LINE
#define wxSTC_CARETSTYLE_BLOCK
#define wxSTC_MARGINOPTION_NONE
#define wxSTC_MARGINOPTION_SUBLINESELECT
#define wxSTC_ANNOTATION_HIDDEN
#define wxSTC_ANNOTATION_STANDARD
#define wxSTC_ANNOTATION_BOXED
#define wxSTC_UNDO_MAY_COALESCE
#define wxSTC_SCVS_NONE
#define wxSTC_SCVS_RECTANGULARSELECTION
#define wxSTC_SCVS_USERACCESSIBLE
#define wxSTC_TECHNOLOGY_DEFAULT
#define wxSTC_TECHNOLOGY_DIRECTWRITE
#endif //%wxchkver_2_9_5
// Maximum value of keywordSet parameter of SetKeyWords.
#define wxSTC_KEYWORDSET_MAX
#if %wxchkver_2_9_5
#define wxSTC_TYPE_BOOLEAN
#define wxSTC_TYPE_INTEGER
#define wxSTC_TYPE_STRING
#endif //%wxchkver_2_9_5
// Notifications
// Type of modification and the action which caused the modification.
// These are defined as a bit mask to make it easy to specify which notifications are wanted.
// One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
#define wxSTC_MOD_INSERTTEXT
#define wxSTC_MOD_DELETETEXT
#define wxSTC_MOD_CHANGESTYLE
#define wxSTC_MOD_CHANGEFOLD
#define wxSTC_PERFORMED_USER
#define wxSTC_PERFORMED_UNDO
#define wxSTC_PERFORMED_REDO
#define wxSTC_MULTISTEPUNDOREDO
#define wxSTC_LASTSTEPINUNDOREDO
#define wxSTC_MOD_CHANGEMARKER
#define wxSTC_MOD_BEFOREINSERT
#define wxSTC_MOD_BEFOREDELETE
#define wxSTC_MULTILINEUNDOREDO
#if %wxchkver_2_9_5
#define wxSTC_STARTACTION
#define wxSTC_MOD_CHANGEINDICATOR
#define wxSTC_MOD_CHANGELINESTATE
#define wxSTC_MOD_CHANGEMARGIN
#define wxSTC_MOD_CHANGEANNOTATION
#define wxSTC_MOD_CONTAINER
#define wxSTC_MOD_LEXERSTATE
#endif //%wxchkver_2_9_5
#define wxSTC_MODEVENTMASKALL
#if %wxchkver_2_9_5
#define wxSTC_UPDATE_CONTENT
#define wxSTC_UPDATE_SELECTION
#define wxSTC_UPDATE_V_SCROLL
#define wxSTC_UPDATE_H_SCROLL
#endif //%wxchkver_2_9_5
// Symbolic key codes and modifier flags.
// ASCII and other printable characters below 256.
// Extended keys above 300.
#define wxSTC_KEY_DOWN
#define wxSTC_KEY_UP
#define wxSTC_KEY_LEFT
#define wxSTC_KEY_RIGHT
#define wxSTC_KEY_HOME
#define wxSTC_KEY_END
#define wxSTC_KEY_PRIOR
#define wxSTC_KEY_NEXT
#define wxSTC_KEY_DELETE
#define wxSTC_KEY_INSERT
#define wxSTC_KEY_ESCAPE
#define wxSTC_KEY_BACK
#define wxSTC_KEY_TAB
#define wxSTC_KEY_RETURN
#define wxSTC_KEY_ADD
#define wxSTC_KEY_SUBTRACT
#define wxSTC_KEY_DIVIDE
%wxchkver_2_9_5 #define wxSTC_KEY_WIN
%wxchkver_2_9_5 #define wxSTC_KEY_RWIN
%wxchkver_2_9_5 #define wxSTC_KEY_MENU
#define wxSTC_SCMOD_NORM
#define wxSTC_SCMOD_SHIFT
#define wxSTC_SCMOD_CTRL
#define wxSTC_SCMOD_ALT
%wxchkver_2_9_5 #define wxSTC_SCMOD_SUPER
%wxchkver_2_9_5 #define wxSTC_SCMOD_META
// For SciLexer.h
#define wxSTC_LEX_CONTAINER
#define wxSTC_LEX_NULL
#define wxSTC_LEX_PYTHON
#define wxSTC_LEX_CPP
#define wxSTC_LEX_HTML
#define wxSTC_LEX_XML
#define wxSTC_LEX_PERL
#define wxSTC_LEX_SQL
#define wxSTC_LEX_VB
#define wxSTC_LEX_PROPERTIES
#define wxSTC_LEX_ERRORLIST
#define wxSTC_LEX_MAKEFILE
#define wxSTC_LEX_BATCH
#define wxSTC_LEX_XCODE
#define wxSTC_LEX_LATEX
#define wxSTC_LEX_LUA
#define wxSTC_LEX_DIFF
#define wxSTC_LEX_CONF
#define wxSTC_LEX_PASCAL
#define wxSTC_LEX_AVE
#define wxSTC_LEX_ADA
#define wxSTC_LEX_LISP
#define wxSTC_LEX_RUBY
#define wxSTC_LEX_EIFFEL
#define wxSTC_LEX_EIFFELKW
#define wxSTC_LEX_TCL
#define wxSTC_LEX_NNCRONTAB
#define wxSTC_LEX_BULLANT
#define wxSTC_LEX_VBSCRIPT
#define wxSTC_LEX_BAAN
#define wxSTC_LEX_MATLAB
#define wxSTC_LEX_SCRIPTOL
#define wxSTC_LEX_ASM
#define wxSTC_LEX_CPPNOCASE
#define wxSTC_LEX_FORTRAN
#define wxSTC_LEX_F77
#define wxSTC_LEX_CSS
#define wxSTC_LEX_POV
#define wxSTC_LEX_LOUT
#define wxSTC_LEX_ESCRIPT
#define wxSTC_LEX_PS
#define wxSTC_LEX_NSIS
#define wxSTC_LEX_MMIXAL
#define wxSTC_LEX_CLW
#define wxSTC_LEX_CLWNOCASE
#define wxSTC_LEX_LOT
#define wxSTC_LEX_YAML
#define wxSTC_LEX_TEX
#define wxSTC_LEX_METAPOST
#define wxSTC_LEX_POWERBASIC
#define wxSTC_LEX_FORTH
#define wxSTC_LEX_ERLANG
#define wxSTC_LEX_OCTAVE
#define wxSTC_LEX_MSSQL
#define wxSTC_LEX_VERILOG
#define wxSTC_LEX_KIX
#define wxSTC_LEX_GUI4CLI
#define wxSTC_LEX_SPECMAN
#define wxSTC_LEX_AU3
#define wxSTC_LEX_APDL
#define wxSTC_LEX_BASH
#define wxSTC_LEX_ASN1
#define wxSTC_LEX_VHDL
#define wxSTC_LEX_CAML
#define wxSTC_LEX_BLITZBASIC
#define wxSTC_LEX_PUREBASIC
#define wxSTC_LEX_HASKELL
#define wxSTC_LEX_PHPSCRIPT
#define wxSTC_LEX_TADS3
#define wxSTC_LEX_REBOL
#define wxSTC_LEX_SMALLTALK
#define wxSTC_LEX_FLAGSHIP
#define wxSTC_LEX_CSOUND
#define wxSTC_LEX_FREEBASIC
%wxchkver_2_8_12 #define wxSTC_LEX_INNOSETUP
%wxchkver_2_8_12 #define wxSTC_LEX_OPAL
%wxchkver_2_8_12 #define wxSTC_LEX_SPICE
#if %wxchkver_2_9_5
#define wxSTC_LEX_OPAL
#define wxSTC_LEX_SPICE
#define wxSTC_LEX_D
#define wxSTC_LEX_CMAKE
#define wxSTC_LEX_GAP
#define wxSTC_LEX_PLM
#define wxSTC_LEX_PROGRESS
#define wxSTC_LEX_ABAQUS
#define wxSTC_LEX_ASYMPTOTE
#define wxSTC_LEX_R
#define wxSTC_LEX_MAGIK
#define wxSTC_LEX_POWERSHELL
#define wxSTC_LEX_MYSQL
#define wxSTC_LEX_PO
#define wxSTC_LEX_TAL
#define wxSTC_LEX_COBOL
#define wxSTC_LEX_TACL
#define wxSTC_LEX_SORCUS
#define wxSTC_LEX_POWERPRO
#define wxSTC_LEX_NIMROD
#define wxSTC_LEX_SML
#define wxSTC_LEX_MARKDOWN
#define wxSTC_LEX_TXT2TAGS
#define wxSTC_LEX_A68K
#define wxSTC_LEX_MODULA
#define wxSTC_LEX_COFFEESCRIPT
#define wxSTC_LEX_TCMD
#define wxSTC_LEX_AVS
#define wxSTC_LEX_ECL
#define wxSTC_LEX_OSCRIPT
#define wxSTC_LEX_VISUALPROLOG
#endif //%wxchkver_2_9_5
// These are deprecated, STC_LEX_HTML should be used instead.
!%wxchkver_2_8 #define wxSTC_LEX_ASP
!%wxchkver_2_8 #define wxSTC_LEX_PHP
// When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
// value assigned in sequence from SCLEX_AUTOMATIC+1.
#define wxSTC_LEX_AUTOMATIC
// Lexical states for SCLEX_PYTHON
#define wxSTC_P_DEFAULT
#define wxSTC_P_COMMENTLINE
#define wxSTC_P_NUMBER
#define wxSTC_P_STRING
#define wxSTC_P_CHARACTER
#define wxSTC_P_WORD
#define wxSTC_P_TRIPLE
#define wxSTC_P_TRIPLEDOUBLE
#define wxSTC_P_CLASSNAME
#define wxSTC_P_DEFNAME
#define wxSTC_P_OPERATOR
#define wxSTC_P_IDENTIFIER
#define wxSTC_P_COMMENTBLOCK
#define wxSTC_P_STRINGEOL
#define wxSTC_P_WORD2
#define wxSTC_P_DECORATOR
// Lexical states for SCLEX_CPP
#define wxSTC_C_DEFAULT
#define wxSTC_C_COMMENT
#define wxSTC_C_COMMENTLINE
#define wxSTC_C_COMMENTDOC
#define wxSTC_C_NUMBER
#define wxSTC_C_WORD
#define wxSTC_C_STRING
#define wxSTC_C_CHARACTER
#define wxSTC_C_UUID
#define wxSTC_C_PREPROCESSOR
#define wxSTC_C_OPERATOR
#define wxSTC_C_IDENTIFIER
#define wxSTC_C_STRINGEOL
#define wxSTC_C_VERBATIM
#define wxSTC_C_REGEX
#define wxSTC_C_COMMENTLINEDOC
#define wxSTC_C_WORD2
#define wxSTC_C_COMMENTDOCKEYWORD
#define wxSTC_C_COMMENTDOCKEYWORDERROR
#define wxSTC_C_GLOBALCLASS
#if %wxchkver_2_9_5
#define wxSTC_C_STRINGRAW
#define wxSTC_C_TRIPLEVERBATIM
#define wxSTC_C_HASHQUOTEDSTRING
#define wxSTC_C_PREPROCESSORCOMMENT
#endif //%wxchkver_2_9_5
#if %wxchkver_2_9_5
// Lexical states for SCLEX_D
#define wxSTC_D_DEFAULT
#define wxSTC_D_COMMENT
#define wxSTC_D_COMMENTLINE
#define wxSTC_D_COMMENTDOC
#define wxSTC_D_COMMENTNESTED
#define wxSTC_D_NUMBER
#define wxSTC_D_WORD
#define wxSTC_D_WORD2
#define wxSTC_D_WORD3
#define wxSTC_D_TYPEDEF
#define wxSTC_D_STRING
#define wxSTC_D_STRINGEOL
#define wxSTC_D_CHARACTER
#define wxSTC_D_OPERATOR
#define wxSTC_D_IDENTIFIER
#define wxSTC_D_COMMENTLINEDOC
#define wxSTC_D_COMMENTDOCKEYWORD
#define wxSTC_D_COMMENTDOCKEYWORDERROR
#define wxSTC_D_STRINGB
#define wxSTC_D_STRINGR
#define wxSTC_D_WORD5
#define wxSTC_D_WORD6
#define wxSTC_D_WORD7
#endif //%wxchkver_2_9_5
// Lexical states for SCLEX_TCL
#if %wxchkver_2_8_12
#define wxSTC_TCL_DEFAULT
#define wxSTC_TCL_COMMENT
#define wxSTC_TCL_COMMENTLINE
#define wxSTC_TCL_NUMBER
#define wxSTC_TCL_WORD_IN_QUOTE
#define wxSTC_TCL_IN_QUOTE
#define wxSTC_TCL_OPERATOR
#define wxSTC_TCL_IDENTIFIER
#define wxSTC_TCL_SUBSTITUTION
#define wxSTC_TCL_SUB_BRACE
#define wxSTC_TCL_MODIFIER
#define wxSTC_TCL_EXPAND
#define wxSTC_TCL_WORD
#define wxSTC_TCL_WORD2
#define wxSTC_TCL_WORD3
#define wxSTC_TCL_WORD4
#define wxSTC_TCL_WORD5
#define wxSTC_TCL_WORD6
#define wxSTC_TCL_WORD7
#define wxSTC_TCL_WORD8
#define wxSTC_TCL_COMMENT_BOX
#define wxSTC_TCL_BLOCK_COMMENT
#endif //%wxchkver_2_8_12
// Lexical states for SCLEX_HTML, SCLEX_XML
#define wxSTC_H_DEFAULT
#define wxSTC_H_TAG
#define wxSTC_H_TAGUNKNOWN
#define wxSTC_H_ATTRIBUTE
#define wxSTC_H_ATTRIBUTEUNKNOWN
#define wxSTC_H_NUMBER
#define wxSTC_H_DOUBLESTRING
#define wxSTC_H_SINGLESTRING
#define wxSTC_H_OTHER
#define wxSTC_H_COMMENT
#define wxSTC_H_ENTITY
// XML and ASP
#define wxSTC_H_TAGEND
#define wxSTC_H_XMLSTART
#define wxSTC_H_XMLEND
#define wxSTC_H_SCRIPT
#define wxSTC_H_ASP
#define wxSTC_H_ASPAT
#define wxSTC_H_CDATA
#define wxSTC_H_QUESTION
// More HTML
#define wxSTC_H_VALUE
// X-Code
#define wxSTC_H_XCCOMMENT
// SGML
#define wxSTC_H_SGML_DEFAULT
#define wxSTC_H_SGML_COMMAND
#define wxSTC_H_SGML_1ST_PARAM
#define wxSTC_H_SGML_DOUBLESTRING
#define wxSTC_H_SGML_SIMPLESTRING
#define wxSTC_H_SGML_ERROR
#define wxSTC_H_SGML_SPECIAL
#define wxSTC_H_SGML_ENTITY
#define wxSTC_H_SGML_COMMENT
#define wxSTC_H_SGML_1ST_PARAM_COMMENT
#define wxSTC_H_SGML_BLOCK_DEFAULT
// Embedded Javascript
#define wxSTC_HJ_START
#define wxSTC_HJ_DEFAULT
#define wxSTC_HJ_COMMENT
#define wxSTC_HJ_COMMENTLINE
#define wxSTC_HJ_COMMENTDOC
#define wxSTC_HJ_NUMBER
#define wxSTC_HJ_WORD
#define wxSTC_HJ_KEYWORD
#define wxSTC_HJ_DOUBLESTRING
#define wxSTC_HJ_SINGLESTRING
#define wxSTC_HJ_SYMBOLS
#define wxSTC_HJ_STRINGEOL
#define wxSTC_HJ_REGEX
// ASP Javascript
#define wxSTC_HJA_START
#define wxSTC_HJA_DEFAULT
#define wxSTC_HJA_COMMENT
#define wxSTC_HJA_COMMENTLINE
#define wxSTC_HJA_COMMENTDOC
#define wxSTC_HJA_NUMBER
#define wxSTC_HJA_WORD
#define wxSTC_HJA_KEYWORD
#define wxSTC_HJA_DOUBLESTRING
#define wxSTC_HJA_SINGLESTRING
#define wxSTC_HJA_SYMBOLS
#define wxSTC_HJA_STRINGEOL
#define wxSTC_HJA_REGEX
// Embedded VBScript
#define wxSTC_HB_START
#define wxSTC_HB_DEFAULT
#define wxSTC_HB_COMMENTLINE
#define wxSTC_HB_NUMBER
#define wxSTC_HB_WORD
#define wxSTC_HB_STRING
#define wxSTC_HB_IDENTIFIER
#define wxSTC_HB_STRINGEOL
// ASP VBScript
#define wxSTC_HBA_START
#define wxSTC_HBA_DEFAULT
#define wxSTC_HBA_COMMENTLINE
#define wxSTC_HBA_NUMBER
#define wxSTC_HBA_WORD
#define wxSTC_HBA_STRING
#define wxSTC_HBA_IDENTIFIER
#define wxSTC_HBA_STRINGEOL
// Embedded Python
#define wxSTC_HP_START
#define wxSTC_HP_DEFAULT
#define wxSTC_HP_COMMENTLINE
#define wxSTC_HP_NUMBER
#define wxSTC_HP_STRING
#define wxSTC_HP_CHARACTER
#define wxSTC_HP_WORD
#define wxSTC_HP_TRIPLE
#define wxSTC_HP_TRIPLEDOUBLE
#define wxSTC_HP_CLASSNAME
#define wxSTC_HP_DEFNAME
#define wxSTC_HP_OPERATOR
#define wxSTC_HP_IDENTIFIER
// PHP
#define wxSTC_HPHP_COMPLEX_VARIABLE
// ASP Python
#define wxSTC_HPA_START
#define wxSTC_HPA_DEFAULT
#define wxSTC_HPA_COMMENTLINE
#define wxSTC_HPA_NUMBER
#define wxSTC_HPA_STRING
#define wxSTC_HPA_CHARACTER
#define wxSTC_HPA_WORD
#define wxSTC_HPA_TRIPLE
#define wxSTC_HPA_TRIPLEDOUBLE
#define wxSTC_HPA_CLASSNAME
#define wxSTC_HPA_DEFNAME
#define wxSTC_HPA_OPERATOR
#define wxSTC_HPA_IDENTIFIER
// PHP
#define wxSTC_HPHP_DEFAULT
#define wxSTC_HPHP_HSTRING
#define wxSTC_HPHP_SIMPLESTRING
#define wxSTC_HPHP_WORD
#define wxSTC_HPHP_NUMBER
#define wxSTC_HPHP_VARIABLE
#define wxSTC_HPHP_COMMENT
#define wxSTC_HPHP_COMMENTLINE
#define wxSTC_HPHP_HSTRING_VARIABLE
#define wxSTC_HPHP_OPERATOR
// Lexical states for SCLEX_PERL
#define wxSTC_PL_DEFAULT
#define wxSTC_PL_ERROR
#define wxSTC_PL_COMMENTLINE
#define wxSTC_PL_POD
#define wxSTC_PL_NUMBER
#define wxSTC_PL_WORD
#define wxSTC_PL_STRING
#define wxSTC_PL_CHARACTER
#define wxSTC_PL_PUNCTUATION
#define wxSTC_PL_PREPROCESSOR
#define wxSTC_PL_OPERATOR
#define wxSTC_PL_IDENTIFIER
#define wxSTC_PL_SCALAR
#define wxSTC_PL_ARRAY
#define wxSTC_PL_HASH
#define wxSTC_PL_SYMBOLTABLE
#define wxSTC_PL_VARIABLE_INDEXER
#define wxSTC_PL_REGEX
#define wxSTC_PL_REGSUBST
#define wxSTC_PL_LONGQUOTE
#define wxSTC_PL_BACKTICKS
#define wxSTC_PL_DATASECTION
#define wxSTC_PL_HERE_DELIM
#define wxSTC_PL_HERE_Q
#define wxSTC_PL_HERE_QQ
#define wxSTC_PL_HERE_QX
#define wxSTC_PL_STRING_Q
#define wxSTC_PL_STRING_QQ
#define wxSTC_PL_STRING_QX
#define wxSTC_PL_STRING_QR
#define wxSTC_PL_STRING_QW
#define wxSTC_PL_POD_VERB
#if %wxchkver_2_9_5
#define wxSTC_PL_SUB_PROTOTYPE
#define wxSTC_PL_FORMAT_IDENT
#define wxSTC_PL_FORMAT
#define wxSTC_PL_STRING_VAR
#define wxSTC_PL_XLAT
#define wxSTC_PL_REGEX_VAR
#define wxSTC_PL_REGSUBST_VAR
#define wxSTC_PL_BACKTICKS_VAR
#define wxSTC_PL_HERE_QQ_VAR
#define wxSTC_PL_HERE_QX_VAR
#define wxSTC_PL_STRING_QQ_VAR
#define wxSTC_PL_STRING_QX_VAR
#define wxSTC_PL_STRING_QR_VAR
#endif //%wxchkver_2_9_5
// Lexical states for SCLEX_RUBY
#define wxSTC_RB_DEFAULT
#define wxSTC_RB_ERROR
#define wxSTC_RB_COMMENTLINE
#define wxSTC_RB_POD
#define wxSTC_RB_NUMBER
#define wxSTC_RB_WORD
#define wxSTC_RB_STRING
#define wxSTC_RB_CHARACTER
#define wxSTC_RB_CLASSNAME
#define wxSTC_RB_DEFNAME
#define wxSTC_RB_OPERATOR
#define wxSTC_RB_IDENTIFIER
#define wxSTC_RB_REGEX
#define wxSTC_RB_GLOBAL
#define wxSTC_RB_SYMBOL
#define wxSTC_RB_MODULE_NAME
#define wxSTC_RB_INSTANCE_VAR
#define wxSTC_RB_CLASS_VAR
#define wxSTC_RB_BACKTICKS
#define wxSTC_RB_DATASECTION
#define wxSTC_RB_HERE_DELIM
#define wxSTC_RB_HERE_Q
#define wxSTC_RB_HERE_QQ
#define wxSTC_RB_HERE_QX
#define wxSTC_RB_STRING_Q
#define wxSTC_RB_STRING_QQ
#define wxSTC_RB_STRING_QX
#define wxSTC_RB_STRING_QR
#define wxSTC_RB_STRING_QW
#define wxSTC_RB_WORD_DEMOTED
#define wxSTC_RB_STDIN
#define wxSTC_RB_STDOUT
#define wxSTC_RB_STDERR
#define wxSTC_RB_UPPER_BOUND
// Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC
#define wxSTC_B_DEFAULT
#define wxSTC_B_COMMENT
#define wxSTC_B_NUMBER
#define wxSTC_B_KEYWORD
#define wxSTC_B_STRING
#define wxSTC_B_PREPROCESSOR
#define wxSTC_B_OPERATOR
#define wxSTC_B_IDENTIFIER
#define wxSTC_B_DATE
#define wxSTC_B_STRINGEOL
#define wxSTC_B_KEYWORD2
#define wxSTC_B_KEYWORD3
#define wxSTC_B_KEYWORD4
#define wxSTC_B_CONSTANT
#define wxSTC_B_ASM
#define wxSTC_B_LABEL
#define wxSTC_B_ERROR
#define wxSTC_B_HEXNUMBER
#define wxSTC_B_BINNUMBER
// Lexical states for SCLEX_PROPERTIES
#define wxSTC_PROPS_DEFAULT
#define wxSTC_PROPS_COMMENT
#define wxSTC_PROPS_SECTION
#define wxSTC_PROPS_ASSIGNMENT
#define wxSTC_PROPS_DEFVAL
%wxchkver_2_8_12 #define wxSTC_PROPS_KEY
// Lexical states for SCLEX_LATEX
#define wxSTC_L_DEFAULT
#define wxSTC_L_COMMAND
#define wxSTC_L_TAG
#define wxSTC_L_MATH
#define wxSTC_L_COMMENT
#if %wxchkver_2_9_5
#define wxSTC_L_TAG2
#define wxSTC_L_MATH2
#define wxSTC_L_COMMENT2
#define wxSTC_L_VERBATIM
#define wxSTC_L_SHORTCMD
#define wxSTC_L_SPECIAL
#define wxSTC_L_CMDOPT
#define wxSTC_L_ERROR
#endif // %wxchkver_2_9_5
// Lexical states for SCLEX_LUA
#define wxSTC_LUA_DEFAULT
#define wxSTC_LUA_COMMENT
#define wxSTC_LUA_COMMENTLINE
#define wxSTC_LUA_COMMENTDOC
#define wxSTC_LUA_NUMBER
#define wxSTC_LUA_WORD
#define wxSTC_LUA_STRING
#define wxSTC_LUA_CHARACTER
#define wxSTC_LUA_LITERALSTRING
#define wxSTC_LUA_PREPROCESSOR
#define wxSTC_LUA_OPERATOR
#define wxSTC_LUA_IDENTIFIER
#define wxSTC_LUA_STRINGEOL
#define wxSTC_LUA_WORD2
#define wxSTC_LUA_WORD3
#define wxSTC_LUA_WORD4
#define wxSTC_LUA_WORD5
#define wxSTC_LUA_WORD6
#define wxSTC_LUA_WORD7
#define wxSTC_LUA_WORD8
%wxchkver_2_9_5 #define wxSTC_LUA_LABEL
// Lexical states for SCLEX_ERRORLIST
#define wxSTC_ERR_DEFAULT
#define wxSTC_ERR_PYTHON
#define wxSTC_ERR_GCC
#define wxSTC_ERR_MS
#define wxSTC_ERR_CMD
#define wxSTC_ERR_BORLAND
#define wxSTC_ERR_PERL
#define wxSTC_ERR_NET
#define wxSTC_ERR_LUA
#define wxSTC_ERR_CTAG
#define wxSTC_ERR_DIFF_CHANGED
#define wxSTC_ERR_DIFF_ADDITION
#define wxSTC_ERR_DIFF_DELETION
#define wxSTC_ERR_DIFF_MESSAGE
#define wxSTC_ERR_PHP
#define wxSTC_ERR_ELF
#define wxSTC_ERR_IFC
#define wxSTC_ERR_IFORT
#define wxSTC_ERR_ABSF
#define wxSTC_ERR_TIDY
#define wxSTC_ERR_JAVA_STACK
%wxchkver_2_9_5 #define wxSTC_ERR_VALUE
// Lexical states for SCLEX_BATCH
#define wxSTC_BAT_DEFAULT
#define wxSTC_BAT_COMMENT
#define wxSTC_BAT_WORD
#define wxSTC_BAT_LABEL
#define wxSTC_BAT_HIDE
#define wxSTC_BAT_COMMAND
#define wxSTC_BAT_IDENTIFIER
#define wxSTC_BAT_OPERATOR
#if %wxchkver_2_9_5
// Lexical states for SCLEX_TCMD
#define wxSTC_TCMD_DEFAULT
#define wxSTC_TCMD_COMMENT
#define wxSTC_TCMD_WORD
#define wxSTC_TCMD_LABEL
#define wxSTC_TCMD_HIDE
#define wxSTC_TCMD_COMMAND
#define wxSTC_TCMD_IDENTIFIER
#define wxSTC_TCMD_OPERATOR
#define wxSTC_TCMD_ENVIRONMENT
#define wxSTC_TCMD_EXPANSION
#define wxSTC_TCMD_CLABEL
#endif //%wxchkver_2_9_5
// Lexical states for SCLEX_MAKEFILE
#define wxSTC_MAKE_DEFAULT
#define wxSTC_MAKE_COMMENT
#define wxSTC_MAKE_PREPROCESSOR
#define wxSTC_MAKE_IDENTIFIER
#define wxSTC_MAKE_OPERATOR
#define wxSTC_MAKE_TARGET
#define wxSTC_MAKE_IDEOL
// Lexical states for SCLEX_DIFF
#define wxSTC_DIFF_DEFAULT
#define wxSTC_DIFF_COMMENT
#define wxSTC_DIFF_COMMAND
#define wxSTC_DIFF_HEADER
#define wxSTC_DIFF_POSITION
#define wxSTC_DIFF_DELETED
#define wxSTC_DIFF_ADDED
%wxchkver_2_9_5 #define wxSTC_DIFF_CHANGED
// Lexical states for SCLEX_CONF (Apache Configuration Files Lexer)
#define wxSTC_CONF_DEFAULT
#define wxSTC_CONF_COMMENT
#define wxSTC_CONF_NUMBER
#define wxSTC_CONF_IDENTIFIER
#define wxSTC_CONF_EXTENSION
#define wxSTC_CONF_PARAMETER
#define wxSTC_CONF_STRING
#define wxSTC_CONF_OPERATOR
#define wxSTC_CONF_IP
#define wxSTC_CONF_DIRECTIVE
// Lexical states for SCLEX_AVE, Avenue
#define wxSTC_AVE_DEFAULT
#define wxSTC_AVE_COMMENT
#define wxSTC_AVE_NUMBER
#define wxSTC_AVE_WORD
#define wxSTC_AVE_STRING
#define wxSTC_AVE_ENUM
#define wxSTC_AVE_STRINGEOL
#define wxSTC_AVE_IDENTIFIER
#define wxSTC_AVE_OPERATOR
#define wxSTC_AVE_WORD1
#define wxSTC_AVE_WORD2
#define wxSTC_AVE_WORD3
#define wxSTC_AVE_WORD4
#define wxSTC_AVE_WORD5
#define wxSTC_AVE_WORD6
// Lexical states for SCLEX_ADA
#define wxSTC_ADA_DEFAULT
#define wxSTC_ADA_WORD
#define wxSTC_ADA_IDENTIFIER
#define wxSTC_ADA_NUMBER
#define wxSTC_ADA_DELIMITER
#define wxSTC_ADA_CHARACTER
#define wxSTC_ADA_CHARACTEREOL
#define wxSTC_ADA_STRING
#define wxSTC_ADA_STRINGEOL
#define wxSTC_ADA_LABEL
#define wxSTC_ADA_COMMENTLINE
#define wxSTC_ADA_ILLEGAL
// Lexical states for SCLEX_BAAN
#define wxSTC_BAAN_DEFAULT
#define wxSTC_BAAN_COMMENT
#define wxSTC_BAAN_COMMENTDOC
#define wxSTC_BAAN_NUMBER
#define wxSTC_BAAN_WORD
#define wxSTC_BAAN_STRING
#define wxSTC_BAAN_PREPROCESSOR
#define wxSTC_BAAN_OPERATOR
#define wxSTC_BAAN_IDENTIFIER
#define wxSTC_BAAN_STRINGEOL
#define wxSTC_BAAN_WORD2
// Lexical states for SCLEX_LISP
#define wxSTC_LISP_DEFAULT
#define wxSTC_LISP_COMMENT
#define wxSTC_LISP_NUMBER
#define wxSTC_LISP_KEYWORD
#define wxSTC_LISP_KEYWORD_KW
#define wxSTC_LISP_SYMBOL
#define wxSTC_LISP_STRING
#define wxSTC_LISP_STRINGEOL
#define wxSTC_LISP_IDENTIFIER
#define wxSTC_LISP_OPERATOR
#define wxSTC_LISP_SPECIAL
#define wxSTC_LISP_MULTI_COMMENT
// Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW
#define wxSTC_EIFFEL_DEFAULT
#define wxSTC_EIFFEL_COMMENTLINE
#define wxSTC_EIFFEL_NUMBER
#define wxSTC_EIFFEL_WORD
#define wxSTC_EIFFEL_STRING
#define wxSTC_EIFFEL_CHARACTER
#define wxSTC_EIFFEL_OPERATOR
#define wxSTC_EIFFEL_IDENTIFIER
#define wxSTC_EIFFEL_STRINGEOL
// Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer)
#define wxSTC_NNCRONTAB_DEFAULT
#define wxSTC_NNCRONTAB_COMMENT
#define wxSTC_NNCRONTAB_TASK
#define wxSTC_NNCRONTAB_SECTION
#define wxSTC_NNCRONTAB_KEYWORD
#define wxSTC_NNCRONTAB_MODIFIER
#define wxSTC_NNCRONTAB_ASTERISK
#define wxSTC_NNCRONTAB_NUMBER
#define wxSTC_NNCRONTAB_STRING
#define wxSTC_NNCRONTAB_ENVIRONMENT
#define wxSTC_NNCRONTAB_IDENTIFIER
// Lexical states for SCLEX_FORTH (Forth Lexer)
#define wxSTC_FORTH_DEFAULT
#define wxSTC_FORTH_COMMENT
#define wxSTC_FORTH_COMMENT_ML
#define wxSTC_FORTH_IDENTIFIER
#define wxSTC_FORTH_CONTROL
#define wxSTC_FORTH_KEYWORD
#define wxSTC_FORTH_DEFWORD
#define wxSTC_FORTH_PREWORD1
#define wxSTC_FORTH_PREWORD2
#define wxSTC_FORTH_NUMBER
#define wxSTC_FORTH_STRING
#define wxSTC_FORTH_LOCALE
// Lexical states for SCLEX_MATLAB
#define wxSTC_MATLAB_DEFAULT
#define wxSTC_MATLAB_COMMENT
#define wxSTC_MATLAB_COMMAND
#define wxSTC_MATLAB_NUMBER
#define wxSTC_MATLAB_KEYWORD
// single quoted string
#define wxSTC_MATLAB_STRING
#define wxSTC_MATLAB_OPERATOR
#define wxSTC_MATLAB_IDENTIFIER
#define wxSTC_MATLAB_DOUBLEQUOTESTRING
// Lexical states for SCLEX_SCRIPTOL
#define wxSTC_SCRIPTOL_DEFAULT
#define wxSTC_SCRIPTOL_WHITE
#define wxSTC_SCRIPTOL_COMMENTLINE
#define wxSTC_SCRIPTOL_PERSISTENT
#define wxSTC_SCRIPTOL_CSTYLE
#define wxSTC_SCRIPTOL_COMMENTBLOCK
#define wxSTC_SCRIPTOL_NUMBER
#define wxSTC_SCRIPTOL_STRING
#define wxSTC_SCRIPTOL_CHARACTER
#define wxSTC_SCRIPTOL_STRINGEOL
#define wxSTC_SCRIPTOL_KEYWORD
#define wxSTC_SCRIPTOL_OPERATOR
#define wxSTC_SCRIPTOL_IDENTIFIER
#define wxSTC_SCRIPTOL_TRIPLE
#define wxSTC_SCRIPTOL_CLASSNAME
#define wxSTC_SCRIPTOL_PREPROCESSOR
// Lexical states for SCLEX_ASM
#define wxSTC_ASM_DEFAULT
#define wxSTC_ASM_COMMENT
#define wxSTC_ASM_NUMBER
#define wxSTC_ASM_STRING
#define wxSTC_ASM_OPERATOR
#define wxSTC_ASM_IDENTIFIER
#define wxSTC_ASM_CPUINSTRUCTION
#define wxSTC_ASM_MATHINSTRUCTION
#define wxSTC_ASM_REGISTER
#define wxSTC_ASM_DIRECTIVE
#define wxSTC_ASM_DIRECTIVEOPERAND
#define wxSTC_ASM_COMMENTBLOCK
#define wxSTC_ASM_CHARACTER
#define wxSTC_ASM_STRINGEOL
#define wxSTC_ASM_EXTINSTRUCTION
%wxchkver_2_9_5 #define wxSTC_ASM_COMMENTDIRECTIVE
// Lexical states for SCLEX_FORTRAN
#define wxSTC_F_DEFAULT
#define wxSTC_F_COMMENT
#define wxSTC_F_NUMBER
#define wxSTC_F_STRING1
#define wxSTC_F_STRING2
#define wxSTC_F_STRINGEOL
#define wxSTC_F_OPERATOR
#define wxSTC_F_IDENTIFIER
#define wxSTC_F_WORD
#define wxSTC_F_WORD2
#define wxSTC_F_WORD3
#define wxSTC_F_PREPROCESSOR
#define wxSTC_F_OPERATOR2
#define wxSTC_F_LABEL
#define wxSTC_F_CONTINUATION
// Lexical states for SCLEX_CSS
#define wxSTC_CSS_DEFAULT
#define wxSTC_CSS_TAG
#define wxSTC_CSS_CLASS
#define wxSTC_CSS_PSEUDOCLASS
#define wxSTC_CSS_UNKNOWN_PSEUDOCLASS
#define wxSTC_CSS_OPERATOR
#define wxSTC_CSS_IDENTIFIER
#define wxSTC_CSS_UNKNOWN_IDENTIFIER
#define wxSTC_CSS_VALUE
#define wxSTC_CSS_COMMENT
#define wxSTC_CSS_ID
#define wxSTC_CSS_IMPORTANT
#define wxSTC_CSS_DIRECTIVE
#define wxSTC_CSS_DOUBLESTRING
#define wxSTC_CSS_SINGLESTRING
#define wxSTC_CSS_IDENTIFIER2
#define wxSTC_CSS_ATTRIBUTE
#if %wxchkver_2_9_5
#define wxSTC_CSS_IDENTIFIER3
#define wxSTC_CSS_PSEUDOELEMENT
#define wxSTC_CSS_EXTENDED_IDENTIFIER
#define wxSTC_CSS_EXTENDED_PSEUDOCLASS
#define wxSTC_CSS_EXTENDED_PSEUDOELEMENT
#define wxSTC_CSS_MEDIA
#define wxSTC_CSS_VARIABLE
#endif //%wxchkver_2_9_5
// Lexical states for SCLEX_POV
#define wxSTC_POV_DEFAULT
#define wxSTC_POV_COMMENT
#define wxSTC_POV_COMMENTLINE
#define wxSTC_POV_NUMBER
#define wxSTC_POV_OPERATOR
#define wxSTC_POV_IDENTIFIER
#define wxSTC_POV_STRING
#define wxSTC_POV_STRINGEOL
#define wxSTC_POV_DIRECTIVE
#define wxSTC_POV_BADDIRECTIVE
#define wxSTC_POV_WORD2
#define wxSTC_POV_WORD3
#define wxSTC_POV_WORD4
#define wxSTC_POV_WORD5
#define wxSTC_POV_WORD6
#define wxSTC_POV_WORD7
#define wxSTC_POV_WORD8
// Lexical states for SCLEX_LOUT
#define wxSTC_LOUT_DEFAULT
#define wxSTC_LOUT_COMMENT
#define wxSTC_LOUT_NUMBER
#define wxSTC_LOUT_WORD
#define wxSTC_LOUT_WORD2
#define wxSTC_LOUT_WORD3
#define wxSTC_LOUT_WORD4
#define wxSTC_LOUT_STRING
#define wxSTC_LOUT_OPERATOR
#define wxSTC_LOUT_IDENTIFIER
#define wxSTC_LOUT_STRINGEOL
// Lexical states for SCLEX_ESCRIPT
#define wxSTC_ESCRIPT_DEFAULT
#define wxSTC_ESCRIPT_COMMENT
#define wxSTC_ESCRIPT_COMMENTLINE
#define wxSTC_ESCRIPT_COMMENTDOC
#define wxSTC_ESCRIPT_NUMBER
#define wxSTC_ESCRIPT_WORD
#define wxSTC_ESCRIPT_STRING
#define wxSTC_ESCRIPT_OPERATOR
#define wxSTC_ESCRIPT_IDENTIFIER
#define wxSTC_ESCRIPT_BRACE
#define wxSTC_ESCRIPT_WORD2
#define wxSTC_ESCRIPT_WORD3
// Lexical states for SCLEX_PS
#define wxSTC_PS_DEFAULT
#define wxSTC_PS_COMMENT
#define wxSTC_PS_DSC_COMMENT
#define wxSTC_PS_DSC_VALUE
#define wxSTC_PS_NUMBER
#define wxSTC_PS_NAME
#define wxSTC_PS_KEYWORD
#define wxSTC_PS_LITERAL
#define wxSTC_PS_IMMEVAL
#define wxSTC_PS_PAREN_ARRAY
#define wxSTC_PS_PAREN_DICT
#define wxSTC_PS_PAREN_PROC
#define wxSTC_PS_TEXT
#define wxSTC_PS_HEXSTRING
#define wxSTC_PS_BASE85STRING
#define wxSTC_PS_BADSTRINGCHAR
// Lexical states for SCLEX_NSIS
#define wxSTC_NSIS_DEFAULT
#define wxSTC_NSIS_COMMENT
#define wxSTC_NSIS_STRINGDQ
#define wxSTC_NSIS_STRINGLQ
#define wxSTC_NSIS_STRINGRQ
#define wxSTC_NSIS_FUNCTION
#define wxSTC_NSIS_VARIABLE
#define wxSTC_NSIS_LABEL
#define wxSTC_NSIS_USERDEFINED
#define wxSTC_NSIS_SECTIONDEF
#define wxSTC_NSIS_SUBSECTIONDEF
#define wxSTC_NSIS_IFDEFINEDEF
#define wxSTC_NSIS_MACRODEF
#define wxSTC_NSIS_STRINGVAR
#define wxSTC_NSIS_NUMBER
#define wxSTC_NSIS_SECTIONGROUP
#define wxSTC_NSIS_PAGEEX
#define wxSTC_NSIS_FUNCTIONDEF
#define wxSTC_NSIS_COMMENTBOX
// Lexical states for SCLEX_MMIXAL
#define wxSTC_MMIXAL_LEADWS
#define wxSTC_MMIXAL_COMMENT
#define wxSTC_MMIXAL_LABEL
#define wxSTC_MMIXAL_OPCODE
#define wxSTC_MMIXAL_OPCODE_PRE
#define wxSTC_MMIXAL_OPCODE_VALID
#define wxSTC_MMIXAL_OPCODE_UNKNOWN
#define wxSTC_MMIXAL_OPCODE_POST
#define wxSTC_MMIXAL_OPERANDS
#define wxSTC_MMIXAL_NUMBER
#define wxSTC_MMIXAL_REF
#define wxSTC_MMIXAL_CHAR
#define wxSTC_MMIXAL_STRING
#define wxSTC_MMIXAL_REGISTER
#define wxSTC_MMIXAL_HEX
#define wxSTC_MMIXAL_OPERATOR
#define wxSTC_MMIXAL_SYMBOL
#define wxSTC_MMIXAL_INCLUDE
// Lexical states for SCLEX_CLW
#define wxSTC_CLW_DEFAULT
#define wxSTC_CLW_LABEL
#define wxSTC_CLW_COMMENT
#define wxSTC_CLW_STRING
#define wxSTC_CLW_USER_IDENTIFIER
#define wxSTC_CLW_INTEGER_CONSTANT
#define wxSTC_CLW_REAL_CONSTANT
#define wxSTC_CLW_PICTURE_STRING
#define wxSTC_CLW_KEYWORD
#define wxSTC_CLW_COMPILER_DIRECTIVE
#define wxSTC_CLW_RUNTIME_EXPRESSIONS
#define wxSTC_CLW_BUILTIN_PROCEDURES_FUNCTION
#define wxSTC_CLW_STRUCTURE_DATA_TYPE
#define wxSTC_CLW_ATTRIBUTE
#define wxSTC_CLW_STANDARD_EQUATE
#define wxSTC_CLW_ERROR
#define wxSTC_CLW_DEPRECATED
// Lexical states for SCLEX_LOT
#define wxSTC_LOT_DEFAULT
#define wxSTC_LOT_HEADER
#define wxSTC_LOT_BREAK
#define wxSTC_LOT_SET
#define wxSTC_LOT_PASS
#define wxSTC_LOT_FAIL
#define wxSTC_LOT_ABORT
// Lexical states for SCLEX_YAML
#define wxSTC_YAML_DEFAULT
#define wxSTC_YAML_COMMENT
#define wxSTC_YAML_IDENTIFIER
#define wxSTC_YAML_KEYWORD
#define wxSTC_YAML_NUMBER
#define wxSTC_YAML_REFERENCE
#define wxSTC_YAML_DOCUMENT
#define wxSTC_YAML_TEXT
#define wxSTC_YAML_ERROR
%wxchkver_2_9_5 #define wxSTC_YAML_OPERATOR
// Lexical states for SCLEX_TEX
#define wxSTC_TEX_DEFAULT
#define wxSTC_TEX_SPECIAL
#define wxSTC_TEX_GROUP
#define wxSTC_TEX_SYMBOL
#define wxSTC_TEX_COMMAND
#define wxSTC_TEX_TEXT
#define wxSTC_METAPOST_DEFAULT
#define wxSTC_METAPOST_SPECIAL
#define wxSTC_METAPOST_GROUP
#define wxSTC_METAPOST_SYMBOL
#define wxSTC_METAPOST_COMMAND
#define wxSTC_METAPOST_TEXT
#define wxSTC_METAPOST_EXTRA
// Lexical states for SCLEX_ERLANG
#define wxSTC_ERLANG_DEFAULT
#define wxSTC_ERLANG_COMMENT
#define wxSTC_ERLANG_VARIABLE
#define wxSTC_ERLANG_NUMBER
#define wxSTC_ERLANG_KEYWORD
#define wxSTC_ERLANG_STRING
#define wxSTC_ERLANG_OPERATOR
#define wxSTC_ERLANG_ATOM
#define wxSTC_ERLANG_FUNCTION_NAME
#define wxSTC_ERLANG_CHARACTER
#define wxSTC_ERLANG_MACRO
#define wxSTC_ERLANG_RECORD
!%wxchkver_2_9_2 #define wxSTC_ERLANG_SEPARATOR
#if %wxchkver_2_9_5
#define wxSTC_ERLANG_PREPROC
#define wxSTC_ERLANG_NODE_NAME
#define wxSTC_ERLANG_COMMENT_FUNCTION
#define wxSTC_ERLANG_COMMENT_MODULE
#define wxSTC_ERLANG_COMMENT_DOC
#define wxSTC_ERLANG_COMMENT_DOC_MACRO
#define wxSTC_ERLANG_ATOM_QUOTED
#define wxSTC_ERLANG_MACRO_QUOTED
#define wxSTC_ERLANG_RECORD_QUOTED
#define wxSTC_ERLANG_NODE_NAME_QUOTED
#define wxSTC_ERLANG_BIFS
#define wxSTC_ERLANG_MODULES
#define wxSTC_ERLANG_MODULES_ATT
#endif //%wxchkver_2_9_5
#define wxSTC_ERLANG_UNKNOWN
// Lexical states for SCLEX_OCTAVE are identical to MatLab
// Lexical states for SCLEX_MSSQL
#define wxSTC_MSSQL_DEFAULT
#define wxSTC_MSSQL_COMMENT
#define wxSTC_MSSQL_LINE_COMMENT
#define wxSTC_MSSQL_NUMBER
#define wxSTC_MSSQL_STRING
#define wxSTC_MSSQL_OPERATOR
#define wxSTC_MSSQL_IDENTIFIER
#define wxSTC_MSSQL_VARIABLE
#define wxSTC_MSSQL_COLUMN_NAME
#define wxSTC_MSSQL_STATEMENT
#define wxSTC_MSSQL_DATATYPE
#define wxSTC_MSSQL_SYSTABLE
#define wxSTC_MSSQL_GLOBAL_VARIABLE
#define wxSTC_MSSQL_FUNCTION
#define wxSTC_MSSQL_STORED_PROCEDURE
#define wxSTC_MSSQL_DEFAULT_PREF_DATATYPE
#define wxSTC_MSSQL_COLUMN_NAME_2
// Lexical states for SCLEX_VERILOG
#define wxSTC_V_DEFAULT
#define wxSTC_V_COMMENT
#define wxSTC_V_COMMENTLINE
#define wxSTC_V_COMMENTLINEBANG
#define wxSTC_V_NUMBER
#define wxSTC_V_WORD
#define wxSTC_V_STRING
#define wxSTC_V_WORD2
#define wxSTC_V_WORD3
#define wxSTC_V_PREPROCESSOR
#define wxSTC_V_OPERATOR
#define wxSTC_V_IDENTIFIER
#define wxSTC_V_STRINGEOL
#define wxSTC_V_USER
// Lexical states for SCLEX_KIX
#define wxSTC_KIX_DEFAULT
#define wxSTC_KIX_COMMENT
#define wxSTC_KIX_STRING1
#define wxSTC_KIX_STRING2
#define wxSTC_KIX_NUMBER
#define wxSTC_KIX_VAR
#define wxSTC_KIX_MACRO
#define wxSTC_KIX_KEYWORD
#define wxSTC_KIX_FUNCTIONS
#define wxSTC_KIX_OPERATOR
#define wxSTC_KIX_IDENTIFIER
// Lexical states for SCLEX_GUI4CLI
#define wxSTC_GC_DEFAULT
#define wxSTC_GC_COMMENTLINE
#define wxSTC_GC_COMMENTBLOCK
#define wxSTC_GC_GLOBAL
#define wxSTC_GC_EVENT
#define wxSTC_GC_ATTRIBUTE
#define wxSTC_GC_CONTROL
#define wxSTC_GC_COMMAND
#define wxSTC_GC_STRING
#define wxSTC_GC_OPERATOR
// Lexical states for SCLEX_SPECMAN
#define wxSTC_SN_DEFAULT
#define wxSTC_SN_CODE
#define wxSTC_SN_COMMENTLINE
#define wxSTC_SN_COMMENTLINEBANG
#define wxSTC_SN_NUMBER
#define wxSTC_SN_WORD
#define wxSTC_SN_STRING
#define wxSTC_SN_WORD2
#define wxSTC_SN_WORD3
#define wxSTC_SN_PREPROCESSOR
#define wxSTC_SN_OPERATOR
#define wxSTC_SN_IDENTIFIER
#define wxSTC_SN_STRINGEOL
#define wxSTC_SN_REGEXTAG
#define wxSTC_SN_SIGNAL
#define wxSTC_SN_USER
// Lexical states for SCLEX_AU3
#define wxSTC_AU3_DEFAULT
#define wxSTC_AU3_COMMENT
#define wxSTC_AU3_COMMENTBLOCK
#define wxSTC_AU3_NUMBER
#define wxSTC_AU3_FUNCTION
#define wxSTC_AU3_KEYWORD
#define wxSTC_AU3_MACRO
#define wxSTC_AU3_STRING
#define wxSTC_AU3_OPERATOR
#define wxSTC_AU3_VARIABLE
#define wxSTC_AU3_SENT
#define wxSTC_AU3_PREPROCESSOR
#define wxSTC_AU3_SPECIAL
#define wxSTC_AU3_EXPAND
#define wxSTC_AU3_COMOBJ
%wxchkver_2_8_12 #define wxSTC_AU3_UDF
// Lexical states for SCLEX_APDL
#define wxSTC_APDL_DEFAULT
#define wxSTC_APDL_COMMENT
#define wxSTC_APDL_COMMENTBLOCK
#define wxSTC_APDL_NUMBER
#define wxSTC_APDL_STRING
#define wxSTC_APDL_OPERATOR
#define wxSTC_APDL_WORD
#define wxSTC_APDL_PROCESSOR
#define wxSTC_APDL_COMMAND
#define wxSTC_APDL_SLASHCOMMAND
#define wxSTC_APDL_STARCOMMAND
#define wxSTC_APDL_ARGUMENT
#define wxSTC_APDL_FUNCTION
// Lexical states for SCLEX_BASH
#define wxSTC_SH_DEFAULT
#define wxSTC_SH_ERROR
#define wxSTC_SH_COMMENTLINE
#define wxSTC_SH_NUMBER
#define wxSTC_SH_WORD
#define wxSTC_SH_STRING
#define wxSTC_SH_CHARACTER
#define wxSTC_SH_OPERATOR
#define wxSTC_SH_IDENTIFIER
#define wxSTC_SH_SCALAR
#define wxSTC_SH_PARAM
#define wxSTC_SH_BACKTICKS
#define wxSTC_SH_HERE_DELIM
#define wxSTC_SH_HERE_Q
// Lexical states for SCLEX_ASN1
#define wxSTC_ASN1_DEFAULT
#define wxSTC_ASN1_COMMENT
#define wxSTC_ASN1_IDENTIFIER
#define wxSTC_ASN1_STRING
#define wxSTC_ASN1_OID
#define wxSTC_ASN1_SCALAR
#define wxSTC_ASN1_KEYWORD
#define wxSTC_ASN1_ATTRIBUTE
#define wxSTC_ASN1_DESCRIPTOR
#define wxSTC_ASN1_TYPE
#define wxSTC_ASN1_OPERATOR
// Lexical states for SCLEX_VHDL
#define wxSTC_VHDL_DEFAULT
#define wxSTC_VHDL_COMMENT
#define wxSTC_VHDL_COMMENTLINEBANG
#define wxSTC_VHDL_NUMBER
#define wxSTC_VHDL_STRING
#define wxSTC_VHDL_OPERATOR
#define wxSTC_VHDL_IDENTIFIER
#define wxSTC_VHDL_STRINGEOL
#define wxSTC_VHDL_KEYWORD
#define wxSTC_VHDL_STDOPERATOR
#define wxSTC_VHDL_ATTRIBUTE
#define wxSTC_VHDL_STDFUNCTION
#define wxSTC_VHDL_STDPACKAGE
#define wxSTC_VHDL_STDTYPE
#define wxSTC_VHDL_USERWORD
// Lexical states for SCLEX_CAML
#define wxSTC_CAML_DEFAULT
#define wxSTC_CAML_IDENTIFIER
#define wxSTC_CAML_TAGNAME
#define wxSTC_CAML_KEYWORD
#define wxSTC_CAML_KEYWORD2
#define wxSTC_CAML_KEYWORD3
#define wxSTC_CAML_LINENUM
#define wxSTC_CAML_OPERATOR
#define wxSTC_CAML_NUMBER
#define wxSTC_CAML_CHAR
%wxchkver_2_9_5 #define wxSTC_CAML_WHITE
#define wxSTC_CAML_STRING
#define wxSTC_CAML_COMMENT
#define wxSTC_CAML_COMMENT1
#define wxSTC_CAML_COMMENT2
#define wxSTC_CAML_COMMENT3
// Lexical states for SCLEX_HASKELL
#define wxSTC_HA_DEFAULT
#define wxSTC_HA_IDENTIFIER
#define wxSTC_HA_KEYWORD
#define wxSTC_HA_NUMBER
#define wxSTC_HA_STRING
#define wxSTC_HA_CHARACTER
#define wxSTC_HA_CLASS
#define wxSTC_HA_MODULE
#define wxSTC_HA_CAPITAL
#define wxSTC_HA_DATA
#define wxSTC_HA_IMPORT
#define wxSTC_HA_OPERATOR
#define wxSTC_HA_INSTANCE
#define wxSTC_HA_COMMENTLINE
#define wxSTC_HA_COMMENTBLOCK
#define wxSTC_HA_COMMENTBLOCK2
#define wxSTC_HA_COMMENTBLOCK3
// Lexical states of SCLEX_TADS3
#define wxSTC_T3_DEFAULT
#define wxSTC_T3_X_DEFAULT
#define wxSTC_T3_PREPROCESSOR
#define wxSTC_T3_BLOCK_COMMENT
#define wxSTC_T3_LINE_COMMENT
#define wxSTC_T3_OPERATOR
#define wxSTC_T3_KEYWORD
#define wxSTC_T3_NUMBER
#define wxSTC_T3_IDENTIFIER
#define wxSTC_T3_S_STRING
#define wxSTC_T3_D_STRING
#define wxSTC_T3_X_STRING
#define wxSTC_T3_LIB_DIRECTIVE
#define wxSTC_T3_MSG_PARAM
#define wxSTC_T3_HTML_TAG
#define wxSTC_T3_HTML_DEFAULT
#define wxSTC_T3_HTML_STRING
#define wxSTC_T3_USER1
#define wxSTC_T3_USER2
#define wxSTC_T3_USER3
%wxchkver_2_9_5 #define wxSTC_T3_BRACE
// Lexical states for SCLEX_REBOL
#define wxSTC_REBOL_DEFAULT
#define wxSTC_REBOL_COMMENTLINE
#define wxSTC_REBOL_COMMENTBLOCK
#define wxSTC_REBOL_PREFACE
#define wxSTC_REBOL_OPERATOR
#define wxSTC_REBOL_CHARACTER
#define wxSTC_REBOL_QUOTEDSTRING
#define wxSTC_REBOL_BRACEDSTRING
#define wxSTC_REBOL_NUMBER
#define wxSTC_REBOL_PAIR
#define wxSTC_REBOL_TUPLE
#define wxSTC_REBOL_BINARY
#define wxSTC_REBOL_MONEY
#define wxSTC_REBOL_ISSUE
#define wxSTC_REBOL_TAG
#define wxSTC_REBOL_FILE
#define wxSTC_REBOL_EMAIL
#define wxSTC_REBOL_URL
#define wxSTC_REBOL_DATE
#define wxSTC_REBOL_TIME
#define wxSTC_REBOL_IDENTIFIER
#define wxSTC_REBOL_WORD
#define wxSTC_REBOL_WORD2
#define wxSTC_REBOL_WORD3
#define wxSTC_REBOL_WORD4
#define wxSTC_REBOL_WORD5
#define wxSTC_REBOL_WORD6
#define wxSTC_REBOL_WORD7
#define wxSTC_REBOL_WORD8
// Lexical states for SCLEX_SQL
#define wxSTC_SQL_DEFAULT
#define wxSTC_SQL_COMMENT
#define wxSTC_SQL_COMMENTLINE
#define wxSTC_SQL_COMMENTDOC
#define wxSTC_SQL_NUMBER
#define wxSTC_SQL_WORD
#define wxSTC_SQL_STRING
#define wxSTC_SQL_CHARACTER
#define wxSTC_SQL_SQLPLUS
#define wxSTC_SQL_SQLPLUS_PROMPT
#define wxSTC_SQL_OPERATOR
#define wxSTC_SQL_IDENTIFIER
#define wxSTC_SQL_SQLPLUS_COMMENT
#define wxSTC_SQL_COMMENTLINEDOC
#define wxSTC_SQL_WORD2
#define wxSTC_SQL_COMMENTDOCKEYWORD
#define wxSTC_SQL_COMMENTDOCKEYWORDERROR
#define wxSTC_SQL_USER1
#define wxSTC_SQL_USER2
#define wxSTC_SQL_USER3
#define wxSTC_SQL_USER4
#define wxSTC_SQL_QUOTEDIDENTIFIER
// Lexical states for SCLEX_SMALLTALK
#define wxSTC_ST_DEFAULT
#define wxSTC_ST_STRING
#define wxSTC_ST_NUMBER
#define wxSTC_ST_COMMENT
#define wxSTC_ST_SYMBOL
#define wxSTC_ST_BINARY
#define wxSTC_ST_BOOL
#define wxSTC_ST_SELF
#define wxSTC_ST_SUPER
#define wxSTC_ST_NIL
#define wxSTC_ST_GLOBAL
#define wxSTC_ST_RETURN
#define wxSTC_ST_SPECIAL
#define wxSTC_ST_KWSEND
#define wxSTC_ST_ASSIGN
#define wxSTC_ST_CHARACTER
#define wxSTC_ST_SPEC_SEL
// Lexical states for SCLEX_FLAGSHIP (clipper)
#define wxSTC_FS_DEFAULT
#define wxSTC_FS_COMMENT
#define wxSTC_FS_COMMENTLINE
#define wxSTC_FS_COMMENTDOC
#define wxSTC_FS_COMMENTLINEDOC
#define wxSTC_FS_COMMENTDOCKEYWORD
#define wxSTC_FS_COMMENTDOCKEYWORDERROR
#define wxSTC_FS_KEYWORD
#define wxSTC_FS_KEYWORD2
#define wxSTC_FS_KEYWORD3
#define wxSTC_FS_KEYWORD4
#define wxSTC_FS_NUMBER
#define wxSTC_FS_STRING
#define wxSTC_FS_PREPROCESSOR
#define wxSTC_FS_OPERATOR
#define wxSTC_FS_IDENTIFIER
#define wxSTC_FS_DATE
#define wxSTC_FS_STRINGEOL
#define wxSTC_FS_CONSTANT
#if %wxchkver_2_9_5
#define wxSTC_FS_WORDOPERATOR
#define wxSTC_FS_DISABLEDCODE
#define wxSTC_FS_DEFAULT_C
#define wxSTC_FS_COMMENTDOC_C
#define wxSTC_FS_COMMENTLINEDOC_C
#define wxSTC_FS_KEYWORD_C
#define wxSTC_FS_KEYWORD2_C
#define wxSTC_FS_NUMBER_C
#define wxSTC_FS_STRING_C
#define wxSTC_FS_PREPROCESSOR_C
#define wxSTC_FS_OPERATOR_C
#define wxSTC_FS_IDENTIFIER_C
#define wxSTC_FS_STRINGEOL_C
#endif //%wxchkver_2_9_5
//#define wxSTC_FS_ASM - Removed in 2.9.5
//#define wxSTC_FS_LABEL - Removed in 2.9.5
//#define wxSTC_FS_ERROR - Removed in 2.9.5
//#define wxSTC_FS_HEXNUMBER - Removed in 2.9.5
//#define wxSTC_FS_BINNUMBER - Removed in 2.9.5
// Lexical states for SCLEX_CSOUND
#define wxSTC_CSOUND_DEFAULT
#define wxSTC_CSOUND_COMMENT
#define wxSTC_CSOUND_NUMBER
#define wxSTC_CSOUND_OPERATOR
#define wxSTC_CSOUND_INSTR
#define wxSTC_CSOUND_IDENTIFIER
#define wxSTC_CSOUND_OPCODE
#define wxSTC_CSOUND_HEADERSTMT
#define wxSTC_CSOUND_USERKEYWORD
#define wxSTC_CSOUND_COMMENTBLOCK
#define wxSTC_CSOUND_PARAM
#define wxSTC_CSOUND_ARATE_VAR
#define wxSTC_CSOUND_KRATE_VAR
#define wxSTC_CSOUND_IRATE_VAR
#define wxSTC_CSOUND_GLOBAL_VAR
#define wxSTC_CSOUND_STRINGEOL
#if %wxchkver_2_8_12
// Lexical states for SCLEX_INNOSETUP
#define wxSTC_INNO_DEFAULT
#define wxSTC_INNO_COMMENT
#define wxSTC_INNO_KEYWORD
#define wxSTC_INNO_PARAMETER
#define wxSTC_INNO_SECTION
#define wxSTC_INNO_PREPROC
%wxchkver_2_9_5 #define wxSTC_INNO_INLINE_EXPANSION
#define wxSTC_INNO_COMMENT_PASCAL
#define wxSTC_INNO_KEYWORD_PASCAL
#define wxSTC_INNO_KEYWORD_USER
#define wxSTC_INNO_STRING_DOUBLE
#define wxSTC_INNO_STRING_SINGLE
#define wxSTC_INNO_IDENTIFIER
// Lexical states for SCLEX_OPAL
#define wxSTC_OPAL_SPACE
#define wxSTC_OPAL_COMMENT_BLOCK
#define wxSTC_OPAL_COMMENT_LINE
#define wxSTC_OPAL_INTEGER
#define wxSTC_OPAL_KEYWORD
#define wxSTC_OPAL_SORT
#define wxSTC_OPAL_STRING
#define wxSTC_OPAL_PAR
#define wxSTC_OPAL_BOOL_CONST
#define wxSTC_OPAL_DEFAULT
// Lexical states for SCLEX_SPICE
#define wxSTC_SPICE_DEFAULT
#define wxSTC_SPICE_IDENTIFIER
#define wxSTC_SPICE_KEYWORD
#define wxSTC_SPICE_KEYWORD2
#define wxSTC_SPICE_KEYWORD3
#define wxSTC_SPICE_NUMBER
#define wxSTC_SPICE_DELIMITER
#define wxSTC_SPICE_VALUE
#define wxSTC_SPICE_COMMENTLINE
#endif //%wxchkver_2_8_12
#if %wxchkver_2_9_5
// Lexical states for SCLEX_CMAKE
#define wxSTC_CMAKE_DEFAULT
#define wxSTC_CMAKE_COMMENT
#define wxSTC_CMAKE_STRINGDQ
#define wxSTC_CMAKE_STRINGLQ
#define wxSTC_CMAKE_STRINGRQ
#define wxSTC_CMAKE_COMMANDS
#define wxSTC_CMAKE_PARAMETERS
#define wxSTC_CMAKE_VARIABLE
#define wxSTC_CMAKE_USERDEFINED
#define wxSTC_CMAKE_WHILEDEF
#define wxSTC_CMAKE_FOREACHDEF
#define wxSTC_CMAKE_IFDEFINEDEF
#define wxSTC_CMAKE_MACRODEF
#define wxSTC_CMAKE_STRINGVAR
#define wxSTC_CMAKE_NUMBER
// Lexical states for SCLEX_GAP
#define wxSTC_GAP_DEFAULT
#define wxSTC_GAP_IDENTIFIER
#define wxSTC_GAP_KEYWORD
#define wxSTC_GAP_KEYWORD2
#define wxSTC_GAP_KEYWORD3
#define wxSTC_GAP_KEYWORD4
#define wxSTC_GAP_STRING
#define wxSTC_GAP_CHAR
#define wxSTC_GAP_OPERATOR
#define wxSTC_GAP_COMMENT
#define wxSTC_GAP_NUMBER
#define wxSTC_GAP_STRINGEOL
// Lexical state for SCLEX_PLM
#define wxSTC_PLM_DEFAULT
#define wxSTC_PLM_COMMENT
#define wxSTC_PLM_STRING
#define wxSTC_PLM_NUMBER
#define wxSTC_PLM_IDENTIFIER
#define wxSTC_PLM_OPERATOR
#define wxSTC_PLM_CONTROL
#define wxSTC_PLM_KEYWORD
// Lexical state for SCLEX_PROGRESS
#define wxSTC_4GL_DEFAULT
#define wxSTC_4GL_NUMBER
#define wxSTC_4GL_WORD
#define wxSTC_4GL_STRING
#define wxSTC_4GL_CHARACTER
#define wxSTC_4GL_PREPROCESSOR
#define wxSTC_4GL_OPERATOR
#define wxSTC_4GL_IDENTIFIER
#define wxSTC_4GL_BLOCK
#define wxSTC_4GL_END
#define wxSTC_4GL_COMMENT1
#define wxSTC_4GL_COMMENT2
#define wxSTC_4GL_COMMENT3
#define wxSTC_4GL_COMMENT4
#define wxSTC_4GL_COMMENT5
#define wxSTC_4GL_COMMENT6
#define wxSTC_4GL_DEFAULT_
#define wxSTC_4GL_NUMBER_
#define wxSTC_4GL_WORD_
#define wxSTC_4GL_STRING_
#define wxSTC_4GL_CHARACTER_
#define wxSTC_4GL_PREPROCESSOR_
#define wxSTC_4GL_OPERATOR_
#define wxSTC_4GL_IDENTIFIER_
#define wxSTC_4GL_BLOCK_
#define wxSTC_4GL_END_
#define wxSTC_4GL_COMMENT1_
#define wxSTC_4GL_COMMENT2_
#define wxSTC_4GL_COMMENT3_
#define wxSTC_4GL_COMMENT4_
#define wxSTC_4GL_COMMENT5_
#define wxSTC_4GL_COMMENT6_
// Lexical states for SCLEX_ABAQUS
#define wxSTC_ABAQUS_DEFAULT
#define wxSTC_ABAQUS_COMMENT
#define wxSTC_ABAQUS_COMMENTBLOCK
#define wxSTC_ABAQUS_NUMBER
#define wxSTC_ABAQUS_STRING
#define wxSTC_ABAQUS_OPERATOR
#define wxSTC_ABAQUS_WORD
#define wxSTC_ABAQUS_PROCESSOR
#define wxSTC_ABAQUS_COMMAND
#define wxSTC_ABAQUS_SLASHCOMMAND
#define wxSTC_ABAQUS_STARCOMMAND
#define wxSTC_ABAQUS_ARGUMENT
#define wxSTC_ABAQUS_FUNCTION
// Lexical states for SCLEX_ASYMPTOTE
#define wxSTC_ASY_DEFAULT
#define wxSTC_ASY_COMMENT
#define wxSTC_ASY_COMMENTLINE
#define wxSTC_ASY_NUMBER
#define wxSTC_ASY_WORD
#define wxSTC_ASY_STRING
#define wxSTC_ASY_CHARACTER
#define wxSTC_ASY_OPERATOR
#define wxSTC_ASY_IDENTIFIER
#define wxSTC_ASY_STRINGEOL
#define wxSTC_ASY_COMMENTLINEDOC
#define wxSTC_ASY_WORD2
// Lexical states for SCLEX_R
#define wxSTC_R_DEFAULT
#define wxSTC_R_COMMENT
#define wxSTC_R_KWORD
#define wxSTC_R_BASEKWORD
#define wxSTC_R_OTHERKWORD
#define wxSTC_R_NUMBER
#define wxSTC_R_STRING
#define wxSTC_R_STRING2
#define wxSTC_R_OPERATOR
#define wxSTC_R_IDENTIFIER
#define wxSTC_R_INFIX
#define wxSTC_R_INFIXEOL
// Lexical state for SCLEX_MAGIKSF
#define wxSTC_MAGIK_DEFAULT
#define wxSTC_MAGIK_COMMENT
#define wxSTC_MAGIK_HYPER_COMMENT
#define wxSTC_MAGIK_STRING
#define wxSTC_MAGIK_CHARACTER
#define wxSTC_MAGIK_NUMBER
#define wxSTC_MAGIK_IDENTIFIER
#define wxSTC_MAGIK_OPERATOR
#define wxSTC_MAGIK_FLOW
#define wxSTC_MAGIK_CONTAINER
#define wxSTC_MAGIK_BRACKET_BLOCK
#define wxSTC_MAGIK_BRACE_BLOCK
#define wxSTC_MAGIK_SQBRACKET_BLOCK
#define wxSTC_MAGIK_UNKNOWN_KEYWORD
#define wxSTC_MAGIK_KEYWORD
#define wxSTC_MAGIK_PRAGMA
#define wxSTC_MAGIK_SYMBOL
// Lexical state for SCLEX_POWERSHELL
#define wxSTC_POWERSHELL_DEFAULT
#define wxSTC_POWERSHELL_COMMENT
#define wxSTC_POWERSHELL_STRING
#define wxSTC_POWERSHELL_CHARACTER
#define wxSTC_POWERSHELL_NUMBER
#define wxSTC_POWERSHELL_VARIABLE
#define wxSTC_POWERSHELL_OPERATOR
#define wxSTC_POWERSHELL_IDENTIFIER
#define wxSTC_POWERSHELL_KEYWORD
#define wxSTC_POWERSHELL_CMDLET
#define wxSTC_POWERSHELL_ALIAS
#define wxSTC_POWERSHELL_FUNCTION
#define wxSTC_POWERSHELL_USER1
#define wxSTC_POWERSHELL_COMMENTSTREAM
// Lexical state for SCLEX_MYSQL
#define wxSTC_MYSQL_DEFAULT
#define wxSTC_MYSQL_COMMENT
#define wxSTC_MYSQL_COMMENTLINE
#define wxSTC_MYSQL_VARIABLE
#define wxSTC_MYSQL_SYSTEMVARIABLE
#define wxSTC_MYSQL_KNOWNSYSTEMVARIABLE
#define wxSTC_MYSQL_NUMBER
#define wxSTC_MYSQL_MAJORKEYWORD
#define wxSTC_MYSQL_KEYWORD
#define wxSTC_MYSQL_DATABASEOBJECT
#define wxSTC_MYSQL_PROCEDUREKEYWORD
#define wxSTC_MYSQL_STRING
#define wxSTC_MYSQL_SQSTRING
#define wxSTC_MYSQL_DQSTRING
#define wxSTC_MYSQL_OPERATOR
#define wxSTC_MYSQL_FUNCTION
#define wxSTC_MYSQL_IDENTIFIER
#define wxSTC_MYSQL_QUOTEDIDENTIFIER
#define wxSTC_MYSQL_USER1
#define wxSTC_MYSQL_USER2
#define wxSTC_MYSQL_USER3
#define wxSTC_MYSQL_HIDDENCOMMAND
// Lexical state for SCLEX_PO
#define wxSTC_PO_DEFAULT
#define wxSTC_PO_COMMENT
#define wxSTC_PO_MSGID
#define wxSTC_PO_MSGID_TEXT
#define wxSTC_PO_MSGSTR
#define wxSTC_PO_MSGSTR_TEXT
#define wxSTC_PO_MSGCTXT
#define wxSTC_PO_MSGCTXT_TEXT
#define wxSTC_PO_FUZZY
// Lexical states for SCLEX_PASCAL
#define wxSTC_PAS_DEFAULT
#define wxSTC_PAS_IDENTIFIER
#define wxSTC_PAS_COMMENT
#define wxSTC_PAS_COMMENT2
#define wxSTC_PAS_COMMENTLINE
#define wxSTC_PAS_PREPROCESSOR
#define wxSTC_PAS_PREPROCESSOR2
#define wxSTC_PAS_NUMBER
#define wxSTC_PAS_HEXNUMBER
#define wxSTC_PAS_WORD
#define wxSTC_PAS_STRING
#define wxSTC_PAS_STRINGEOL
#define wxSTC_PAS_CHARACTER
#define wxSTC_PAS_OPERATOR
#define wxSTC_PAS_ASM
// Lexical state for SCLEX_SORCUS
#define wxSTC_SORCUS_DEFAULT
#define wxSTC_SORCUS_COMMAND
#define wxSTC_SORCUS_PARAMETER
#define wxSTC_SORCUS_COMMENTLINE
#define wxSTC_SORCUS_STRING
#define wxSTC_SORCUS_STRINGEOL
#define wxSTC_SORCUS_IDENTIFIER
#define wxSTC_SORCUS_OPERATOR
#define wxSTC_SORCUS_NUMBER
#define wxSTC_SORCUS_CONSTANT
// Lexical state for SCLEX_POWERPRO
#define wxSTC_POWERPRO_DEFAULT
#define wxSTC_POWERPRO_COMMENTBLOCK
#define wxSTC_POWERPRO_COMMENTLINE
#define wxSTC_POWERPRO_NUMBER
#define wxSTC_POWERPRO_WORD
#define wxSTC_POWERPRO_WORD2
#define wxSTC_POWERPRO_WORD3
#define wxSTC_POWERPRO_WORD4
#define wxSTC_POWERPRO_DOUBLEQUOTEDSTRING
#define wxSTC_POWERPRO_SINGLEQUOTEDSTRING
#define wxSTC_POWERPRO_LINECONTINUE
#define wxSTC_POWERPRO_OPERATOR
#define wxSTC_POWERPRO_IDENTIFIER
#define wxSTC_POWERPRO_STRINGEOL
#define wxSTC_POWERPRO_VERBATIM
#define wxSTC_POWERPRO_ALTQUOTE
#define wxSTC_POWERPRO_FUNCTION
// Lexical states for SCLEX_SML
#define wxSTC_SML_DEFAULT
#define wxSTC_SML_IDENTIFIER
#define wxSTC_SML_TAGNAME
#define wxSTC_SML_KEYWORD
#define wxSTC_SML_KEYWORD2
#define wxSTC_SML_KEYWORD3
#define wxSTC_SML_LINENUM
#define wxSTC_SML_OPERATOR
#define wxSTC_SML_NUMBER
#define wxSTC_SML_CHAR
#define wxSTC_SML_STRING
#define wxSTC_SML_COMMENT
#define wxSTC_SML_COMMENT1
#define wxSTC_SML_COMMENT2
#define wxSTC_SML_COMMENT3
// Lexical state for SCLEX_MARKDOWN
#define wxSTC_MARKDOWN_DEFAULT
#define wxSTC_MARKDOWN_LINE_BEGIN
#define wxSTC_MARKDOWN_STRONG1
#define wxSTC_MARKDOWN_STRONG2
#define wxSTC_MARKDOWN_EM1
#define wxSTC_MARKDOWN_EM2
#define wxSTC_MARKDOWN_HEADER1
#define wxSTC_MARKDOWN_HEADER2
#define wxSTC_MARKDOWN_HEADER3
#define wxSTC_MARKDOWN_HEADER4
#define wxSTC_MARKDOWN_HEADER5
#define wxSTC_MARKDOWN_HEADER6
#define wxSTC_MARKDOWN_PRECHAR
#define wxSTC_MARKDOWN_ULIST_ITEM
#define wxSTC_MARKDOWN_OLIST_ITEM
#define wxSTC_MARKDOWN_BLOCKQUOTE
#define wxSTC_MARKDOWN_STRIKEOUT
#define wxSTC_MARKDOWN_HRULE
#define wxSTC_MARKDOWN_LINK
#define wxSTC_MARKDOWN_CODE
#define wxSTC_MARKDOWN_CODE2
#define wxSTC_MARKDOWN_CODEBK
// Lexical state for SCLEX_TXT2TAGS
#define wxSTC_TXT2TAGS_DEFAULT
#define wxSTC_TXT2TAGS_LINE_BEGIN
#define wxSTC_TXT2TAGS_STRONG1
#define wxSTC_TXT2TAGS_STRONG2
#define wxSTC_TXT2TAGS_EM1
#define wxSTC_TXT2TAGS_EM2
#define wxSTC_TXT2TAGS_HEADER1
#define wxSTC_TXT2TAGS_HEADER2
#define wxSTC_TXT2TAGS_HEADER3
#define wxSTC_TXT2TAGS_HEADER4
#define wxSTC_TXT2TAGS_HEADER5
#define wxSTC_TXT2TAGS_HEADER6
#define wxSTC_TXT2TAGS_PRECHAR
#define wxSTC_TXT2TAGS_ULIST_ITEM
#define wxSTC_TXT2TAGS_OLIST_ITEM
#define wxSTC_TXT2TAGS_BLOCKQUOTE
#define wxSTC_TXT2TAGS_STRIKEOUT
#define wxSTC_TXT2TAGS_HRULE
#define wxSTC_TXT2TAGS_LINK
#define wxSTC_TXT2TAGS_CODE
#define wxSTC_TXT2TAGS_CODE2
#define wxSTC_TXT2TAGS_CODEBK
#define wxSTC_TXT2TAGS_COMMENT
#define wxSTC_TXT2TAGS_OPTION
#define wxSTC_TXT2TAGS_PREPROC
#define wxSTC_TXT2TAGS_POSTPROC
// Lexical states for SCLEX_A68K
#define wxSTC_A68K_DEFAULT
#define wxSTC_A68K_COMMENT
#define wxSTC_A68K_NUMBER_DEC
#define wxSTC_A68K_NUMBER_BIN
#define wxSTC_A68K_NUMBER_HEX
#define wxSTC_A68K_STRING1
#define wxSTC_A68K_OPERATOR
#define wxSTC_A68K_CPUINSTRUCTION
#define wxSTC_A68K_EXTINSTRUCTION
#define wxSTC_A68K_REGISTER
#define wxSTC_A68K_DIRECTIVE
#define wxSTC_A68K_MACRO_ARG
#define wxSTC_A68K_LABEL
#define wxSTC_A68K_STRING2
#define wxSTC_A68K_IDENTIFIER
#define wxSTC_A68K_MACRO_DECLARATION
#define wxSTC_A68K_COMMENT_WORD
#define wxSTC_A68K_COMMENT_SPECIAL
#define wxSTC_A68K_COMMENT_DOXYGEN
// Lexical states for SCLEX_MODULA
#define wxSTC_MODULA_DEFAULT
#define wxSTC_MODULA_COMMENT
#define wxSTC_MODULA_DOXYCOMM
#define wxSTC_MODULA_DOXYKEY
#define wxSTC_MODULA_KEYWORD
#define wxSTC_MODULA_RESERVED
#define wxSTC_MODULA_NUMBER
#define wxSTC_MODULA_BASENUM
#define wxSTC_MODULA_FLOAT
#define wxSTC_MODULA_STRING
#define wxSTC_MODULA_STRSPEC
#define wxSTC_MODULA_CHAR
#define wxSTC_MODULA_CHARSPEC
#define wxSTC_MODULA_PROC
#define wxSTC_MODULA_PRAGMA
#define wxSTC_MODULA_PRGKEY
#define wxSTC_MODULA_OPERATOR
#define wxSTC_MODULA_BADSTR
// Lexical states for SCLEX_COFFEESCRIPT
#define wxSTC_COFFEESCRIPT_DEFAULT
#define wxSTC_COFFEESCRIPT_COMMENT
#define wxSTC_COFFEESCRIPT_COMMENTLINE
#define wxSTC_COFFEESCRIPT_COMMENTDOC
#define wxSTC_COFFEESCRIPT_NUMBER
#define wxSTC_COFFEESCRIPT_WORD
#define wxSTC_COFFEESCRIPT_STRING
#define wxSTC_COFFEESCRIPT_CHARACTER
#define wxSTC_COFFEESCRIPT_UUID
#define wxSTC_COFFEESCRIPT_PREPROCESSOR
#define wxSTC_COFFEESCRIPT_OPERATOR
#define wxSTC_COFFEESCRIPT_IDENTIFIER
#define wxSTC_COFFEESCRIPT_STRINGEOL
#define wxSTC_COFFEESCRIPT_VERBATIM
#define wxSTC_COFFEESCRIPT_REGEX
#define wxSTC_COFFEESCRIPT_COMMENTLINEDOC
#define wxSTC_COFFEESCRIPT_WORD2
#define wxSTC_COFFEESCRIPT_COMMENTDOCKEYWORD
#define wxSTC_COFFEESCRIPT_COMMENTDOCKEYWORDERROR
#define wxSTC_COFFEESCRIPT_GLOBALCLASS
#define wxSTC_COFFEESCRIPT_STRINGRAW
#define wxSTC_COFFEESCRIPT_TRIPLEVERBATIM
#define wxSTC_COFFEESCRIPT_HASHQUOTEDSTRING
#define wxSTC_COFFEESCRIPT_COMMENTBLOCK
#define wxSTC_COFFEESCRIPT_VERBOSE_REGEX
#define wxSTC_COFFEESCRIPT_VERBOSE_REGEX_COMMENT
// Lexical states for SCLEX_AVS
#define wxSTC_AVS_DEFAULT
#define wxSTC_AVS_COMMENTBLOCK
#define wxSTC_AVS_COMMENTBLOCKN
#define wxSTC_AVS_COMMENTLINE
#define wxSTC_AVS_NUMBER
#define wxSTC_AVS_OPERATOR
#define wxSTC_AVS_IDENTIFIER
#define wxSTC_AVS_STRING
#define wxSTC_AVS_TRIPLESTRING
#define wxSTC_AVS_KEYWORD
#define wxSTC_AVS_FILTER
#define wxSTC_AVS_PLUGIN
#define wxSTC_AVS_FUNCTION
#define wxSTC_AVS_CLIPPROP
#define wxSTC_AVS_USERDFN
// Lexical states for SCLEX_ECL
#define wxSTC_ECL_DEFAULT
#define wxSTC_ECL_COMMENT
#define wxSTC_ECL_COMMENTLINE
#define wxSTC_ECL_NUMBER
#define wxSTC_ECL_STRING
#define wxSTC_ECL_WORD0
#define wxSTC_ECL_OPERATOR
#define wxSTC_ECL_CHARACTER
#define wxSTC_ECL_UUID
#define wxSTC_ECL_PREPROCESSOR
#define wxSTC_ECL_UNKNOWN
#define wxSTC_ECL_IDENTIFIER
#define wxSTC_ECL_STRINGEOL
#define wxSTC_ECL_VERBATIM
#define wxSTC_ECL_REGEX
#define wxSTC_ECL_COMMENTLINEDOC
#define wxSTC_ECL_WORD1
#define wxSTC_ECL_COMMENTDOCKEYWORD
#define wxSTC_ECL_COMMENTDOCKEYWORDERROR
#define wxSTC_ECL_WORD2
#define wxSTC_ECL_WORD3
#define wxSTC_ECL_WORD4
#define wxSTC_ECL_WORD5
#define wxSTC_ECL_COMMENTDOC
#define wxSTC_ECL_ADDED
#define wxSTC_ECL_DELETED
#define wxSTC_ECL_CHANGED
#define wxSTC_ECL_MOVED
// Lexical states for SCLEX_OSCRIPT
#define wxSTC_OSCRIPT_DEFAULT
#define wxSTC_OSCRIPT_LINE_COMMENT
#define wxSTC_OSCRIPT_BLOCK_COMMENT
#define wxSTC_OSCRIPT_DOC_COMMENT
#define wxSTC_OSCRIPT_PREPROCESSOR
#define wxSTC_OSCRIPT_NUMBER
#define wxSTC_OSCRIPT_SINGLEQUOTE_STRING
#define wxSTC_OSCRIPT_DOUBLEQUOTE_STRING
#define wxSTC_OSCRIPT_CONSTANT
#define wxSTC_OSCRIPT_IDENTIFIER
#define wxSTC_OSCRIPT_GLOBAL
#define wxSTC_OSCRIPT_KEYWORD
#define wxSTC_OSCRIPT_OPERATOR
#define wxSTC_OSCRIPT_LABEL
#define wxSTC_OSCRIPT_TYPE
#define wxSTC_OSCRIPT_FUNCTION
#define wxSTC_OSCRIPT_OBJECT
#define wxSTC_OSCRIPT_PROPERTY
#define wxSTC_OSCRIPT_METHOD
// Lexical states for SCLEX_VISUALPROLOG
#define wxSTC_VISUALPROLOG_DEFAULT
#define wxSTC_VISUALPROLOG_KEY_MAJOR
#define wxSTC_VISUALPROLOG_KEY_MINOR
#define wxSTC_VISUALPROLOG_KEY_DIRECTIVE
#define wxSTC_VISUALPROLOG_COMMENT_BLOCK
#define wxSTC_VISUALPROLOG_COMMENT_LINE
#define wxSTC_VISUALPROLOG_COMMENT_KEY
#define wxSTC_VISUALPROLOG_COMMENT_KEY_ERROR
#define wxSTC_VISUALPROLOG_IDENTIFIER
#define wxSTC_VISUALPROLOG_VARIABLE
#define wxSTC_VISUALPROLOG_ANONYMOUS
#define wxSTC_VISUALPROLOG_NUMBER
#define wxSTC_VISUALPROLOG_OPERATOR
#define wxSTC_VISUALPROLOG_CHARACTER
#define wxSTC_VISUALPROLOG_CHARACTER_TOO_MANY
#define wxSTC_VISUALPROLOG_CHARACTER_ESCAPE_ERROR
#define wxSTC_VISUALPROLOG_STRING
#define wxSTC_VISUALPROLOG_STRING_ESCAPE
#define wxSTC_VISUALPROLOG_STRING_ESCAPE_ERROR
#define wxSTC_VISUALPROLOG_STRING_EOL_OPEN
#define wxSTC_VISUALPROLOG_STRING_VERBATIM
#define wxSTC_VISUALPROLOG_STRING_VERBATIM_SPECIAL
#define wxSTC_VISUALPROLOG_STRING_VERBATIM_EOL
#endif //%wxchkver_2_9_5
//-----------------------------------------
// Commands that can be bound to keystrokes
// Redoes the next action on the undo history.
#define wxSTC_CMD_REDO
// Select all the text in the document.
#define wxSTC_CMD_SELECTALL
// Undo one action in the undo history.
#define wxSTC_CMD_UNDO
// Cut the selection to the clipboard.
#define wxSTC_CMD_CUT
// Copy the selection to the clipboard.
#define wxSTC_CMD_COPY
// Paste the contents of the clipboard into the document replacing the selection.
#define wxSTC_CMD_PASTE
// Clear the selection.
#define wxSTC_CMD_CLEAR
// Move caret down one line.
#define wxSTC_CMD_LINEDOWN
// Move caret down one line extending selection to new caret position.
#define wxSTC_CMD_LINEDOWNEXTEND
// Move caret up one line.
#define wxSTC_CMD_LINEUP
// Move caret up one line extending selection to new caret position.
#define wxSTC_CMD_LINEUPEXTEND
// Move caret left one character.
#define wxSTC_CMD_CHARLEFT
// Move caret left one character extending selection to new caret position.
#define wxSTC_CMD_CHARLEFTEXTEND
// Move caret right one character.
#define wxSTC_CMD_CHARRIGHT
// Move caret right one character extending selection to new caret position.
#define wxSTC_CMD_CHARRIGHTEXTEND
// Move caret left one word.
#define wxSTC_CMD_WORDLEFT
// Move caret left one word extending selection to new caret position.
#define wxSTC_CMD_WORDLEFTEXTEND
// Move caret right one word.
#define wxSTC_CMD_WORDRIGHT
// Move caret right one word extending selection to new caret position.
#define wxSTC_CMD_WORDRIGHTEXTEND
// Move caret to first position on line.
#define wxSTC_CMD_HOME
// Move caret to first position on line extending selection to new caret position.
#define wxSTC_CMD_HOMEEXTEND
// Move caret to last position on line.
#define wxSTC_CMD_LINEEND
// Move caret to last position on line extending selection to new caret position.
#define wxSTC_CMD_LINEENDEXTEND
// Move caret to first position in document.
#define wxSTC_CMD_DOCUMENTSTART
// Move caret to first position in document extending selection to new caret position.
#define wxSTC_CMD_DOCUMENTSTARTEXTEND
// Move caret to last position in document.
#define wxSTC_CMD_DOCUMENTEND
// Move caret to last position in document extending selection to new caret position.
#define wxSTC_CMD_DOCUMENTENDEXTEND
// Move caret one page up.
#define wxSTC_CMD_PAGEUP
// Move caret one page up extending selection to new caret position.
#define wxSTC_CMD_PAGEUPEXTEND
// Move caret one page down.
#define wxSTC_CMD_PAGEDOWN
// Move caret one page down extending selection to new caret position.
#define wxSTC_CMD_PAGEDOWNEXTEND
// Switch from insert to overtype mode or the reverse.
#define wxSTC_CMD_EDITTOGGLEOVERTYPE
// Cancel any modes such as call tip or auto-completion list display.
#define wxSTC_CMD_CANCEL
// Delete the selection or if no selection, the character before the caret.
#define wxSTC_CMD_DELETEBACK
// If selection is empty or all on one line replace the selection with a tab character.
// If more than one line selected, indent the lines.
#define wxSTC_CMD_TAB
// Dedent the selected lines.
#define wxSTC_CMD_BACKTAB
// Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
#define wxSTC_CMD_NEWLINE
// Insert a Form Feed character.
#define wxSTC_CMD_FORMFEED
// Move caret to before first visible character on line.
// If already there move to first character on line.
#define wxSTC_CMD_VCHOME
// Like VCHome but extending selection to new caret position.
#define wxSTC_CMD_VCHOMEEXTEND
// Magnify the displayed text by increasing the sizes by 1 point.
#define wxSTC_CMD_ZOOMIN
// Make the displayed text smaller by decreasing the sizes by 1 point.
#define wxSTC_CMD_ZOOMOUT
// Delete the word to the left of the caret.
#define wxSTC_CMD_DELWORDLEFT
// Delete the word to the right of the caret.
#define wxSTC_CMD_DELWORDRIGHT
// Delete the word to the right of the caret, but not the trailing non-word characters.
%wxchkver_2_9_5 #define wxSTC_CMD_DELWORDRIGHTEND
// Cut the line containing the caret.
#define wxSTC_CMD_LINECUT
// Delete the line containing the caret.
#define wxSTC_CMD_LINEDELETE
// Switch the current line with the previous.
#define wxSTC_CMD_LINETRANSPOSE
// Duplicate the current line.
#define wxSTC_CMD_LINEDUPLICATE
// Transform the selection to lower case.
#define wxSTC_CMD_LOWERCASE
// Transform the selection to upper case.
#define wxSTC_CMD_UPPERCASE
// Scroll the document down, keeping the caret visible.
#define wxSTC_CMD_LINESCROLLDOWN
// Scroll the document up, keeping the caret visible.
#define wxSTC_CMD_LINESCROLLUP
// Delete the selection or if no selection, the character before the caret.
// Will not delete the character before at the start of a line.
#define wxSTC_CMD_DELETEBACKNOTLINE
// Move caret to first position on display line.
#define wxSTC_CMD_HOMEDISPLAY
// Move caret to first position on display line extending selection to
// new caret position.
#define wxSTC_CMD_HOMEDISPLAYEXTEND
// Move caret to last position on display line.
#define wxSTC_CMD_LINEENDDISPLAY
// Move caret to last position on display line extending selection to new
// caret position.
#define wxSTC_CMD_LINEENDDISPLAYEXTEND
// These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?
// except they behave differently when word-wrap is enabled:
// They go first to the start / end of the display line, like (Home|LineEnd)Display
// The difference is that, the cursor is already at the point, it goes on to the start
// or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
#define wxSTC_CMD_HOMEWRAP
#define wxSTC_CMD_HOMEWRAPEXTEND
#define wxSTC_CMD_LINEENDWRAP
#define wxSTC_CMD_LINEENDWRAPEXTEND
#define wxSTC_CMD_VCHOMEWRAP
#define wxSTC_CMD_VCHOMEWRAPEXTEND
// Copy the line containing the caret.
#define wxSTC_CMD_LINECOPY
// Move to the previous change in capitalisation.
#define wxSTC_CMD_WORDPARTLEFT
// Move to the previous change in capitalisation extending selection
// to new caret position.
#define wxSTC_CMD_WORDPARTLEFTEXTEND
// Move to the change next in capitalisation.
#define wxSTC_CMD_WORDPARTRIGHT
// Move to the next change in capitalisation extending selection
// to new caret position.
#define wxSTC_CMD_WORDPARTRIGHTEXTEND
// Delete back from the current position to the start of the line.
#define wxSTC_CMD_DELLINELEFT
// Delete forwards from the current position to the end of the line.
#define wxSTC_CMD_DELLINERIGHT
// Move caret between paragraphs (delimited by empty lines).
#define wxSTC_CMD_PARADOWN
#define wxSTC_CMD_PARADOWNEXTEND
#define wxSTC_CMD_PARAUP
#define wxSTC_CMD_PARAUPEXTEND
// Move caret down one line, extending rectangular selection to new caret position.
#define wxSTC_CMD_LINEDOWNRECTEXTEND
// Move caret up one line, extending rectangular selection to new caret position.
#define wxSTC_CMD_LINEUPRECTEXTEND
// Move caret left one character, extending rectangular selection to new caret position.
#define wxSTC_CMD_CHARLEFTRECTEXTEND
// Move caret right one character, extending rectangular selection to new caret position.
#define wxSTC_CMD_CHARRIGHTRECTEXTEND
// Move caret to first position on line, extending rectangular selection to new caret position.
#define wxSTC_CMD_HOMERECTEXTEND
// Move caret to before first visible character on line.
// If already there move to first character on line.
// In either case, extend rectangular selection to new caret position.
#define wxSTC_CMD_VCHOMERECTEXTEND
// Move caret to last position on line, extending rectangular selection to new caret position.
#define wxSTC_CMD_LINEENDRECTEXTEND
// Move caret one page up, extending rectangular selection to new caret position.
#define wxSTC_CMD_PAGEUPRECTEXTEND
// Move caret one page down, extending rectangular selection to new caret position.
#define wxSTC_CMD_PAGEDOWNRECTEXTEND
// Move caret to top of page, or one page up if already at top of page.
#define wxSTC_CMD_STUTTEREDPAGEUP
// Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
#define wxSTC_CMD_STUTTEREDPAGEUPEXTEND
// Move caret to bottom of page, or one page down if already at bottom of page.
#define wxSTC_CMD_STUTTEREDPAGEDOWN
// Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
#define wxSTC_CMD_STUTTEREDPAGEDOWNEXTEND
// Move caret left one word, position cursor at end of word.
#define wxSTC_CMD_WORDLEFTEND
// Move caret left one word, position cursor at end of word, extending selection to new caret position.
#define wxSTC_CMD_WORDLEFTENDEXTEND
// Move caret right one word, position cursor at end of word.
#define wxSTC_CMD_WORDRIGHTEND
// Move caret right one word, position cursor at end of word, extending selection to new caret position.
#define wxSTC_CMD_WORDRIGHTENDEXTEND
// Centre current line in window.
%wxchkver_2_9_5 #define wxSTC_CMD_VERTICALCENTRECARET
// Move the selected lines up one line, shifting the line above after the selection
%wxchkver_2_9_5 #define wxSTC_CMD_MOVESELECTEDLINESUP
// Move the selected lines down one line, shifting the line below before the selection
%wxchkver_2_9_5 #define wxSTC_CMD_MOVESELECTEDLINESDOWN
// Scroll to start of document.
%wxchkver_2_9_5 #define wxSTC_CMD_SCROLLTOSTART
// Scroll to end of document.
%wxchkver_2_9_5 #define wxSTC_CMD_SCROLLTOEND
///////////////////////////////////////////////////////////////////////////////
// wxStyledTextCtrl
class wxStyledTextCtrl : public wxControl
{

> wxStyledTextCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString &name = "wxStyledTextCtrl" );
> //}}}
> //----------------------------------------------------------------------
> // BEGIN generated section. The following code is automatically generated
> // by gen_iface.py. Do not edit this file. Edit stc.h.in instead
> // and regenerate
> // Add text to the document at current position.
> void AddText(const wxString& text);
> // Add array of cells to document.
> //void AddStyledText(const wxMemoryBuffer& data);
> // Insert string at a position.
> void InsertText(int pos, const wxString& text);
> // Delete all text in the document.
> void ClearAll();
> // Delete a range of text in the document.
> %wxchkver_2_9_5 void DeleteRange(int pos, int deleteLength);
> // Set all style bytes to 0, remove all folding information.
> void ClearDocumentStyle();
> // Returns the number of bytes in the document.
> int GetLength() const;
> // Returns the character byte at the position.
> int GetCharAt(int pos) const;
> // Returns the position of the caret.
> int GetCurrentPos() const;
> // Returns the position of the opposite end of the selection to the caret.
> int GetAnchor() const;
> // Returns the style byte at the position.
> int GetStyleAt(int pos) const;
> // Redoes the next action on the undo history.
> void Redo();
> // Choose between collecting actions into the undo
> // history and discarding them.
> void SetUndoCollection(bool collectUndo);
> // Select all the text in the document.
> void SelectAll();
> // Remember the current position in the undo history as the position
> // at which the document was saved.
> void SetSavePoint();
> // Retrieve a buffer of cells.
> //wxMemoryBuffer GetStyledText(int startPos, int endPos);
> // Are there any redoable actions in the undo history?
> bool CanRedo() const;
> // Retrieve the line number at which a particular marker is located.
> int MarkerLineFromHandle(int handle);
> // Delete a marker.
> void MarkerDeleteHandle(int handle);
> // Is undo history being collected?
> bool GetUndoCollection() const;
> // Are white space characters currently visible?
> // Returns one of SCWS_* constants.
> int GetViewWhiteSpace() const;
> // Make white space characters invisible, always visible or visible outside indentation.
> void SetViewWhiteSpace(int viewWS);
> // Find the position from a point within the window.
> int PositionFromPoint(const wxPoint& pt) const;
> // Find the position from a point within the window but return
> // INVALID_POSITION if not close to text.
> int PositionFromPointClose(int x, int y);
> // Set caret to start of a line and ensure it is visible.
> void GotoLine(int line);
> // Set caret to a position and ensure it is visible.
> void GotoPos(int pos);
> // Set the selection anchor to a position. The anchor is the opposite
> // end of the selection from the caret.
> void SetAnchor(int posAnchor);
> // Retrieve the text of the line containing the caret.
> // Returns the index of the caret on the line.
> //#ifdef SWIG
> // wxString GetCurLine(int* OUTPUT);
> //#else
> // %override [int linePos] wxStyledTextCtrl::GetCurLine( );
> // C++ Func: wxString GetCurLine(int* linePos=NULL);
> wxString GetCurLine();
> //#endif
> // Retrieve the position of the last correctly styled character.
> int GetEndStyled() const;
> // Convert all line endings in the document to one mode.
> void ConvertEOLs(int eolMode);
> // Retrieve the current end of line mode - one of CRLF, CR, or LF.
> int GetEOLMode() const;
> // Set the current end of line mode.
> void SetEOLMode(int eolMode);
> // Set the current styling position to pos and the styling mask to mask.
> // The styling mask can be used to protect some bits in each styling byte from modification.
> void StartStyling(int pos, unsigned int mask); // wxLua - mask is unsigned to keep all the bits
> // Change style from current styling position for length characters to a style
> // and move the current styling position to after this newly styled segment.
> void SetStyling(int length, int style);
> // Is drawing done first into a buffer or direct to the screen?
> bool GetBufferedDraw() const;
> // If drawing is buffered then each line of text is drawn into a bitmap buffer
> // before drawing it to the screen to avoid flicker.
> void SetBufferedDraw(bool buffered);
> // Change the visible size of a tab to be a multiple of the width of a space character.
> void SetTabWidth(int tabWidth);
> // Retrieve the visible size of a tab.
> int GetTabWidth() const;
> // Set the code page used to interpret the bytes of the document as characters.
> void SetCodePage(int codePage);
> // Set the symbol used for a particular marker number,
> // and optionally the fore and background colours.
> void MarkerDefine(int markerNumber, int markerSymbol, const wxColour& foreground = wxNullColour, const wxColour& background = wxNullColour);
> // Set the foreground colour used for a particular marker number.
> void MarkerSetForeground(int markerNumber, const wxColour& fore);
> // Set the background colour used for a particular marker number.
> void MarkerSetBackground(int markerNumber, const wxColour& back);
> // Set the background colour used for a particular marker number when its folding block is selected.
> %wxchkver_2_9_5 void MarkerSetBackgroundSelected(int markerNumber, const wxColour& back);
> // Enable/disable highlight for current folding bloc (smallest one that contains the caret)
> %wxchkver_2_9_5 void MarkerEnableHighlight(bool enabled);
> // Add a marker to a line, returning an ID which can be used to find or delete the marker.
> int MarkerAdd(int line, int markerNumber);
> // Delete a marker from a line.
> void MarkerDelete(int line, int markerNumber);
> // Delete all markers with a particular number from all lines.
> void MarkerDeleteAll(int markerNumber);
> // Get a bit mask of all the markers set on a line.
> unsigned int MarkerGet(int line); // wxLua - mask is unsigned to keep all the bits
> // Find the next line at or after lineStart that includes a marker in mask.
> // Return -1 when no more lines.
> int MarkerNext(int lineStart, unsigned int markerMask); // wxLua - mask is unsigned to keep all the bits
> // Find the previous line before lineStart that includes a marker in mask.
> int MarkerPrevious(int lineStart, unsigned int markerMask); // wxLua - mask is unsigned to keep all the bits
> // Define a marker from a bitmap
> void MarkerDefineBitmap(int markerNumber, const wxBitmap& bmp);
> // Add a set of markers to a line.
> void MarkerAddSet(int line, int set);
> // Set the alpha used for a marker that is drawn in the text area, not the margin.
> %wxchkver_2_8_12 void MarkerSetAlpha(int markerNumber, int alpha);
> // Set a margin to be either numeric or symbolic.
> void SetMarginType(int margin, int marginType);
> // Retrieve the type of a margin.
> int GetMarginType(int margin) const;
> // Set the width of a margin to a width expressed in pixels.
> void SetMarginWidth(int margin, int pixelWidth);
> // Retrieve the width of a margin in pixels.
> int GetMarginWidth(int margin) const;
> // Set a mask that determines which markers are displayed in a margin.
> void SetMarginMask(int margin, unsigned int mask); // NOTE: wxSTC has "int mask", but we need all the bits so we force uint
> // Retrieve the marker mask of a margin.
> unsigned int GetMarginMask(int margin) const;
> // Make a margin sensitive or insensitive to mouse clicks.
> void SetMarginSensitive(int margin, bool sensitive);
> // Retrieve the mouse click sensitivity of a margin.
> bool GetMarginSensitive(int margin) const;
> // Set the cursor shown when the mouse is inside a margin.
> %wxchkver_2_9_5 void SetMarginCursor(int margin, int cursor);
> // Retrieve the cursor shown in a margin.
> %wxchkver_2_9_5 int GetMarginCursor(int margin) const;
> // Clear all the styles and make equivalent to the global default style.
> void StyleClearAll();
> // Set the foreground colour of a style.
> void StyleSetForeground(int style, const wxColour& fore);
> // Set the background colour of a style.
> void StyleSetBackground(int style, const wxColour& back);
> // Set a style to be bold or not.
> void StyleSetBold(int style, bool bold);
> // Set a style to be italic or not.
> void StyleSetItalic(int style, bool italic);
> // Set the size of characters of a style.
> void StyleSetSize(int style, int sizePoints);
> // Set the font of a style.
> void StyleSetFaceName(int style, const wxString& fontName);
> // Set a style to have its end of line filled or not.
> void StyleSetEOLFilled(int style, bool filled);
> // Reset the default style to its state at startup
> void StyleResetDefault();
> // Set a style to be underlined or not.
> void StyleSetUnderline(int style, bool underline);
> // Get the foreground colour of a style.
> %wxchkver_2_9_5 wxColour StyleGetForeground(int style) const;
> // Get the background colour of a style.
> %wxchkver_2_9_5 wxColour StyleGetBackground(int style) const;
> // Get is a style bold or not.
> %wxchkver_2_9_5 bool StyleGetBold(int style) const;
> // Get is a style italic or not.
> %wxchkver_2_9_5 bool StyleGetItalic(int style) const;
> // Get the size of characters of a style.
> %wxchkver_2_9_5 int StyleGetSize(int style) const;
> // Get the font facename of a style
> %wxchkver_2_9_5 wxString StyleGetFaceName(int style);
> // Get is a style to have its end of line filled or not.
> %wxchkver_2_9_5 bool StyleGetEOLFilled(int style) const;
> // Get is a style underlined or not.
> %wxchkver_2_9_5 bool StyleGetUnderline(int style) const;
> // Get is a style mixed case, or to force upper or lower case.
> %wxchkver_2_9_5 int StyleGetCase(int style) const;
> // Get the character set of the font in a style.
> %wxchkver_2_9_5 int StyleGetCharacterSet(int style) const;
> // Get is a style visible or not.
> %wxchkver_2_9_5 bool StyleGetVisible(int style) const;
> // Get is a style changeable or not (read only).
> // Experimental feature, currently buggy.
> %wxchkver_2_9_5 bool StyleGetChangeable(int style) const;
> // Get is a style a hotspot or not.
> %wxchkver_2_9_5 bool StyleGetHotSpot(int style) const;
> // Set a style to be mixed case, or to force upper or lower case.
> void StyleSetCase(int style, int caseForce);
> // Set the size of characters of a style. Size is in points multiplied by 100.
> %wxchkver_2_9_5 void StyleSetSizeFractional(int style, int caseForce);
> // Get the size of characters of a style in points multiplied by 100
> %wxchkver_2_9_5 int StyleGetSizeFractional(int style) const;
> // Set the weight of characters of a style.
> %wxchkver_2_9_5 void StyleSetWeight(int style, int weight);
> // Get the weight of characters of a style.
> %wxchkver_2_9_5 int StyleGetWeight(int style) const;
> // Set a style to be a hotspot or not.
> void StyleSetHotSpot(int style, bool hotspot);
> // Set the foreground colour of the main and additional selections and whether to use this setting.
> void SetSelForeground(bool useSetting, const wxColour& fore);
> // Set the background colour of the main and additional selections and whether to use this setting.
> void SetSelBackground(bool useSetting, const wxColour& back);
> // Get the alpha of the selection.
> %wxchkver_2_8_12 int GetSelAlpha() const;
> // Set the alpha of the selection.
> %wxchkver_2_8_12 void SetSelAlpha(int alpha);
> // Is the selection end of line filled?
> %wxchkver_2_9_5 bool GetSelEOLFilled() const;
> // Set the selection to have its end of line filled or not.
> %wxchkver_2_9_5 void SetSelEOLFilled(bool filled);
> // Set the foreground colour of the caret.
> void SetCaretForeground(const wxColour& fore);
> // When key+modifier combination km is pressed perform msg.
> void CmdKeyAssign(int key, int modifiers, int cmd);
> // When key+modifier combination km is pressed do nothing.
> void CmdKeyClear(int key, int modifiers);
> // Drop all key mappings.
> void CmdKeyClearAll();
> // Set the styles for a segment of the document.
> // %override [Lua string styleBytes] wxStyledTextCtrl::SetStyleBytes(int length, Lua string styleBytes );
> // C++ Func: void SetStyleBytes(int length, char* styleBytes);
> void SetStyleBytes(int length, char* styleBytes);
> // Set a style to be visible or not.
> void StyleSetVisible(int style, bool visible);
> // Get the time in milliseconds that the caret is on and off.
> int GetCaretPeriod() const;
> // Get the time in milliseconds that the caret is on and off. 0 = steady on.
> void SetCaretPeriod(int periodMilliseconds);
> // Set the set of characters making up words for when moving or selecting by word.
> // First sets defaults like SetCharsDefault.
> void SetWordChars(const wxString& characters);
> // Get the set of characters making up words for when moving or selecting by word.
> %wxchkver_2_9_5 wxString GetWordChars() const;
> // Start a sequence of actions that is undone and redone as a unit.
> // May be nested.
> void BeginUndoAction();
> // End a sequence of actions that is undone and redone as a unit.
> void EndUndoAction();
> // Set an indicator to plain, squiggle or TT.
> void IndicatorSetStyle(int indic, int style);
> // Retrieve the style of an indicator.
> int IndicatorGetStyle(int indic) const;
> // Set the foreground colour of an indicator.
> void IndicatorSetForeground(int indic, const wxColour& fore);
> // Retrieve the foreground colour of an indicator.
> wxColour IndicatorGetForeground(int indic) const;
> // Set an indicator to draw under text or over(default).
> %wxchkver_2_9_5 void IndicatorSetUnder(int indic, bool under);
> // Retrieve whether indicator drawn under or over text.
> %wxchkver_2_9_5 bool IndicatorGetUnder(int indic) const;
> // Set the foreground colour of all whitespace and whether to use this setting.
> void SetWhitespaceForeground(bool useSetting, const wxColour& fore);
> // Set the background colour of all whitespace and whether to use this setting.
> void SetWhitespaceBackground(bool useSetting, const wxColour& back);
> // Set the size of the dots used to mark space characters.
> %wxchkver_2_9_5 void SetWhitespaceSize(int size);
> // Get the size of the dots used to mark space characters.
> %wxchkver_2_9_5 int GetWhitespaceSize() const;
> // Divide each styling byte into lexical class bits (default: 5) and indicator
> // bits (default: 3). If a lexer requires more than 32 lexical states, then this
> // is used to expand the possible states.
> void SetStyleBits(int bits);
> // Retrieve number of bits in style bytes used to hold the lexical state.
> int GetStyleBits() const;
> // Used to hold extra styling information for each line.
> void SetLineState(int line, int state);
> // Retrieve the extra styling information for a line.
> int GetLineState(int line) const;
> // Retrieve the last line number that has line state.
> int GetMaxLineState() const;
> // Is the background of the line containing the caret in a different colour?
> bool GetCaretLineVisible() const;
> // Display the background of the line containing the caret in a different colour.
> void SetCaretLineVisible(bool show);
> // Get the colour of the background of the line containing the caret.
> !%wxchkver_2_8 wxColour GetCaretLineBack();
> %wxchkver_2_8 wxColour GetCaretLineBackground() const;
> // Set the colour of the background of the line containing the caret.
> !%wxchkver_2_8 void SetCaretLineBack(const wxColour& back);
> %wxchkver_2_8 void SetCaretLineBackground(const wxColour& back);
> // Set a style to be changeable or not (read only).
> // Experimental feature, currently buggy.
> void StyleSetChangeable(int style, bool changeable);
> // Display a auto-completion list.
> // The lenEntered parameter indicates how many characters before
> // the caret should be used to provide context.
> void AutoCompShow(int lenEntered, const wxString& itemList);
> // Remove the auto-completion list from the screen.
> void AutoCompCancel();
> // Is there an auto-completion list visible?
> bool AutoCompActive();
> // Retrieve the position of the caret when the auto-completion list was displayed.
> int AutoCompPosStart();
> // User has selected an item so remove the list and insert the selection.
> void AutoCompComplete();
> // Define a set of character that when typed cancel the auto-completion list.
> void AutoCompStops(const wxString& characterSet);
> // Change the separator character in the string setting up an auto-completion list.
> // Default is space but can be changed if items contain space.
> void AutoCompSetSeparator(int separatorCharacter);
> // Retrieve the auto-completion list separator character.
> int AutoCompGetSeparator() const;
> // Select the item in the auto-completion list that starts with a string.
> void AutoCompSelect(const wxString& text);
> // Should the auto-completion list be cancelled if the user backspaces to a
> // position before where the box was created.
> void AutoCompSetCancelAtStart(bool cancel);
> // Retrieve whether auto-completion cancelled by backspacing before start.
> bool AutoCompGetCancelAtStart() const;
> // Define a set of characters that when typed will cause the autocompletion to
> // choose the selected item.
> void AutoCompSetFillUps(const wxString& characterSet);
> // Should a single item auto-completion list automatically choose the item.
> void AutoCompSetChooseSingle(bool chooseSingle);
> // Retrieve whether a single item auto-completion list automatically choose the item.
> bool AutoCompGetChooseSingle() const;
> // Set whether case is significant when performing auto-completion searches.
> void AutoCompSetIgnoreCase(bool ignoreCase);
> // Retrieve state of ignore case flag.
> bool AutoCompGetIgnoreCase() const;
> // Display a list of strings and send notification when user chooses one.
> void UserListShow(int listType, const wxString& itemList);
> // Set whether or not autocompletion is hidden automatically when nothing matches.
> void AutoCompSetAutoHide(bool autoHide);
> // Retrieve whether or not autocompletion is hidden automatically when nothing matches.
> bool AutoCompGetAutoHide() const;
> // Set whether or not autocompletion deletes any word characters
> // after the inserted text upon completion.
> void AutoCompSetDropRestOfWord(bool dropRestOfWord);
> // Retrieve whether or not autocompletion deletes any word characters
> // after the inserted text upon completion.
> bool AutoCompGetDropRestOfWord() const;
> // Register an image for use in autocompletion lists.
> void RegisterImage(int type, const wxBitmap& bmp);
> // Clear all the registered images.
> void ClearRegisteredImages();
> // Retrieve the auto-completion list type-separator character.
> int AutoCompGetTypeSeparator() const;
> // Change the type-separator character in the string setting up an auto-completion list.
> // Default is '?' but can be changed if items contain '?'.
> void AutoCompSetTypeSeparator(int separatorCharacter);
> // Set the maximum width, in characters, of auto-completion and user lists.
> // Set to 0 to autosize to fit longest item, which is the default.
> void AutoCompSetMaxWidth(int characterCount);
> // Get the maximum width, in characters, of auto-completion and user lists.
> int AutoCompGetMaxWidth() const;
> // Set the maximum height, in rows, of auto-completion and user lists.
> // The default is 5 rows.
> void AutoCompSetMaxHeight(int rowCount);
> // Set the maximum height, in rows, of auto-completion and user lists.
> int AutoCompGetMaxHeight() const;
> // Set the number of spaces used for one level of indentation.
> void SetIndent(int indentSize);
> // Retrieve indentation size.
> int GetIndent() const;
> // Indentation will only use space characters if useTabs is false, otherwise
> // it will use a combination of tabs and spaces.
> void SetUseTabs(bool useTabs);
> // Retrieve whether tabs will be used in indentation.
> bool GetUseTabs() const;
> // Change the indentation of a line to a number of columns.
> void SetLineIndentation(int line, int indentSize);
> // Retrieve the number of columns that a line is indented.
> int GetLineIndentation(int line) const;
> // Retrieve the position before the first non indentation character on a line.
> int GetLineIndentPosition(int line) const;
> // Retrieve the column number of a position, taking tab width into account.
> int GetColumn(int pos) const;
> // Count characters between two positions.
> %wxchkver_2_9_5 int CountCharacters(int startPos, int endPos);
> // Show or hide the horizontal scroll bar.
> void SetUseHorizontalScrollBar(bool show);
> // Is the horizontal scroll bar visible?
> bool GetUseHorizontalScrollBar() const;
> // Show or hide indentation guides.
> !%wxchkver_2_9_5 void SetIndentationGuides(bool show);
> %wxchkver_2_9_5 void SetIndentationGuides(int indentView);
> // Are the indentation guides visible?
> !%wxchkver_2_9_5 bool GetIndentationGuides();
> %wxchkver_2_9_5 int GetIndentationGuides();
> // Set the highlighted indentation guide column.
> // 0 = no highlighted guide.
> void SetHighlightGuide(int column);
> // Get the highlighted indentation guide column.
> int GetHighlightGuide() const;
> // Get the position after the last visible characters on a line.
> int GetLineEndPosition(int line) const;
> // Get the code page used to interpret the bytes of the document as characters.
> int GetCodePage() const;
> // Get the foreground colour of the caret.
> wxColour GetCaretForeground() const;
> // In read-only mode?
> bool GetReadOnly() const;
> // Sets the position of the caret.
> void SetCurrentPos(int pos);
> // Sets the position that starts the selection - this becomes the anchor.
> void SetSelectionStart(int pos);
> // Returns the position at the start of the selection.
> int GetSelectionStart() const;
> // Sets the position that ends the selection - this becomes the currentPosition.
> void SetSelectionEnd(int pos);
> // Returns the position at the end of the selection.
> int GetSelectionEnd() const;
> // Set caret to a position, while removing any existing selection.
> %wxchkver_2_9_5 void SetEmptySelection(int pos);
> // Sets the print magnification added to the point size of each style for printing.
> void SetPrintMagnification(int magnification);
> // Returns the print magnification.
> int GetPrintMagnification() const;
> // Modify colours when printing for clearer printed text.
> void SetPrintColourMode(int mode);
> // Returns the print colour mode.
> int GetPrintColourMode() const;
> // Find some text in the document.
> int FindText(int minPos, int maxPos, const wxString& text, int flags=0);
> // On Windows, will draw the document into a display context such as a printer.
> int FormatRange(bool doDraw, int startPos, int endPos, wxDC* draw, wxDC* target, const wxRect& renderRect, const wxRect& pageRect);
> // Retrieve the display line at the top of the display.
> int GetFirstVisibleLine() const;
> // Retrieve the contents of a line.
> wxString GetLine(int line) const;
> // Returns the number of lines in the document. There is always at least one.
> int GetLineCount() const;
> // Sets the size in pixels of the left margin.
> void SetMarginLeft(int pixelWidth);
> // Returns the size in pixels of the left margin.
> int GetMarginLeft() const;
> // Sets the size in pixels of the right margin.
> void SetMarginRight(int pixelWidth);
> // Returns the size in pixels of the right margin.
> int GetMarginRight() const;
> // Is the document different from when it was last saved?
> bool GetModify() const;
> // Select a range of text.
> void SetSelection(int start, int end);
> // Retrieve the selected text.
> wxString GetSelectedText();
> // Retrieve a range of text.
> wxString GetTextRange(int startPos, int endPos);
> // Draw the selection in normal style or with selection highlighted.
> void HideSelection(bool normal);
> // Retrieve the line containing a position.
> int LineFromPosition(int pos) const;
> // Retrieve the position at the start of a line.
> int PositionFromLine(int line) const;
> // Scroll horizontally and vertically.
> void LineScroll(int columns, int lines);
> // Ensure the caret is visible.
> void EnsureCaretVisible();
> // Replace the selected text with the argument text.
> void ReplaceSelection(const wxString& text);
> // Set to read only or read write.
> void SetReadOnly(bool readOnly);
> // Will a paste succeed?
> bool CanPaste() const;
> // Are there any undoable actions in the undo history?
> bool CanUndo() const;
> // Delete the undo history.
> void EmptyUndoBuffer();
> // Undo one action in the undo history.
> void Undo();
> // Cut the selection to the clipboard.
> void Cut();
> // Copy the selection to the clipboard.
> void Copy();
> // Paste the contents of the clipboard into the document replacing the selection.
> void Paste();
> // Clear the selection.
> void Clear();
> // Replace the contents of the document with the argument text.
> void SetText(const wxString& text);
> // Retrieve all the text in the document.
> wxString GetText() const;
> // Retrieve the number of characters in the document.
> int GetTextLength() const;
> // Set to overtype (true) or insert mode.
> void SetOvertype(bool overtype);
> // Returns true if overtype mode is active otherwise false is returned.
> bool GetOvertype() const;
> // Set the width of the insert mode caret.
> void SetCaretWidth(int pixelWidth);
> // Returns the width of the insert mode caret.
> int GetCaretWidth() const;
> // Sets the position that starts the target which is used for updating the
> // document without affecting the scroll position.
> void SetTargetStart(int pos);
> // Get the position that starts the target.
> int GetTargetStart() const;
> // Sets the position that ends the target which is used for updating the
> // document without affecting the scroll position.
> void SetTargetEnd(int pos);
> // Get the position that ends the target.
> int GetTargetEnd() const;
> // Replace the target text with the argument text.
> // Text is counted so it can contain NULs.
> // Returns the length of the replacement text.
> int ReplaceTarget(const wxString& text);
> // Replace the target text with the argument text after \d processing.
> // Text is counted so it can contain NULs.
> // Looks for \d where d is between 1 and 9 and replaces these with the strings
> // matched in the last search operation which were surrounded by \( and \).
> // Returns the length of the replacement text including any change
> // caused by processing the \d patterns.
> int ReplaceTargetRE(const wxString& text);
> // Search for a counted string in the target and set the target to the found
> // range. Text is counted so it can contain NULs.
> // Returns length of range or -1 for failure in which case target is not moved.
> int SearchInTarget(const wxString& text);
> // Set the search flags used by SearchInTarget.
> void SetSearchFlags(int flags);
> // Get the search flags used by SearchInTarget.
> int GetSearchFlags() const;
> // Show a call tip containing a definition near position pos.
> void CallTipShow(int pos, const wxString& definition);
> // Remove the call tip from the screen.
> void CallTipCancel();
> // Is there an active call tip?
> bool CallTipActive();
> // Retrieve the position where the caret was before displaying the call tip.
> int CallTipPosAtStart();
> // Highlight a segment of the definition.
> void CallTipSetHighlight(int start, int end);
> // Set the background colour for the call tip.
> void CallTipSetBackground(const wxColour& back);
> // Set the foreground colour for the call tip.
> void CallTipSetForeground(const wxColour& fore);
> // Set the foreground colour for the highlighted part of the call tip.
> void CallTipSetForegroundHighlight(const wxColour& fore);
> // Enable use of STYLE_CALLTIP and set call tip tab size in pixels.
> %wxchkver_2_8_12 void CallTipUseStyle(int tabSize);
> // Set position of calltip, above or below text.
> %wxchkver_2_9_5 void CallTipSetPosition(bool above);
> // Find the display line of a document line taking hidden lines into account.
> int VisibleFromDocLine(int line);
> // Find the document line of a display line taking hidden lines into account.
> int DocLineFromVisible(int lineDisplay);
> // The number of display lines needed to wrap a document line
> int WrapCount(int line);
> // Set the fold level of a line.
> // This encodes an integer level along with flags indicating whether the
> // line is a header and whether it is effectively white space.
> void SetFoldLevel(int line, int level);
> // Retrieve the fold level of a line.
> int GetFoldLevel(int line) const;
> // Find the last child line of a header line.
> int GetLastChild(int line, int level) const;
> // Find the parent line of a child line.
> int GetFoldParent(int line) const;
> // Make a range of lines visible.
> void ShowLines(int lineStart, int lineEnd);
> // Make a range of lines invisible.
> void HideLines(int lineStart, int lineEnd);
> // Is a line visible?
> bool GetLineVisible(int line) const;
> // Are all lines visible?
> %wxchkver_2_9_5 bool GetAllLinesVisible() const;
> // Show the children of a header line.
> void SetFoldExpanded(int line, bool expanded);
> // Is a header line expanded?
> bool GetFoldExpanded(int line) const;
> // Switch a header line between expanded and contracted.
> void ToggleFold(int line);
> // Ensure a particular line is visible by expanding any header line hiding it.
> void EnsureVisible(int line);
> // Set some style options for folding.
> void SetFoldFlags(int flags);
> // Ensure a particular line is visible by expanding any header line hiding it.
> // Use the currently set visibility policy to determine which range to display.
> void EnsureVisibleEnforcePolicy(int line);
> // Sets whether a tab pressed when caret is within indentation indents.
> void SetTabIndents(bool tabIndents);
> // Does a tab pressed when caret is within indentation indent?
> bool GetTabIndents() const;
> // Sets whether a backspace pressed when caret is within indentation unindents.
> void SetBackSpaceUnIndents(bool bsUnIndents);
> // Does a backspace pressed when caret is within indentation unindent?
> bool GetBackSpaceUnIndents() const;
> // Sets the time the mouse must sit still to generate a mouse dwell event.
> void SetMouseDwellTime(int periodMilliseconds);
> // Retrieve the time the mouse must sit still to generate a mouse dwell event.
> int GetMouseDwellTime() const;
> // Get position of start of word.
> int WordStartPosition(int pos, bool onlyWordCharacters);
> // Get position of end of word.
> int WordEndPosition(int pos, bool onlyWordCharacters);
> // Sets whether text is word wrapped.
> void SetWrapMode(int mode);
> // Retrieve whether text is word wrapped.
> int GetWrapMode() const;
> // Set the display mode of visual flags for wrapped lines.
> void SetWrapVisualFlags(int wrapVisualFlags);
> // Retrive the display mode of visual flags for wrapped lines.
> int GetWrapVisualFlags() const;
> // Set the location of visual flags for wrapped lines.
> void SetWrapVisualFlagsLocation(int wrapVisualFlagsLocation);
> // Retrive the location of visual flags for wrapped lines.
> int GetWrapVisualFlagsLocation() const;
> // Set the start indent for wrapped lines.
> void SetWrapStartIndent(int indent);
> // Retrive the start indent for wrapped lines.
> int GetWrapStartIndent() const;
> // Sets how wrapped sublines are placed. Default is fixed.
> %wxchkver_2_9_5 void SetWrapIndentMode(int mode);
> // Retrieve how wrapped sublines are placed. Default is fixed.
> %wxchkver_2_9_5 int GetWrapIndentMode() const;
> // Sets the degree of caching of layout information.
> void SetLayoutCache(int mode);
> // Retrieve the degree of caching of layout information.
> int GetLayoutCache() const;
> // Sets the document width assumed for scrolling.
> void SetScrollWidth(int pixelWidth);
> // Retrieve the document width assumed for scrolling.
> int GetScrollWidth() const;
> // Sets whether the maximum width line displayed is used to set scroll width.
> %wxchkver_2_9_5 void SetScrollWidthTracking(bool tracking);
> // Retrieve whether the scroll width tracks wide lines.
> %wxchkver_2_9_5 bool GetScrollWidthTracking() const;
> // Measure the pixel width of some text in a particular style.
> // NUL terminated text argument.
> // Does not handle tab or control characters.
> int TextWidth(int style, const wxString& text);
> // Sets the scroll range so that maximum scroll position has
> // the last line at the bottom of the view (default).
> // Setting this to false allows scrolling one page below the last line.
> void SetEndAtLastLine(bool endAtLastLine);
> // Retrieve whether the maximum scroll position has the last
> // line at the bottom of the view.
> bool GetEndAtLastLine() const;
> // Retrieve the height of a particular line of text in pixels.
> int TextHeight(int line);
> // Show or hide the vertical scroll bar.
> void SetUseVerticalScrollBar(bool show);
> // Is the vertical scroll bar visible?
> bool GetUseVerticalScrollBar() const;
> // Append a string to the end of the document without changing the selection.
> void AppendText(const wxString& text);
> // Is drawing done in two phases with backgrounds drawn before foregrounds?
> bool GetTwoPhaseDraw() const;
> // In twoPhaseDraw mode, drawing is performed in two phases, first the background
> // and then the foreground. This avoids chopping off characters that overlap the next run.
> void SetTwoPhaseDraw(bool twoPhase);
> // Scroll so that a display line is at the top of the display.
> %wxchkver_2_9_5 void SetFirstVisibleLine(int lineDisplay);
> // Change the effect of pasting when there are multiple selections.
> %wxchkver_2_9_5 void SetMultiPaste(int multiPaste);
> // Retrieve the effect of pasting when there are multiple selections..
> %wxchkver_2_9_5 int GetMultiPaste() const;
> // Retrieve the value of a tag from a regular expression search.
> %wxchkver_2_9_5 wxString GetTag(int tagNumber) const;
> // Make the target range start and end be the same as the selection range start and end.
> void TargetFromSelection();
> // Join the lines in the target.
> void LinesJoin();
> // Split the lines in the target into lines that are less wide than pixelWidth
> // where possible.
> void LinesSplit(int pixelWidth);
> // Set the colours used as a chequerboard pattern in the fold margin
> void SetFoldMarginColour(bool useSetting, const wxColour& back);
> void SetFoldMarginHiColour(bool useSetting, const wxColour& fore);
> // Move caret down one line.
> void LineDown();
> // Move caret down one line extending selection to new caret position.
> void LineDownExtend();
> // Move caret up one line.
> void LineUp();
> // Move caret up one line extending selection to new caret position.
> void LineUpExtend();
> // Move caret left one character.
> void CharLeft();
> // Move caret left one character extending selection to new caret position.
> void CharLeftExtend();
> // Move caret right one character.
> void CharRight();
> // Move caret right one character extending selection to new caret position.
> void CharRightExtend();
> // Move caret left one word.
> void WordLeft();
> // Move caret left one word extending selection to new caret position.
> void WordLeftExtend();
> // Move caret right one word.
> void WordRight();
> // Move caret right one word extending selection to new caret position.
> void WordRightExtend();
> // Move caret to first position on line.
> void Home();
> // Move caret to first position on line extending selection to new caret position.
> void HomeExtend();
> // Move caret to last position on line.
> void LineEnd();
> // Move caret to last position on line extending selection to new caret position.
> void LineEndExtend();
> // Move caret to first position in document.
> void DocumentStart();
> // Move caret to first position in document extending selection to new caret position.
> void DocumentStartExtend();
> // Move caret to last position in document.
> void DocumentEnd();
> // Move caret to last position in document extending selection to new caret position.
> void DocumentEndExtend();
> // Move caret one page up.
> void PageUp();
> // Move caret one page up extending selection to new caret position.
> void PageUpExtend();
> // Move caret one page down.
> void PageDown();
> // Move caret one page down extending selection to new caret position.
> void PageDownExtend();
> // Switch from insert to overtype mode or the reverse.
> void EditToggleOvertype();
> // Cancel any modes such as call tip or auto-completion list display.
> void Cancel();
> // Delete the selection or if no selection, the character before the caret.
> void DeleteBack();
> // If selection is empty or all on one line replace the selection with a tab character.
> // If more than one line selected, indent the lines.
> void Tab();
> // Dedent the selected lines.
> void BackTab();
> // Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
> void NewLine();
> // Insert a Form Feed character.
> void FormFeed();
> // Move caret to before first visible character on line.
> // If already there move to first character on line.
> void VCHome();
> // Like VCHome but extending selection to new caret position.
> void VCHomeExtend();
> // Magnify the displayed text by increasing the sizes by 1 point.
> void ZoomIn();
> // Make the displayed text smaller by decreasing the sizes by 1 point.
> void ZoomOut();
> // Delete the word to the left of the caret.
> void DelWordLeft();
> // Delete the word to the right of the caret.
> void DelWordRight();
> // Delete the word to the right of the caret, but not the trailing non-word characters.
> %wxchkver_2_9_5 void DelWordRightEnd();
> // Cut the line containing the caret.
> void LineCut();
> // Delete the line containing the caret.
> void LineDelete();
> // Switch the current line with the previous.
> void LineTranspose();
> // Duplicate the current line.
> void LineDuplicate();
> // Transform the selection to lower case.
> void LowerCase();
> // Transform the selection to upper case.
> void UpperCase();
> // Scroll the document down, keeping the caret visible.
> void LineScrollDown();
> // Scroll the document up, keeping the caret visible.
> void LineScrollUp();
> // Delete the selection or if no selection, the character before the caret.
> // Will not delete the character before at the start of a line.
> void DeleteBackNotLine();
> // Move caret to first position on display line.
> void HomeDisplay();
> // Move caret to first position on display line extending selection to
> // new caret position.
> void HomeDisplayExtend();
> // Move caret to last position on display line.
> void LineEndDisplay();
> // Move caret to last position on display line extending selection to new
> // caret position.
> void LineEndDisplayExtend();
> // These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?
> // except they behave differently when word-wrap is enabled:
> // They go first to the start / end of the display line, like (Home|LineEnd)Display
> // The difference is that, the cursor is already at the point, it goes on to the start
> // or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
> void HomeWrap();
> void HomeWrapExtend();
> void LineEndWrap();
> void LineEndWrapExtend();
> void VCHomeWrap();
> void VCHomeWrapExtend();
> // Copy the line containing the caret.
> void LineCopy();
> // Move the caret inside current view if it's not there already.
> void MoveCaretInsideView();
> // How many characters are on a line, including end of line characters?
> int LineLength(int line) const;
> // Highlight the characters at two positions.
> void BraceHighlight(int pos1, int pos2);
> // Use specified indicator to highlight matching braces instead of changing their style.
> %wxchkver_2_9_5 void BraceHighlightIndicator(bool useBraceHighlightIndicator, int indicator);
> // Highlight the character at a position indicating there is no matching brace.
> void BraceBadLight(int pos);
> // Use specified indicator to highlight non matching brace instead of changing its style.
> %wxchkver_2_9_5 void BraceBadLightIndicator(bool useBraceBadLightIndicator, int indicator);
> // Find the position of a matching brace or INVALID_POSITION if no match.
> int BraceMatch(int pos);
> // Are the end of line characters visible?
> bool GetViewEOL() const;
> // Make the end of line characters visible or invisible.
> void SetViewEOL(bool visible);
> // Retrieve a pointer to the document object.
> void* GetDocPointer();
> // Change the document object used.
> void SetDocPointer(void* docPointer);
> // Set which document modification events are sent to the container.
> void SetModEventMask(int mask);
> // Retrieve the column number which text should be kept within.
> int GetEdgeColumn() const;
> // Set the column number of the edge.
> // If text goes past the edge then it is highlighted.
> void SetEdgeColumn(int column);
> // Retrieve the edge highlight mode.
> int GetEdgeMode() const;
> // The edge may be displayed by a line (EDGE_LINE) or by highlighting text that
> // goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
> void SetEdgeMode(int mode);
> // Retrieve the colour used in edge indication.
> wxColour GetEdgeColour() const;
> // Change the colour used in edge indication.
> void SetEdgeColour(const wxColour& edgeColour);
> // Sets the current caret position to be the search anchor.
> void SearchAnchor();
> // Find some text starting at the search anchor.
> // Does not ensure the selection is visible.
> int SearchNext(int flags, const wxString& text);
> // Find some text starting at the search anchor and moving backwards.
> // Does not ensure the selection is visible.
> int SearchPrev(int flags, const wxString& text);
> // Retrieves the number of lines completely visible.
> int LinesOnScreen() const;
> // Set whether a pop up menu is displayed automatically when the user presses
> // the wrong mouse button.
> void UsePopUp(bool allowPopUp);
> // Is the selection rectangular? The alternative is the more common stream selection.
> bool SelectionIsRectangle() const;
> // Set the zoom level. This number of points is added to the size of all fonts.
> // It may be positive to magnify or negative to reduce.
> void SetZoom(int zoom);
> // Retrieve the zoom level.
> int GetZoom() const;
> // Create a new document object.
> // Starts with reference count of 1 and not selected into editor.
> void* CreateDocument();
> // Extend life of document.
> void AddRefDocument(void* docPointer);
> // Release a reference to the document, deleting document if it fades to black.
> void ReleaseDocument(void* docPointer);
> // Get which document modification events are sent to the container.
> int GetModEventMask() const;
> // Change internal focus flag.
> void SetSTCFocus(bool focus);
> // Get internal focus flag.
> bool GetSTCFocus() const;
> // Change error status - 0 = OK.
> void SetStatus(int statusCode);
> // Get error status.
> int GetStatus() const;
> // Set whether the mouse is captured when its button is pressed.
> void SetMouseDownCaptures(bool captures);
> // Get whether mouse gets captured.
> bool GetMouseDownCaptures() const;
> // Sets the cursor to one of the SC_CURSOR* values.
> void SetSTCCursor(int cursorType);
> // Get cursor type.
> int GetSTCCursor() const;
> // Change the way control characters are displayed:
> // If symbol is < 32, keep the drawn way, else, use the given character.
> void SetControlCharSymbol(int symbol);
> // Get the way control characters are displayed.
> int GetControlCharSymbol() const;
> // Move to the previous change in capitalisation.
> void WordPartLeft();
> // Move to the previous change in capitalisation extending selection
> // to new caret position.
> void WordPartLeftExtend();
> // Move to the change next in capitalisation.
> void WordPartRight();
> // Move to the next change in capitalisation extending selection
> // to new caret position.
> void WordPartRightExtend();
> // Set the way the display area is determined when a particular line
> // is to be moved to by Find, FindNext, GotoLine, etc.
> void SetVisiblePolicy(int visiblePolicy, int visibleSlop);
> // Delete back from the current position to the start of the line.
> void DelLineLeft();
> // Delete forwards from the current position to the end of the line.
> void DelLineRight();
> // Get and Set the xOffset (ie, horizontal scroll position).
> void SetXOffset(int newOffset);
> int GetXOffset() const;
> // Set the last x chosen value to be the caret x position.
> void ChooseCaretX();
> // Set the way the caret is kept visible when going sideways.
> // The exclusion zone is given in pixels.
> void SetXCaretPolicy(int caretPolicy, int caretSlop);
> // Set the way the line the caret is on is kept visible.
> // The exclusion zone is given in lines.
> void SetYCaretPolicy(int caretPolicy, int caretSlop);
> // Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
> void SetPrintWrapMode(int mode);
> // Is printing line wrapped?
> int GetPrintWrapMode() const;
> // Set a fore colour for active hotspots.
> void SetHotspotActiveForeground(bool useSetting, const wxColour& fore);
> // Get the fore colour for active hotspots.
> %wxchkver_2_9_5 wxColour GetHotspotActiveForeground() const;
> // Set a back colour for active hotspots.
> void SetHotspotActiveBackground(bool useSetting, const wxColour& back);
> // Get the back colour for active hotspots.
> %wxchkver_2_9_5 wxColour GetHotspotActiveBackground() const;
> // Enable / Disable underlining active hotspots.
> void SetHotspotActiveUnderline(bool underline);
> // Get whether underlining for active hotspots.
> %wxchkver_2_9_5 bool GetHotspotActiveUnderline() const;
> // Limit hotspots to single line so hotspots on two lines don't merge.
> void SetHotspotSingleLine(bool singleLine);
> // Get the HotspotSingleLine property
> %wxchkver_2_9_5 bool GetHotspotSingleLine() const;
> // Move caret between paragraphs (delimited by empty lines).
> void ParaDown();
> void ParaDownExtend();
> void ParaUp();
> void ParaUpExtend();
> // Given a valid document position, return the previous position taking code
> // page into account. Returns 0 if passed 0.
> int PositionBefore(int pos);
> // Given a valid document position, return the next position taking code
> // page into account. Maximum value returned is the last position in the document.
> int PositionAfter(int pos);
> // Copy a range of text to the clipboard. Positions are clipped into the document.
> void CopyRange(int start, int end);
> // Copy argument text to the clipboard.
> void CopyText(int length, const wxString& text);
> // Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or
> // by lines (SC_SEL_LINES).
> void SetSelectionMode(int mode);
> // Get the mode of the current selection.
> int GetSelectionMode() const;
> // Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).
> int GetLineSelStartPosition(int line);
> // Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).
> int GetLineSelEndPosition(int line);
> // Move caret down one line, extending rectangular selection to new caret position.
> void LineDownRectExtend();
> // Move caret up one line, extending rectangular selection to new caret position.
> void LineUpRectExtend();
> // Move caret left one character, extending rectangular selection to new caret position.
> void CharLeftRectExtend();
> // Move caret right one character, extending rectangular selection to new caret position.
> void CharRightRectExtend();
> // Move caret to first position on line, extending rectangular selection to new caret position.
> void HomeRectExtend();
> // Move caret to before first visible character on line.
> // If already there move to first character on line.
> // In either case, extend rectangular selection to new caret position.
> void VCHomeRectExtend();
> // Move caret to last position on line, extending rectangular selection to new caret position.
> void LineEndRectExtend();
> // Move caret one page up, extending rectangular selection to new caret position.
> void PageUpRectExtend();
> // Move caret one page down, extending rectangular selection to new caret position.
> void PageDownRectExtend();
> // Move caret to top of page, or one page up if already at top of page.
> void StutteredPageUp();
> // Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
> void StutteredPageUpExtend();
> // Move caret to bottom of page, or one page down if already at bottom of page.
> void StutteredPageDown();
> // Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
> void StutteredPageDownExtend();
> // Move caret left one word, position cursor at end of word.
> void WordLeftEnd();
> // Move caret left one word, position cursor at end of word, extending selection to new caret position.
> void WordLeftEndExtend();
> // Move caret right one word, position cursor at end of word.
> void WordRightEnd();
> // Move caret right one word, position cursor at end of word, extending selection to new caret position.
> void WordRightEndExtend();
> // Set the set of characters making up whitespace for when moving or selecting by word.
> // Should be called after SetWordChars.
> void SetWhitespaceChars(const wxString& characters);
> // Get the set of characters making up whitespace for when moving or selecting by word.
> %wxchkver_2_9_5 wxString GetWhitespaceChars() const;
> // Set the set of characters making up punctuation characters
> // Should be called after SetWordChars.
> %wxchkver_2_9_5 void SetPunctuationChars(const wxString& characters);
> // Get the set of characters making up punctuation characters
> %wxchkver_2_9_5 wxString GetPunctuationChars() const;
> // Reset the set of characters for whitespace and word characters to the defaults.
> void SetCharsDefault();
> // Get currently selected item position in the auto-completion list
> int AutoCompGetCurrent() const;
> // Set auto-completion case insensitive behaviour to either prefer case-sensitive matches or have no preference.
> %wxchkver_2_9_5 void AutoCompSetCaseInsensitiveBehaviour(int behaviour);
> // Get auto-completion case insensitive behaviour.
> %wxchkver_2_9_5 int AutoCompGetCaseInsensitiveBehaviour() const;
> // Enlarge the document to a particular size of text bytes.
> void Allocate(int bytes);
> // Find the position of a column on a line taking into account tabs and
> // multi-byte characters. If beyond end of line, return line end position.
> int FindColumn(int line, int column);
> // Can the caret preferred x position only be changed by explicit movement commands?
> !%wxchkver_2_9_5 bool GetCaretSticky() const;
> %wxchkver_2_9_5 int GetCaretSticky() const;
> // Stop the caret preferred x position changing when the user types.
> !%wxchkver_2_9_5 void SetCaretSticky(bool useCaretStickyBehaviour);
> %wxchkver_2_9_5 void SetCaretSticky(int useCaretStickyBehaviour);
> // Switch between sticky and non-sticky: meant to be bound to a key.
> void ToggleCaretSticky();
> // Enable/Disable convert-on-paste for line endings
> void SetPasteConvertEndings(bool convert);
> // Get convert-on-paste setting
> bool GetPasteConvertEndings() const;
> // Duplicate the selection. If selection empty duplicate the line containing the caret.
> void SelectionDuplicate();
> // Set background alpha of the caret line.
> %wxchkver_2_8_12 void SetCaretLineBackAlpha(int alpha);
> // Get the background alpha of the caret line.
> %wxchkver_2_8_12 int GetCaretLineBackAlpha() const;
> #if %wxchkver_2_9_5
> // Set the style of the caret to be drawn.
> void SetCaretStyle(int caretStyle);
> // Returns the current style of the caret.
> int GetCaretStyle() const;
> // Set the indicator used for IndicatorFillRange and IndicatorClearRange
> void SetIndicatorCurrent(int indicator);
> // Get the current indicator
> int GetIndicatorCurrent() const;
> // Set the value used for IndicatorFillRange
> void SetIndicatorValue(int value);
> // Get the current indicator value
> int GetIndicatorValue() const;
> // Turn a indicator on over a range.
> void IndicatorFillRange(int position, int fillLength);
> // Turn a indicator off over a range.
> void IndicatorClearRange(int position, int clearLength);
> // Are any indicators present at position?
> int IndicatorAllOnFor(int position);
> // What value does a particular indicator have at at a position?
> int IndicatorValueAt(int indicator, int position);
> // Where does a particular indicator start?
> int IndicatorStart(int indicator, int position);
> // Where does a particular indicator end?
> int IndicatorEnd(int indicator, int position);
> // Set number of entries in position cache
> void SetPositionCacheSize(int size);
> // How many entries are allocated to the position cache?
> int GetPositionCacheSize() const;
> // Copy the selection, if selection empty copy the line with the caret
> void CopyAllowLine();
> // Compact the document buffer and return a read-only pointer to the
> // characters in the document.
> //const char* GetCharacterPointer() const;
> // Return a read-only pointer to a range of characters in the document.
> // May move the gap so that the range is contiguous, but will only move up
> // to rangeLength bytes.
> //const char* GetRangePointer(int position, int rangeLength) const;
> // Return a position which, to avoid performance costs, should not be within
> // the range of a call to GetRangePointer.
> int GetGapPosition() const;
> // Always interpret keyboard input as Unicode
> void SetKeysUnicode(bool keysUnicode);
> // Are keys always interpreted as Unicode?
> bool GetKeysUnicode() const;
> // Set the alpha fill colour of the given indicator.
> void IndicatorSetAlpha(int indicator, int alpha);
> // Get the alpha fill colour of the given indicator.
> int IndicatorGetAlpha(int indicator) const;
> // Set the alpha outline colour of the given indicator.
> void IndicatorSetOutlineAlpha(int indicator, int alpha);
> // Get the alpha outline colour of the given indicator.
> int IndicatorGetOutlineAlpha(int indicator) const;
> // Set extra ascent for each line
> void SetExtraAscent(int extraAscent);
> // Get extra ascent for each line
> int GetExtraAscent() const;
> // Set extra descent for each line
> void SetExtraDescent(int extraDescent);
> // Get extra descent for each line
> int GetExtraDescent() const;
> // Which symbol was defined for markerNumber with MarkerDefine
> int GetMarkerSymbolDefined(int markerNumber);
> // Set the text in the text margin for a line
> void MarginSetText(int line, const wxString& text);
> // Get the text in the text margin for a line
> wxString MarginGetText(int line) const;
> // Set the style number for the text margin for a line
> void MarginSetStyle(int line, int style);
> // Get the style number for the text margin for a line
> int MarginGetStyle(int line) const;
> // Set the style in the text margin for a line
> void MarginSetStyles(int line, const wxString& styles);
> // Get the styles in the text margin for a line
> wxString MarginGetStyles(int line) const;
> // Clear the margin text on all lines
> void MarginTextClearAll();
> // Get the start of the range of style numbers used for margin text
> void MarginSetStyleOffset(int style);
> // Get the start of the range of style numbers used for margin text
> int MarginGetStyleOffset() const;
> // Set the margin options.
> void SetMarginOptions(int marginOptions);
> // Get the margin options.
> int GetMarginOptions() const;
> // Set the annotation text for a line
> void AnnotationSetText(int line, const wxString& text);
> // Get the annotation text for a line
> wxString AnnotationGetText(int line) const;
> // Set the style number for the annotations for a line
> void AnnotationSetStyle(int line, int style);
> // Get the style number for the annotations for a line
> int AnnotationGetStyle(int line) const;
> // Set the annotation styles for a line
> void AnnotationSetStyles(int line, const wxString& styles);
> // Get the annotation styles for a line
> wxString AnnotationGetStyles(int line) const;
> // Get the number of annotation lines for a line
> int AnnotationGetLines(int line) const;
> // Clear the annotations from all lines
> void AnnotationClearAll();
> // Set the visibility for the annotations for a view
> void AnnotationSetVisible(int visible);
> // Get the visibility for the annotations for a view
> int AnnotationGetVisible() const;
> // Get the start of the range of style numbers used for annotations
> void AnnotationSetStyleOffset(int style);
> // Get the start of the range of style numbers used for annotations
> int AnnotationGetStyleOffset() const;
> // Add a container action to the undo stack
> void AddUndoAction(int token, int flags);
> // Find the position of a character from a point within the window.
> int CharPositionFromPoint(int x, int y);
> // Find the position of a character from a point within the window.
> // Return INVALID_POSITION if not close to text.
> int CharPositionFromPointClose(int x, int y);
> // Set whether multiple selections can be made
> void SetMultipleSelection(bool multipleSelection);
> // Whether multiple selections can be made
> bool GetMultipleSelection() const;
> // Set whether typing can be performed into multiple selections
> void SetAdditionalSelectionTyping(bool additionalSelectionTyping);
> // Whether typing can be performed into multiple selections
> bool GetAdditionalSelectionTyping() const;
> // Set whether additional carets will blink
> void SetAdditionalCaretsBlink(bool additionalCaretsBlink);
> // Whether additional carets will blink
> bool GetAdditionalCaretsBlink() const;
> // Set whether additional carets are visible
> void SetAdditionalCaretsVisible(bool additionalCaretsBlink);
> // Whether additional carets are visible
> bool GetAdditionalCaretsVisible() const;
> // How many selections are there?
> int GetSelections() const;
> // Clear selections to a single empty stream selection
> void ClearSelections();
> // Add a selection
> int AddSelection(int caret, int anchor);
> // Set the main selection
> void SetMainSelection(int selection);
> // Which selection is the main selection
> int GetMainSelection() const;
> void SetSelectionNCaret(int selection, int pos);
> int GetSelectionNCaret(int selection) const;
> void SetSelectionNAnchor(int selection, int posAnchor);
> int GetSelectionNAnchor(int selection) const;
> void SetSelectionNCaretVirtualSpace(int selection, int space);
> int GetSelectionNCaretVirtualSpace(int selection) const;
> void SetSelectionNAnchorVirtualSpace(int selection, int space);
> int GetSelectionNAnchorVirtualSpace(int selection) const;
> // Sets the position that starts the selection - this becomes the anchor.
> void SetSelectionNStart(int selection, int pos);
> // Returns the position at the start of the selection.
> int GetSelectionNStart(int selection) const;
> // Sets the position that ends the selection - this becomes the currentPosition.
> void SetSelectionNEnd(int selection, int pos);
> // Returns the position at the end of the selection.
> int GetSelectionNEnd(int selection) const;
> void SetRectangularSelectionCaret(int pos);
> int GetRectangularSelectionCaret() const;
> void SetRectangularSelectionAnchor(int posAnchor);
> int GetRectangularSelectionAnchor() const;
> void SetRectangularSelectionCaretVirtualSpace(int space);
> int GetRectangularSelectionCaretVirtualSpace() const;
> void SetRectangularSelectionAnchorVirtualSpace(int space);
> int GetRectangularSelectionAnchorVirtualSpace() const;
> void SetVirtualSpaceOptions(int virtualSpaceOptions);
> int GetVirtualSpaceOptions() const;
> // On GTK+, allow selecting the modifier key to use for mouse-based
> // rectangular selection. Often the window manager requires Alt+Mouse Drag
> // for moving windows.
> // Valid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER.
> void SetRectangularSelectionModifier(int modifier);
> // Get the modifier key used for rectangular selection.
> int GetRectangularSelectionModifier() const;
> // Set the foreground colour of additional selections.
> // Must have previously called SetSelFore with non-zero first argument for this to have an effect.
> void SetAdditionalSelForeground(const wxColour& fore);
> // Set the background colour of additional selections.
> // Must have previously called SetSelBack with non-zero first argument for this to have an effect.
> void SetAdditionalSelBackground(const wxColour& back);
> // Set the alpha of the selection.
> void SetAdditionalSelAlpha(int alpha);
> // Get the alpha of the selection.
> int GetAdditionalSelAlpha() const;
> // Set the foreground colour of additional carets.
> void SetAdditionalCaretForeground(const wxColour& fore);
> // Get the foreground colour of additional carets.
> wxColour GetAdditionalCaretForeground() const;
> // Set the main selection to the next selection.
> void RotateSelection();
> // Swap that caret and anchor of the main selection.
> void SwapMainAnchorCaret();
> // Indicate that the internal state of a lexer has changed over a range and therefore
> // there may be a need to redraw.
> int ChangeLexerState(int start, int end);
> // Find the next line at or after lineStart that is a contracted fold header line.
> // Return -1 when no more lines.
> int ContractedFoldNext(int lineStart);
> // Centre current line in window.
> void VerticalCentreCaret();
> // Move the selected lines up one line, shifting the line above after the selection
> void MoveSelectedLinesUp();
> // Move the selected lines down one line, shifting the line below before the selection
> void MoveSelectedLinesDown();
> // Set the identifier reported as idFrom in notification messages.
> void SetIdentifier(int identifier);
> // Get the identifier.
> int GetIdentifier() const;
> // Set the width for future RGBA image data.
> void RGBAImageSetWidth(int width);
> // Set the height for future RGBA image data.
> void RGBAImageSetHeight(int height);
> // Define a marker from RGBA data.
> // It has the width and height from RGBAImageSetWidth/Height
> void MarkerDefineRGBAImage(int markerNumber, const unsigned char* pixels);
> // Register an RGBA image for use in autocompletion lists.
> // It has the width and height from RGBAImageSetWidth/Height
> void RegisterRGBAImage(int type, const unsigned char* pixels);
> // Scroll to start of document.
> void ScrollToStart();
> // Scroll to end of document.
> void ScrollToEnd();
> // Set the technology used.
> void SetTechnology(int technology);
> // Get the tech.
> int GetTechnology() const;
> // Create an ILoader*.
> //void* CreateLoader(int bytes) const;
> #endif //%wxchkver_2_9_5
> // Start notifying the container of all key presses and commands.
> void StartRecord();
> // Stop notifying the container of all key presses and commands.
> void StopRecord();
> // Set the lexing language of the document.
> void SetLexer(int lexer);
> // Retrieve the lexing language of the document.
> int GetLexer() const;
> // Colourise a segment of the document using the current lexing language.
> void Colourise(int start, int end);
> // Set up a value that may be used by a lexer for some optional feature.
> void SetProperty(const wxString& key, const wxString& value);
> // Set up the key words used by the lexer.
> void SetKeyWords(int keywordSet, const wxString& keyWords);
> // Set the lexing language of the document based on string name.
> void SetLexerLanguage(const wxString& language);
> // Retrieve a 'property' value previously set with SetProperty.
> wxString GetProperty(const wxString& key);
> // Retrieve a 'property' value previously set with SetProperty,
> // with '$()' variable replacement on returned buffer.
> wxString GetPropertyExpanded(const wxString& key);
> // Retrieve a 'property' value previously set with SetProperty,
> // interpreted as an int AFTER any '$()' variable replacement.
> int GetPropertyInt(const wxString& key) const;
> // Retrieve the number of bits the current lexer needs for styling.
> int GetStyleBitsNeeded() const;
> // END of generated section
> //----------------------------------------------------------------------
> // Others...
> // Retrieve a '\n' separated list of properties understood by the current lexer.
> %wxchkver_2_9_5 wxString PropertyNames() const;
> // Retrieve the type of a property.
> %wxchkver_2_9_5 int PropertyType(const wxString& name);
> // Describe a property.
> %wxchkver_2_9_5 wxString DescribeProperty(const wxString& name) const;
> // Retrieve a '\n' separated list of descriptions of the keyword sets understood by the current lexer.
> %wxchkver_2_9_5 wxString DescribeKeyWordSets() const;
> //}}}
> //----------------------------------------------------------------------
> // Manually declared methods
> // Returns the line number of the line with the caret.
> int GetCurrentLine();
> // Extract style settings from a spec-string which is composed of one or
> // more of the following comma separated elements:
> //
> // bold turns on bold
> // italic turns on italics
> // fore:[name or #RRGGBB] sets the foreground colour
> // back:[name or #RRGGBB] sets the background colour
> // face:[facename] sets the font face name to use
> // size:[num] sets the font size in points
> // eol turns on eol filling
> // underline turns on underlining
> //
> void StyleSetSpec(int styleNum, const wxString& spec);
> // Get the font of a style.
> %wxchkver_2_9_5 wxFont StyleGetFont(int style);
> // Set style size, face, bold, italic, and underline attributes from
> // a wxFont's attributes.
> void StyleSetFont(int styleNum, wxFont& font);
> // Set all font style attributes at once.
> void StyleSetFontAttr(int styleNum, int size, const wxString& faceName, bool bold, bool italic, bool underline, wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
> // Set the character set of the font in a style. Converts the Scintilla
> // character set values to a wxFontEncoding.
> void StyleSetCharacterSet(int style, int characterSet);
> // Set the font encoding to be used by a style.
> void StyleSetFontEncoding(int style, wxFontEncoding encoding);
> // Perform one of the operations defined by the wxSTC_CMD_* constants.
> void CmdKeyExecute(int cmd);
> // Set the left and right margin in the edit area, measured in pixels.
> void SetMargins(int left, int right);
> // Retrieve the start and end positions of the current selection.
> //#ifdef SWIG
> // void GetSelection(int* OUTPUT, int* OUTPUT);
> //#else
> // %override [int startPos, int endPos] wxStyledTextCtrl::GetSelection( );
> // C++ Func: void GetSelection(int* startPos, int* endPos);
> void GetSelection();
> //#endif
> // Retrieve the point in the window where a position is displayed.
> wxPoint PointFromPosition(int pos);
> // Scroll enough to make the given line visible
> void ScrollToLine(int line);
> // Scroll enough to make the given column visible
> void ScrollToColumn(int column);
> // Send a message to Scintilla
> long SendMsg(int msg, long wp=0, long lp=0);
> // Set the vertical scrollbar to use instead of the ont that's built-in.
> void SetVScrollBar(wxScrollBar* bar);
> // Set the horizontal scrollbar to use instead of the ont that's built-in.
> void SetHScrollBar(wxScrollBar* bar);
> // Can be used to prevent the EVT_CHAR handler from adding the char
> bool GetLastKeydownProcessed( );
> void SetLastKeydownProcessed(bool val );
> // Write the contents of the editor to filename
> bool SaveFile(const wxString& filename);
> // Load the contents of filename into the editor
> bool LoadFile(const wxString& filename);
> //#ifdef STC_USE_DND
> // Allow for simulating a DnD DragOver
> // wxDragResult DoDragOver(wxCoord x, wxCoord y, wxDragResult def);
> // Allow for simulating a DnD DropText
> // bool DoDropText(long x, long y, const wxString& data);
> //#endif
> // Specify whether anti-aliased fonts should be used. Will have no effect
> // on some platforms, but on some (wxMac for example) can greatly improve
> // performance.
> void SetUseAntiAliasing(bool useAA);
> // Returns the current UseAntiAliasing setting.
> bool GetUseAntiAliasing();
> // Clear annotations from the given line.
> %wxchkver_2_9_5 void AnnotationClearLine(int line);
> // The following methods are nearly equivalent to their similarly named
> // cousins above. The difference is that these methods bypass wxString
> // and always use a char* even if used in a unicode build of wxWidgets.
> // In that case the character data will be utf-8 encoded since that is
> // what is used internally by Scintilla in unicode builds.
> // Add text to the document at current position.
> void AddTextRaw(const char* text);
> // Insert string at a position.
> void InsertTextRaw(int pos, const char* text);
> // Retrieve the text of the line containing the caret.
> // Returns the index of the caret on the line.
> //#ifdef SWIG
> // wxCharBuffer GetCurLineRaw(int* OUTPUT);
> //#else
> // wxCharBuffer GetCurLineRaw(int* linePos=NULL);
> //#endif
> // Retrieve the contents of a line.
> // wxCharBuffer GetLineRaw(int line);
> // Retrieve the selected text.
> // wxCharBuffer GetSelectedTextRaw();
> // Retrieve a range of text.
> // wxCharBuffer GetTextRangeRaw(int startPos, int endPos);
> // Replace the contents of the document with the argument text.
> // void SetTextRaw(const char* text);
> // Retrieve all the text in the document.
> // wxCharBuffer GetTextRaw();
> // Append a string to the end of the document without changing the selection.
> // void AppendTextRaw(const char* text);

};
//----------------------------------------------------------------------
class %delete wxStyledTextEvent : public wxCommandEvent
{

> %wxEventType wxEVT_STC_CHANGE // EVT_STC_CHANGE(id, fn );
> %wxEventType wxEVT_STC_STYLENEEDED // EVT_STC_STYLENEEDED(id, fn );
> %wxEventType wxEVT_STC_CHARADDED // EVT_STC_CHARADDED(id, fn );
> %wxEventType wxEVT_STC_SAVEPOINTREACHED // EVT_STC_SAVEPOINTREACHED(id, fn );
> %wxEventType wxEVT_STC_SAVEPOINTLEFT // EVT_STC_SAVEPOINTLEFT(id, fn );
> %wxEventType wxEVT_STC_ROMODIFYATTEMPT // EVT_STC_ROMODIFYATTEMPT(id, fn );
> %wxEventType wxEVT_STC_KEY // EVT_STC_KEY(id, fn );
> %wxEventType wxEVT_STC_DOUBLECLICK // EVT_STC_DOUBLECLICK(id, fn );
> %wxEventType wxEVT_STC_UPDATEUI // EVT_STC_UPDATEUI(id, fn );
> %wxEventType wxEVT_STC_MODIFIED // EVT_STC_MODIFIED(id, fn );
> %wxEventType wxEVT_STC_MACRORECORD // EVT_STC_MACRORECORD(id, fn );
> %wxEventType wxEVT_STC_MARGINCLICK // EVT_STC_MARGINCLICK(id, fn );
> %wxEventType wxEVT_STC_NEEDSHOWN // EVT_STC_NEEDSHOWN(id, fn );
> %wxEventType wxEVT_STC_PAINTED // EVT_STC_PAINTED(id, fn );
> %wxEventType wxEVT_STC_USERLISTSELECTION // EVT_STC_USERLISTSELECTION(id, fn );
> %wxEventType wxEVT_STC_URIDROPPED // EVT_STC_URIDROPPED(id, fn );
> %wxEventType wxEVT_STC_DWELLSTART // EVT_STC_DWELLSTART(id, fn );
> %wxEventType wxEVT_STC_DWELLEND // EVT_STC_DWELLEND(id, fn );
> %wxEventType wxEVT_STC_START_DRAG // EVT_STC_START_DRAG(id, fn );
> %wxEventType wxEVT_STC_DRAG_OVER // EVT_STC_DRAG_OVER(id, fn );
> %wxEventType wxEVT_STC_DO_DROP // EVT_STC_DO_DROP(id, fn );
> %wxEventType wxEVT_STC_ZOOM // EVT_STC_ZOOM(id, fn );
> %wxEventType wxEVT_STC_HOTSPOT_CLICK // EVT_STC_HOTSPOT_CLICK(id, fn );
> %wxEventType wxEVT_STC_HOTSPOT_DCLICK // EVT_STC_HOTSPOT_DCLICK(id, fn );
> %wxEventType wxEVT_STC_CALLTIP_CLICK // EVT_STC_CALLTIP_CLICK(id, fn );
> %wxEventType wxEVT_STC_AUTOCOMP_SELECTION // EVT_STC_AUTOCOMP_SELECTION(id, fn );
> wxStyledTextEvent(wxEventType commandType = 0, int id = 0 );
> void SetPosition(int pos );
> void SetKey(int k );
> void SetModifiers(int m );
> void SetModificationType(int t );
> void SetText(const wxString& t );
> void SetLength(int len );
> void SetLinesAdded(int num );
> void SetLine(int val );
> void SetFoldLevelNow(int val );
> void SetFoldLevelPrev(int val );
> void SetMargin(int val );
> void SetMessage(int val );
> void SetWParam(int val );
> void SetLParam(int val );
> void SetListType(int val );
> void SetX(int val );
> void SetY(int val );
> void SetDragText(const wxString& val );
> void SetDragAllowMove(bool val );
> void SetDragResult(wxDragResult val );
> int GetPosition() const;
> int GetKey() const;
> int GetModifiers() const;
> int GetModificationType() const;
> wxString GetText() const;
> int GetLength() const;
> int GetLinesAdded() const;
> int GetLine() const;
> int GetFoldLevelNow() const;
> int GetFoldLevelPrev() const;
> int GetMargin() const;
> int GetMessage() const;
> int GetWParam() const;
> int GetLParam() const;
> int GetListType() const;
> int GetX() const;
> int GetY() const;
> %wxchkver_2_9_5 int GetToken() const;
> %wxchkver_2_9_5 int GetAnnotationsLinesAdded() const;
> %wxchkver_2_9_5 int GetUpdated() const;
> wxString GetDragText( );
> bool GetDragAllowMove( );
> wxDragResult GetDragResult( );
> bool GetShift() const;
> bool GetControl() const;
> bool GetAlt() const;

};

## wxwidgets/wxwebview_webview.i - Lua table = 'wxwebview'

/////////////////////////////////////////////////////////////////////////////
// Name: webview.h
// Purpose: Common interface and events for web view component
// Author: Marianne Gagnon
// Copyright: (c) 2010 Marianne Gagnon, 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
//#include "wx/defs.h"
#if wxUSE_WEBVIEW
#include "wx/webview.h"
//#include "wx/control.h"
//#include "wx/event.h"
//#include "wx/sstream.h"
//#include "wx/sharedptr.h"
//#include "wx/vector.h"
//#if defined(__WXOSX__)
// #include "wx/osx/webviewhistoryitem_webkit.h"
//#elif defined(__WXGTK__)
// #include "wx/gtk/webviewhistoryitem_webkit.h"
//#elif defined(__WXMSW__)
// #include "wx/msw/webviewhistoryitem_ie.h"
//#else
// #error "wxWebView not implemented on this platform."
//#endif
//class wxFSFile;
//class wxFileSystem;
//class wxWebView;
enum wxWebViewZoom
{

> wxWEBVIEW_ZOOM_TINY,
> wxWEBVIEW_ZOOM_SMALL,
> wxWEBVIEW_ZOOM_MEDIUM,
> wxWEBVIEW_ZOOM_LARGE,
> wxWEBVIEW_ZOOM_LARGEST

};
enum wxWebViewZoomType
{

> //Scales entire page, including images
> wxWEBVIEW_ZOOM_TYPE_LAYOUT,
> wxWEBVIEW_ZOOM_TYPE_TEXT

};
enum wxWebViewNavigationError
{

> wxWEBVIEW_NAV_ERR_CONNECTION,
> wxWEBVIEW_NAV_ERR_CERTIFICATE,
> wxWEBVIEW_NAV_ERR_AUTH,
> wxWEBVIEW_NAV_ERR_SECURITY,
> wxWEBVIEW_NAV_ERR_NOT_FOUND,
> wxWEBVIEW_NAV_ERR_REQUEST,
> wxWEBVIEW_NAV_ERR_USER_CANCELLED,
> wxWEBVIEW_NAV_ERR_OTHER

};
enum wxWebViewReloadFlags
{

> //Default, may access cache
> wxWEBVIEW_RELOAD_DEFAULT,
> wxWEBVIEW_RELOAD_NO_CACHE

};
enum wxWebViewFindFlags
{

> wxWEBVIEW_FIND_WRAP, // = 0x0001,
> wxWEBVIEW_FIND_ENTIRE_WORD, // = 0x0002,
> wxWEBVIEW_FIND_MATCH_CASE, // = 0x0004,
> wxWEBVIEW_FIND_HIGHLIGHT_RESULT, // = 0x0008,
> wxWEBVIEW_FIND_BACKWARDS, // = 0x0010,
> wxWEBVIEW_FIND_DEFAULT // = 0

};
//Base class for custom scheme handlers
class wxWebViewHandler
{

> public:
> //wxWebViewHandler(const wxString& scheme); = No constructor, base class with pure virtual functions.
> virtual wxString GetName() const;
> virtual wxFSFile* GetFile(const wxString &uri); // = 0;
> private:
> wxString m_scheme;

};
#define_string wxWebViewNameStr // extern WXDLLIMPEXP_DATA_WEBVIEW(const char) wxWebViewNameStr[];
#define_string wxWebViewDefaultURLStr // extern WXDLLIMPEXP_DATA_WEBVIEW(const char) wxWebViewDefaultURLStr[];
#define_string wxWebViewBackendDefault // extern WXDLLIMPEXP_DATA_WEBVIEW(const char) wxWebViewBackendDefault[];
#define_string wxWebViewBackendIE // extern WXDLLIMPEXP_DATA_WEBVIEW(const char) wxWebViewBackendIE[];
#define_string wxWebViewBackendWebKit // extern WXDLLIMPEXP_DATA_WEBVIEW(const char) wxWebViewBackendWebKit[];
class wxWebViewFactory : public wxObject
{

> public:
> // No constructor, base class with pure virtual functions.
> virtual wxWebView* Create(); // = 0;
> virtual wxWebView* Create(wxWindow* parent, wxWindowID id, const wxString& url = wxWebViewDefaultURLStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = wxWebViewNameStr); // = 0;

};
//WX_DECLARE_STRING_HASH_MAP(wxSharedPtr<wxWebViewFactory>, wxStringWebViewFactoryMap);
class wxWebView : public wxControl
{

> public:
> //wxWebView(); // use New() to create a wxWebView instance.
> //virtual ~wxWebView() {}
> virtual bool Create(wxWindow* parent, wxWindowID id, const wxString& url = wxWebViewDefaultURLStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = wxWebViewNameStr); // = 0;
> // Factory methods allowing the use of custom factories registered with
> // RegisterFactory
> static wxWebView* New(const wxString& backend = wxWebViewBackendDefault);
> static wxWebView* New(wxWindow* parent, wxWindowID id, const wxString& url = wxWebViewDefaultURLStr, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, const wxString& backend = wxWebViewBackendDefault, long style = 0, const wxString& name = wxWebViewNameStr);
> //static void RegisterFactory(const wxString& backend, wxSharedPtr<wxWebViewFactory> factory);
> // General methods
> virtual void EnableContextMenu(bool enable = true);
> virtual wxString GetCurrentTitle() const; // = 0;
> virtual wxString GetCurrentURL() const; // = 0;
> // TODO: handle choosing a frame when calling GetPageSource()?
> virtual wxString GetPageSource() const; // = 0;
> virtual wxString GetPageText() const; // = 0;
> virtual bool IsBusy() const; // = 0;
> virtual bool IsContextMenuEnabled() const; // { return m_showMenu; }
> virtual bool IsEditable() const; // = 0;
> virtual void LoadURL(const wxString& url); // = 0;
> virtual void Print(); // = 0;
> //virtual void RegisterHandler(wxSharedPtr<wxWebViewHandler> handler); // = 0;
> virtual void Reload(wxWebViewReloadFlags flags = wxWEBVIEW_RELOAD_DEFAULT); // = 0;
> virtual void RunScript(const wxString& javascript); // = 0;
> virtual void SetEditable(bool enable = true); // = 0;
> void SetPage(const wxString& html, const wxString& baseUrl);
> void SetPage(wxInputStream& html, wxString baseUrl);
> virtual void Stop(); // = 0;
> //History
> virtual bool CanGoBack() const; // = 0;
> virtual bool CanGoForward() const; // = 0;
> virtual void GoBack(); // = 0;
> virtual void GoForward(); // = 0;
> virtual void ClearHistory(); // = 0;
> virtual void EnableHistory(bool enable = true); // = 0;
> //virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetBackwardHistory(); // = 0;
> //virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetForwardHistory(); // = 0;
> //virtual void LoadHistoryItem(wxSharedPtr<wxWebViewHistoryItem> item); // = 0;
> //Zoom
> virtual bool CanSetZoomType(wxWebViewZoomType type) const; // = 0;
> virtual wxWebViewZoom GetZoom() const; // = 0;
> virtual wxWebViewZoomType GetZoomType() const; // = 0;
> virtual void SetZoom(wxWebViewZoom zoom); // = 0;
> virtual void SetZoomType(wxWebViewZoomType zoomType); // = 0;
> //Selection
> virtual void SelectAll(); // = 0;
> virtual bool HasSelection() const; // = 0;
> virtual void DeleteSelection(); // = 0;
> virtual wxString GetSelectedText() const; // = 0;
> virtual wxString GetSelectedSource() const; // = 0;
> virtual void ClearSelection(); // = 0;
> //Clipboard functions
> virtual bool CanCut() const; // = 0;
> virtual bool CanCopy() const; // = 0;
> virtual bool CanPaste() const; // = 0;
> virtual void Cut(); // = 0;
> virtual void Copy(); // = 0;
> virtual void Paste(); // = 0;
> //Undo / redo functionality
> virtual bool CanUndo() const; // = 0;
> virtual bool CanRedo() const; // = 0;
> virtual void Undo(); // = 0;
> virtual void Redo(); // = 0;
> //Get the pointer to the underlying native engine.
> virtual void* GetNativeBackend() const; // = 0;
> //Find function
> virtual long Find(const wxString& text, int flags = wxWEBVIEW_FIND_DEFAULT); // = 0;
> /*
> protected:
> virtual void DoSetPage(const wxString& html, const wxString& baseUrl) = 0;
> private:
> static void InitFactoryMap();
> static wxStringWebViewFactoryMap::iterator FindFactory(const wxString &backend);
> bool m_showMenu;
> static wxStringWebViewFactoryMap m_factoryMap;
> wxDECLARE_ABSTRACT_CLASS(wxWebView);
> */

};
class wxWebViewEvent : public wxNotifyEvent
{

> public:
> %wxEventType wxEVT_WEBVIEW_NAVIGATING // EVT_WEBVIEW_NAVIGATING(id, fn);
> %wxEventType wxEVT_WEBVIEW_NAVIGATED // EVT_WEBVIEW_NAVIGATED(id, fn);
> %wxEventType wxEVT_WEBVIEW_LOADED // EVT_WEBVIEW_LOADED(id, fn);
> %wxEventType wxEVT_WEBVIEW_ERROR // EVT_WEBVIEW_ERROR(id, fn);
> %wxEventType wxEVT_WEBVIEW_NEWWINDOW // EVT_WEBVIEW_NEWWINDOW(id, fn);
> %wxEventType wxEVT_WEBVIEW_TITLE_CHANGED // EVT_WEBVIEW_TITLE_CHANGED(id, fn);
> wxWebViewEvent(); // {}
> wxWebViewEvent(wxEventType type, int id, const wxString& url, const wxString& target);
> const wxString& GetURL() const; // { return m_url; }
> const wxString& GetTarget() const; // { return m_target; }
> virtual wxEvent* Clone() const; // { return new wxWebViewEvent(*this); }

};
/*
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_WEBVIEW, wxEVT_WEBVIEW_NAVIGATING, wxWebViewEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_WEBVIEW, wxEVT_WEBVIEW_NAVIGATED, wxWebViewEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_WEBVIEW, wxEVT_WEBVIEW_LOADED, wxWebViewEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_WEBVIEW, wxEVT_WEBVIEW_ERROR, wxWebViewEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_WEBVIEW, wxEVT_WEBVIEW_NEWWINDOW, wxWebViewEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_WEBVIEW, wxEVT_WEBVIEW_TITLE_CHANGED, wxWebViewEvent );
// old wxEVT_COMMAND_* constants
#define wxEVT_COMMAND_WEBVIEW_NAVIGATING wxEVT_WEBVIEW_NAVIGATING
#define wxEVT_COMMAND_WEBVIEW_NAVIGATED wxEVT_WEBVIEW_NAVIGATED
#define wxEVT_COMMAND_WEBVIEW_LOADED wxEVT_WEBVIEW_LOADED
#define wxEVT_COMMAND_WEBVIEW_ERROR wxEVT_WEBVIEW_ERROR
#define wxEVT_COMMAND_WEBVIEW_NEWWINDOW wxEVT_WEBVIEW_NEWWINDOW
#define wxEVT_COMMAND_WEBVIEW_TITLE_CHANGED wxEVT_WEBVIEW_TITLE_CHANGED
*/
// ---------------------------------------------------------------------------
// wxWebViewHistoryItem
class wxWebViewHistoryItem
{

> public:
> wxWebViewHistoryItem(const wxString& url, const wxString& title);
> wxString GetUrl();
> wxString GetTitle();

};
// ---------------------------------------------------------------------------
// wxWebViewFSHandler
#include "wx/webviewfshandler.h"
class wxWebViewFSHandler : public wxWebViewHandler
{

> public:
> wxWebViewFSHandler(const wxString& scheme);
> virtual wxFSFile* GetFile(const wxString &uri);

};
// ---------------------------------------------------------------------------
// wxWebViewArchiveHandler
#include "wx/webviewarchivehandler.h"
//Loads from uris such as scheme:///C:/example/example.html or archives such as
//scheme:///C:/example/example.zip;protocol=zip/example.html
class wxWebViewArchiveHandler : public wxWebViewHandler
{

> public:
> wxWebViewArchiveHandler(const wxString& scheme);
> virtual wxFSFile* GetFile(const wxString &uri);

};
#endif // wxUSE_WEBVIEW

## wxlua/wxlua.i - Lua table = 'wxlua'

// ===========================================================================
// Purpose: wxLua specific wrappers
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
// ---------------------------------------------------------------------------
// wxLua version defines
#define wxLUA_MAJOR_VERSION
#define wxLUA_MINOR_VERSION
#define wxLUA_RELEASE_NUMBER
#define wxLUA_SUBRELEASE_NUMBER
#define_wxstring wxLUA_VERSION_STRING
bool wxLUA_CHECK_VERSION(int major, int minor, int release); // actually a define
bool wxLUA_CHECK_VERSION_FULL(int major, int minor, int release, int subrel); // actually a define
// ---------------------------------------------------------------------------
// Compile the luaScript of the given name and return the lua error code, a message
// and the line number (or -1) of the error.
// %override [int return, lua_string err_msg, int line_number] CompileLuaScript(const wxString& luaScript, const wxString& fileName );
int CompileLuaScript(const wxString& luaScript, const wxString& fileName );
// ---------------------------------------------------------------------------
// Get information about the status of wxLua.
// Get a table or string of all tracked top level windows that wxLua will
// Destroy() when lua is closed.
// Example output : { "ClassName(&win id=wxWindowID)", ...}
LuaTable GetTrackedWindowInfo(bool as_string = false );
// Get a table or string of all tracked userdata wxLua will delete when lua
// is closed or lua will eventually garbage collect.
// Example output : { "ClassName(&obj)", ... }
LuaTable GetGCUserdataInfo(bool as_string = false );
// Get a table or string of all tracked userdata wxLua has pushed.
// A single object may have multiple types if it has been casted.
// Example output : { "&obj wxLuaTypeName(type#), ...", ... }
LuaTable GetTrackedObjectInfo(bool as_string = false );
// Get a table or string of all tracked wxEvent callbacks that have been
// installed using wxEvtHandler::Connect(... );
// "wxEVT_XXX(evt#) -> wxLuaEventCallback(&callback, ids %d %d)|wxEvtHandler(&evthandler) -> wxEvtHandlerClassName"
LuaTable GetTrackedEventCallbackInfo(bool as_string = false );
// Get a table or string of all wxWindow derived classes that have been created in wxLua.
// "wxWindowClassName(&win, id=%d)|wxLuaDestroyCallback(&callback)"
LuaTable GetTrackedWinDestroyCallbackInfo(bool as_string = false );
// Is the wxLua userdata object on the list to be garbage collected by Lua?
bool isgcobject(void* object );
// Is the wxLua userdata object on the list of tracked objects?
bool istrackedobject(void* object );
// Is the wxLua object refed by wxLua
bool isrefed(void* object );
// ---------------------------------------------------------------------------
// Force the Lua garbage collector to act or ignore object *DANGEROUS*
//
// These are *only* meant for very special cases and should NOT be used unless
// you have an initmate knowledge about the object and how it will be treated
// by wxWidgets, wxLua, and Lua.
// Add the userdata object to the list of objects that will be deleted when
// it goes out of scope and the Lua garbage collector runs.
// bool gcobject(void* object );
// Remove the userdata object from the list of objects that will be deleted when
// it goes out of scope and the Lua garbage collector runs.
bool ungcobject(void* object );
// ---------------------------------------------------------------------------
// Type information about the bindings or current userdata
enum wxLuaMethod_Type // The type of a Lua method
{

> WXLUAMETHOD_CONSTRUCTOR, // constructor
> WXLUAMETHOD_METHOD, // class member function
> WXLUAMETHOD_CFUNCTION, // global C function (not part of a class)
> WXLUAMETHOD_GETPROP, // Get %property funcName, read
> WXLUAMETHOD_SETPROP, // Set %property funcName, write
> WXLUAMETHOD_STATIC, // Class member function is static
> WXLUAMETHOD_DELETE // This is the delete function that wxLua has generated
> // to delete this class and is not part of the
> // original class.

};
#define WXLUA_TNONE
#define WXLUA_TNIL
#define WXLUA_TBOOLEAN
#define WXLUA_TLIGHTUSERDATA
#define WXLUA_TNUMBER
#define WXLUA_TSTRING
#define WXLUA_TTABLE
#define WXLUA_TFUNCTION
#define WXLUA_TUSERDATA
#define WXLUA_TTHREAD
#define WXLUA_TINTEGER
#define WXLUA_TCFUNCTION
#define WXLUA_T_MAX
#define LUA_TNONE // (-1 );
#define LUA_TNIL // 0
#define LUA_TBOOLEAN // 1
#define LUA_TLIGHTUSERDATA // 2
#define LUA_TNUMBER // 3
#define LUA_TSTRING // 4
#define LUA_TTABLE // 5
#define LUA_TFUNCTION // 6
#define LUA_TUSERDATA // 7
#define LUA_TTHREAD // 8
// Is this lua_type() (or in lua the type() function) considered equivalent
%rename iswxluatype int wxlua_iswxluatype(int luatype, int wxluaarg_tag );
// %override [wxlua_typename, wxlua_type#, lua_typename, lua_type#] type(any object );
// Given any type of object, returns four values:
// wxlua name of the type - wxluaT_gettypename(L, stack_idx );
// wxlua number of the type - wxluaT_type(L, stack_idx );
// lua name of the type - lua_typename(L, lua_type(L, stack_idx) );
// lua number of the type - lua_type(L, stack_idx );
wxString type(void* object );
// %override wxString typename(int wxluaarg_tag );
// Returns the wxLua name binding wxLua class type numbers.
wxString typename(int wxluaarg_tag );
// ---------------------------------------------------------------------------
// wxLuaBinding - These are not wrapped in the standard way, but coded by hand
// for size.
// These items follow the structure below and ALL items are called as if they
// were table members.
// Example : print(wxlua.GetBindings()[1].GetClassCount );
// Example : print(wxlua.GetBindings()[1].GetClassArray[1].methods[1].name );
// Note: Use only '.' and NO () to make it a function call, also check to see
// if the item exists first (unlike the example above)!
// Also, you probably want to store the returned tables and get the values from
// them instead of getting the whole table every time from wxlua.GetBindings()...
// Please see the bindings.wx.lua sample program for usage.
// Entry point to get the objects below.
// returns a table array of each installed binding { wxLuaBinding* }
LuaTable GetBindings( );
/*
class wxLuaBinding
{

> // No constructor as this is read only
> wxString GetBindingName
> wxString GetLuaNamespace
> int GetClassCount
> int GetNumberCount
> int GetStringCount
> int GetEventCount
> int GetObjectCount
> int GetFunctionCount
> {wxLuaBindClass*} GetClassArray
> {wxLuaBindMethod*} GetFunctionArray
> {name, value} GetNumberArray
> {name, value} GetStringArray
> {name, eventType, wxluatype, wxLuaBindClass} GetEventArray
> {name, object, wxluatype, wxLuaBindClass} GetObjectArray

};
struct wxLuaBindClass
{

> // No constructor as this is read only
> wxString name
> {wxLuaBindMethod*} wxluamethods
> int wxluamethods_n
> wxClassInfo* classInfo
> int wxluatype
> {wxString} baseclassNames
> {wxLuaBindClass*} baseBindClasses
> {name, value} enums
> int enums_n

};
struct wxLuaBindMethod
{

> // No constructor as this is read only
> wxString name
> int method_type
> {wxLuaBindCFunc*} wxluacfuncs
> int wxluacfuncs_n
> wxLuaBindMethod* basemethod
> wxLuaBindClass* class // class this is part of (not in struct );
> wxString class_name // class name this is part of (not in struct );

};
struct wxLuaBindCFunc
{

> // No constructor as this is read only
> cfunction lua_cfunc
> int method_type
> int minargs
> int maxargs
> {int} argtypes
> wxString class_name // added, not in struct

};
*/
// ---------------------------------------------------------------------------
// wxLuaState
#include "wxlua/wxlstate.h"
class %delete wxLuaState : public wxObject
{

> /*
> wxLuaState(bool create = false );
> wxLuaState(wxEvtHandler *handler, wxWindowID id = wxID_ANY );
> bool Ok() const;
> void Destroy( );
> bool CloseLuaState(bool force );
> bool IsClosing() const;
> wxEventType GetInEventType() const;
> void SetEventHandler(wxEvtHandler *evtHandler );
> wxEvtHandler *GetEventHandler() const;
> void SetId(wxWindowID id );
> wxWindowID GetId() const;
> void SendEvent( wxLuaEvent &event ) const;
> int RunFile(const wxString &fileName );
> int RunString(const wxString &script, const wxString& name = "" );
> bool IsRunning() const;
> */

};
// ---------------------------------------------------------------------------
// wxLuaObject - Allows Lua data items to be used for wxClientData.
enum wxLuaObject_Type
{

> wxLUAOBJECT_NONE,
> wxLUAOBJECT_BOOL,
> wxLUAOBJECT_INT,
> wxLUAOBJECT_STRING,
> wxLUAOBJECT_ARRAYINT

};
class %delete wxLuaObject : public wxObject // ALSO! wxClientData use it anywhere that takes that
{

> // %override wxLuaObject(any value type );
> // C++ Func: wxLuaObject(const wxLuaState& wxlState, int stack_idx = 1 );
> // Wrap the single value passed in with a wxLuaObject
> wxLuaObject( );
> // %override void wxLuaObject::SetObject(any value type );
> // C++ Func: void SetObject(int stack_idx = 1 );
> // Discard the old reference and create a new one for the item passed in
> void SetObject( );
> // %override [any value type] wxLuaObject::GetObject( );
> // C++ Func: bool GetObject( );
> // get the object, note C++ returns bool, in lua it "returns" the referenced object
> void GetObject() const;
> // These are not useful in lua
> //bool *GetBoolPtr();
> //int *GetIntPtr();
> //wxString *GetStringPtr();
> //wxArrayInt *GetArrayPtr();
> int GetAllocationFlag() const;

};
class %delete wxLuaEvent : public wxNotifyEvent
{

> %wxEventType wxEVT_LUA_CREATION // EVT_LUA_CREATION(winid, func );
> %wxEventType wxEVT_LUA_PRINT // EVT_LUA_PRINT(winid, func );
> %wxEventType wxEVT_LUA_ERROR // EVT_LUA_ERROR(winid, func );
> %wxEventType wxEVT_LUA_DEBUG_HOOK // EVT_LUA_DEBUG_HOOK(winid, func );
> wxLuaEvent(wxEventType commandType = wxEVT_NULL, wxWindowID id = wxID_ANY); // , const wxLuaState& wxlState = wxNullLuaState);
> wxLuaEvent(const wxLuaEvent& event);
> // use GetString method to retrieve info
> // Get the line number in the code, -1 if unknown
> int GetLineNum() const;
> wxLuaState GetwxLuaState() const;
> void SetwxLuaState(const wxLuaState& wxlState);
> //lua_State *GetLuaState() const;
> // non null only for wxEVT_LUA_DEBUG_HOOK
> //lua_Debug *GetLuaDebug() const;
> // If called from a wxEVT_LUA_DEBUG_HOOK the interpreter will stop
> void DebugHookBreak(bool stop);

};

## wxlua_debugger/wxluadebugger.i - Lua table = 'wxlua'

// ===========================================================================
// Purpose: wxLuaDebugger specific wrappers
// Author: J Winwood, John Labenski
// Created: 14/11/2001
// Copyright: (c) 2001-2002 Lomtick Software. All rights reserved.
// Licence: wxWidgets licence
// wxWidgets: Updated to 2.8.4
// ===========================================================================
#include "wx/defs.h"
#include "wx/object.h"
#include "wxlua/wxlstate.h"
#include "wxlua/wxlbind.h"
// Show a dialog of the current stack and all of the global data in a wxListCtrl
// This also shows information about the number and kind of userdata items that
// wxLua is tracking and will delete.
// %override void StackDialog( );
void LuaStackDialog( );
// ---------------------------------------------------------------------------
// wxLuaDebugServer
#include "wxlua/debugger/wxldserv.h"
class %delete wxLuaDebuggerServer : public wxEvtHandler
{

> wxLuaDebuggerServer(int portNumber );
> bool StartServer( );
> bool StopServer( );
> long StartClient( );
> bool AddBreakPoint(const wxString &fileName, int lineNumber );
> bool RemoveBreakPoint(const wxString &fileName, int lineNumber );
> bool ClearAllBreakPoints( );
> bool Run(const wxString &fileName, const wxString &buffer );
> bool Step( );
> bool StepOver( );
> bool StepOut( );
> bool Continue( );
> bool Break( );
> bool Reset( );
> bool EvaluateExpr(int exprRef, const wxString &expr );
> void DisplayStackDialog(wxWindow *pParent, wxWindowID id = wxID_ANY );
> long GetDebuggeeProcessId() const;
> bool KillDebuggee( );
> static wxString GetProgramName( );
> static wxString GetNetworkName( );

};
// ---------------------------------------------------------------------------
// wxLuaDebugData
//class wxLuaDebugData
//{
//};
// ---------------------------------------------------------------------------
// wxLuaDebuggerEvent
class %delete wxLuaDebuggerEvent : public wxEvent
{

> %wxEventType wxEVT_WXLUA_DEBUGGER_DEBUGGEE_CONNECTED // EVT_WXLUA_DEBUGGER_DEBUGGEE_CONNECTED(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_DEBUGGEE_DISCONNECTED // EVT_WXLUA_DEBUGGER_DEBUGGEE_DISCONNECTED(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_BREAK // EVT_WXLUA_DEBUGGER_BREAK(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_PRINT // EVT_WXLUA_DEBUGGER_PRINT(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_ERROR // EVT_WXLUA_DEBUGGER_ERROR(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_EXIT // EVT_WXLUA_DEBUGGER_EXIT(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_STACK_ENUM // EVT_WXLUA_DEBUGGER_STACK_ENUM(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_STACK_ENTRY_ENUM // EVT_WXLUA_DEBUGGER_STACK_ENTRY_ENUM(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_TABLE_ENUM // EVT_WXLUA_DEBUGGER_TABLE_ENUM(id, fn );
> %wxEventType wxEVT_WXLUA_DEBUGGER_EVALUATE_EXPR // EVT_WXLUA_DEBUGGER_EVALUATE_EXPR(id, fn );
> int GetLineNumber() const;
> int GetReference() const;
> wxString GetFileName() const;
> wxString GetMessage() const;
> //const wxLuaDebugData GetDebugData() const;

};