mars3142/wx_wherigo
1
0
Fork 0
Code Issues Pull Requests Wiki Activity

initial commit

Browse Source 
Signed-off-by: Peter Siegmund <mars3142@noreply.mars3142.dev>
This commit is contained in:
Peter Siegmund
2025-10-31 23:37:30 +01:00
commit bf6b52fd94
9654 changed files with 4035664 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
libs/wxWidgets-3.3.1/docs/base/readme.txt Normal file
View File

@@ -0,0 +1,123 @@
wxBase README
=============
NB: this file applies to wxBase library only. If you are using a GUI version
of wxWidgets, please refer to the documentation in the appropriate
subdirectory (msw, gtk &c).
Welcome to wxBase!
0. Introduction
---------------
wxBase is the library providing most of the non-GUI classes of the wxWidgets
cross-platform C++ framework. wxBase has some generic classes such as yet
another C++ string class, typesafe dynamic arrays, hashes and lists and, more
excitingly, wxDateTime -- a very flexible and powerful class for manipulating
the dates in the range of 580 million years with up to millisecond precision.
Another useful class not present in the standard C++ library is wxRegEx which
allows you to use regular expressions for string matching and replacing.
There are also classes for writing portable programs in C++ painlessly which
encapsulate things like files (and their names), directories, processes,
threads, sockets and much more. Some of the other utility classes allow you to
parse the command line, limit the number of instances of your program
executing simultaneously (portably!) and so on.
1. Requirements and supported platforms
--------------------------------------
wxBase can be compiled and used under Win32, mostly any modern Unix system
(including macOS), VMS and BeOS (this release couldn't be tested under
these platforms so you might encounter some problems but they should be easy
to solve -- please contact us in this case!)
It is written without using any modern C++ features (such as templates,
exceptions, namespaces) for maximal portability and so you shouldn't have
problems compiling it with any C++ compiler at all. However, we only provide
the project files for Microsoft Visual C++ 6.0 and make files for Borland C++
for Win32 (any contributions are welcome!) -- but our Unix makefiles should
work with any compiler.
2. Installing under Win32
-------------------------
Please note that wxBase can be compiled in different configurations under
Win32: as a static or shared library, in debug or release mode and in ANSI
or Unicode mode for a total of 8 possibilities.
a) Using Visual C++ 6.0
Simply open the build/msw/wx_base.dsp file in MSDEV and build it. When it is
done you can also open samples/console/console.dsp project and build it as
well.
b) Cygwin
Please refer to the Unix section below.
Note that gcc's precompiled headers do not work on current versions of
Cygwin. If your version of Cygwin is affected you will need to use the
--disable-precomp-headers configure option.
c) Borland
Please refer to the docs/msw/install.md. The console sample compiles and
runs but does not pass all tests.
d) Other compilers
Unfortunately we don't have the makefiles for any other compilers yet.
Please contact us if you would like to help us with creating one for the
compiler you use.
3. Installing under Unix/BeOS
-----------------------------
Please note that GNU make may be required to build wxBase, please use it if
you get any errors from the native Unix make.
The recommended way to build wxBase is:
% cd ..../wxWidgets
% mkdir base-release # or any other directory of your liking
% cd base-release
% ../configure --disable-gui
# ignore the error messages about missing samples
% make
% make install
You can also do:
% mkdir base-debug
% cd base-debug
% ../configure --disable-gui --enable-debug
% make
To build the sample then cd to samples/console and make there.
4. Documentation and support
----------------------------
The console sample provided with this distribution tests most (but not all)
wxBase classes. It doesn't do anything useful per itself but you may want to
look at its code to see examples of usage of the class you are interested in.
There is no separate documentation for wxBase, please refer to wxWidgets
documentation instead.
Support for wxBase is available from the same places as for wxWidgets itself,
namely:
* Website: https://www.wxwidgets.org/
* Mailing Lists: https://www.wxwidgets.org/support/mailing-lists/
Hope you will find wxBase useful!
Vadim Zeitlin

532
libs/wxWidgets-3.3.1/docs/changes.txt Normal file
View File

@@ -0,0 +1,532 @@
-------------------------------------------------------------------------------
wxWidgets Change Log
-------------------------------------------------------------------------------
Note: This file contains the list of changes since wxWidgets 3.2, please see
docs/changes_32.txt for the earlier changes.
INCOMPATIBLE CHANGES SINCE 3.2.x:
=================================
Changes in behaviour not resulting in compilation errors
--------------------------------------------------------
- wxMSW now uses double buffering by default, meaning that updating the
windows using wxClientDC doesn't work any longer, which is consistent with
the behaviour of wxGTK with Wayland backend and of wxOSX, but not with the
traditional historic behaviour of wxMSW (or wxGTK/X11). You may call
MSWDisableComposited() to restore the previous behaviour, however it is
strongly recommended to change your redrawing logic to avoid using wxClientDC
instead, as the code using it still won't work with wxGTK/wxOSX.
You may also choose to globally set the new msw.window.no-composited system
option to disable the use of double buffering, but please consider doing it
only as a last resort and/or temporary solution, as this _will_ result in
flicker and won't be supported at all in the future wxWidgets versions.
- wxMSW doesn't support versions of Microsoft Windows before Windows 7. If you
need Windows XP or Vista support, please use wxWidgets 3.2.
- Default exit code in case of fatal error is now consistently 255, including
when using MSVC for which it was 127 previously. Use wxApp::SetErrorExitCode()
and wxApp::SetFatalErrorExitCode() to change this to old value if needed.
- wxGLCanvas doesn't use multi-sampling by default any longer, please use
wxGLAttributes::Samplers(1).SampleBuffers(4) explicitly if you need to keep
using the same attributes that were previously used by default.
- Default location of file used by wxFileConfig under Unix has changed to
XDG-compliant ~/.config/appname.conf instead of ~/.appname but note that
any existing files at the old location will still continue to be used.
See wxCONFIG_USE_XDG and wxCONFIG_USE_HOME for how to customize this
behaviour. You may also find wxFileConfig::MigrateLocalFile() useful.
- Values of many colours in wxColourDatabase have been changed to use the
values from the CSS standard. Use wxColourDatabase::UseScheme() to revert to
using the traditional values if your application appearance depends on them.
- Default art provider (theme) used by wxAuiNotebook has changed. Set the art
provider to wxAuiNativeTabArt in the code or use "native" in XRC to switch
to the previously used default theme.
- As first mentioned in 3.0 release notes, the value of wxTHREAD_WAIT_DEFAULT,
used by wxThread::Delete() and Wait() by default, has changed from
wxTHREAD_WAIT_YIELD to wxTHREAD_WAIT_BLOCK for safety and consistency.
- wxDocument::OnCloseDocument() was called twice in previous versions when
closing the document from the menu. Now it is only called once and after
destroying all the existing document views. If you overrode this function,
please check that you don't rely on any views existing when it's called.
- wxGrid::FreezeTo() now asserts when passed invalid (out of range) number of
rows or columns to freeze. But it also does freeze the requested rows/columns
even if the grid is currently too small to show all of them or if there are
no unfrozen rows/columns remaining.
- Calling wxImageList methods on an invalid wxImageList object now consistently
results in assert failures instead of just failing silently. To avoid these
asserts, make sure that wxImageList is created with a valid size before
operating on it.
- wxTRANSPARENT_WINDOW doesn't do anything and shouldn't be used any more. If
you ever used it under MSW (it never did anything in the other ports), you
can turn on the native WS_EX_TRANSPARENT extended style if really needed.
- In wxMSW, size passed to wxTextDataObject::SetData() must include the size of
the trailing NUL (in bytes, i.e. 2) now, for consistency with GetDataSize().
Typically this function shouldn't be used directly as SetText() should be
used instead, but if you do use it, you need to update your code to prevent
the last character of the data from being chopped.
- Calling wxListCtrl::EditLabel() now asserts if the control doesn't have
wxLC_EDIT_LABELS style: previously this silently didn't work in wxMSW.
- wxSystemAppearance::IsDark() now returns whether this application uses dark
mode under MSW, use the new AreAppsDark() or IsSystemDark() to check if the
other applications or the system are using dark mode.
- wxUILocale::IsSupported() now returns false for unavailable locales under
Unix systems without trying to fall back on another locale using the same
language in a different region, e.g. it doesn't use fr_FR if fr_BE is not
available. If any locale using the given language is acceptable, the region
must be left empty, e.g. just "fr" would use any available "fr_XX".
- Deprecated wxPGCellRenderer::DrawCaptionSelectionRect() overload is not
called any longer by default, you need to explicitly enable 3.0 compatibility
or change your code to override the newer overload, taking a wxWindow pointer.
- wxImageList size is now expressed in physical pixels, i.e. its size must be
the same as the size of bitmaps added to it, in pixels. This is inconvenient
but should be viewed as a hint not to use wxImageList (but wxBitmapBundle)
in the applications supporting high DPI.
- wxWebRequest doesn't use persistent storage under Mac any longer, as this
made its behaviour there incompatible with the other platforms. Please call
wxWebRequest::EnablePersistentStorage() explicitly if you need it.
- In wxMSW, behaviour of wxBitmap::Create(size, dc) overload has changed to
not scale the size by the content scale factor of the DC any longer, as the
size here is expressed in physical pixels and not in DIPs.
- wxIMAGE_QUALITY_NEAREST has a different numeric value and is not the same
as wxIMAGE_QUALITY_NORMAL any longer, see documentation for more details.
- wxTextCtrl::{Save,Load}File() will use RTF format when saving/loading files
with .rtf extension, and not plain text any longer, by default for the
platforms with RTF support. If you need to save/load plain text even for the
files with the .rtf extension, specify wxTEXT_TYPE_PLAIN explicitly.
- wxClientDC and wxPaintDC now correctly offset their origin by wxFrame
toolbar, if any. This is consistent with the behaviour of the other ports
but may require removing any compensation for not doing this before that may
be present in the application code.
- Calling wxTextCtrl::SetLabel() now consistently does nothing and asserts
under all platforms instead of behaving as SetValue() under MSW and doing
nothing elsewhere.
- If you have a custom class deriving from wxAuiGenericTabArt, possibly
indirectly, e.g. via wxAuiMSWTabArt, you need to update it to override the
new virtual functions DrawPageTab() and GetPageTabSize() instead of
overriding the old DrawTab() and GetTabSize(). Note that this is not needed
if your class inherits directly from wxAuiTabArt, as it will continue to work
in this case (but switching to the new functions is still recommended).
- The meaning of page index in wxAuiNotebook has changed if the pages have
been reordered (see wxAUI_NB_TAB_MOVE) and now always refers to the page
logical index, which is not affected by reordering. To get the position of
the page on screen, which doesn't make sense without reference to the tab
control containing it, use GetPagePosition() to retrieve both of them.
- wxListbook and wxChoicebook now interpret (but ignore) mnemonics in their
page titles, just as the other wx*book classes already did. Double "&"
in the page text if it should be interpreted as a literal "&".
- wxAUI_MGR_HINT_FADE is not included in default wxAuiManager style any longer,
please add it explicitly if you really want to use it.
- Behaviour of wxPrintDialogData::SetAllPages() and SetSelection() has
changed when called with "false" argument, please review the documentation
and update your code if you called them with "false" (which is rarely done).
Changes in behaviour which may result in build errors
-----------------------------------------------------
- Symbols deprecated in 3.0 are still available in this version but disabled by
default, you need to set WXWIN_COMPATIBILITY_3_0 to 1 to enable them. Symbols
deprecated in 2.8 are not available any longer.
- Building with wxUSE_UNICODE=0 is not supported any longer.
- wxUSE_STD_CONTAINERS is now set to 1 by default, see "Container Classes"
overview in the manual for the description of the changes this may require in
the existing code. Alternatively, explicitly set wxUSE_STD_CONTAINERS=0 when
compiling the library to preserve full compatibility with the old versions.
- wxUSE_STL option doesn't exist any longer, standard library is always used.
However, previously setting wxUSE_STL=1 enabled implicit conversion from
wxString to std::[w]string which are not enabled by default now, please set
wxUSE_STD_STRING_CONV_IN_WXSTRING=1 explicitly if you need them.
- wxMSW now requires linking with gdiplus.lib and msimg32.lib.
This is done automatically in most cases, but if you use a static build of
the library with a non-MSVC compiler such as MinGW and do not use wx-config,
then you will need to add these libraries to your make or project files
yourself.
- wxMotif and wxGTK1 ports have been removed, please use wxWidgets 3.2 if you
still need them.
- Several private container classes that never made part of wxWidgets public
API have been removed. If you used any of them (e.g. wxSimpleDataObjectList)
in your code, please switch to using std::vector<> or std::list<> instead.
Some other legacy "object array" classes (e.g. wxImageArray) still exist, but
are now similar to std::vector<> containing the objects -- they remain mostly
compatible with the previous wxWidgets versions, but now compare values, and
not pointers, in their Index() member function.
- All operators (e.g. "==", "+", etc) on wx types are not defined in global
scope any more, resulting in much better error messages but also preventing
them from implicitly being used with types convertible to wx types. If you
really need to use these operators with your own types, please use explicit
conversions.
- Due to the possibility to construct wxString from std::string_view some
previously valid code, such as "wxstr = {"Hello", 2}", is now ambiguous.
Please use explicit class name, e.g. "wxstr = wxString{"Hello", 2}" to
preserve the previous behaviour.
- Generic wxSearchCtrl doesn't provide methods that make sense only for
multiline text controls any longer, for consistency with the other ports.
- wxOnAssert() overload taking wide character file name was removed. If you
call it for any reason, please use one of the other overloads instead.
- 64-bit DLLs now use "x64" suffix in their names for all builds, not just
the official ones and those using MSVS projects, but also when using
makefile.vc or CMake, for consistency.
- Support for memory debugging that was previously disabled but could be
activated by using wxUSE_MEMORY_TRACING, wxUSE_GLOBAL_MEMORY_OPERATORS etc
options was completely removed. Please use address sanitizer or similar
tools that are incomparably more useful for this than that legacy code.
- wxTEST_DIALOG() macro now must be followed by semicolon, whereas previously
it was only supposed to, but it wasn't mandatory to use one after it.
- wxWindow::GetDefaultBorderForControl() is not virtual any longer and will
be completely removed in the future. If you overrode this function, don't
do it any longer. If you call it, replace it with wxBORDER_THEME constant.
- wxGTK wxDirButton::Create() doesn't have unused "wildcard" parameter any
longer, please just remove it from your code if you used it.
- Several functions now take wxReadOnlyDC instead of wxDC as argument. While
any code calling these functions keeps compiling and working, classes that
override these functions must be updated to use the new argument type too.
Simply replacing wxDC with wxReadOnlyDC should be sufficient.
- wxSizer::Detach() takes wxWindowBase pointer now instead of wxWindow.
This only matters if you override this virtual function in your own classes
deriving from wxSizer, please change the function in the derived class to
take wxWindowBase pointer too in this case.
- wx/cursor.h doesn't include wx/utils.h any longer, please include it
explicitly if you need to use any functions defined there other than
cursor-related ones.
- wxStyledTextCtrl::AddSelection() erroneously returned int, while the
corresponding Scintilla doesn't have any return value, so it was changed
to return void, please update your code to not use its return value.
3.3.1: (released 2025-07-21)
----------------------------
All:
- Add persistence support for groups of wxRadioButtons (#25530).
- Add persistence support for wxCheckBox (#25515).
- Add support for PNG "Description" text chunk (GenevensiS, #25556).
- Add wxAuiPaneInfo::FloatingClientSize() (Bill Su, #25483).
- Allow setting app id under supported platforms (#25548).
- Avoid wxEVT_GRID_SELECT_CELL when creating wxGrid (#25498).
- CMake fixes and improvements (Maarten Bent, #25466, #25503, #25592).
- Don't assert in wxGridSizer if sizer is empty (#25641).
- Fix calling wxDVC::Collapse() from event handler (#25631).
- Fix overwriting IDs of buttons added to wxPGMultiButton (alilie, #25514).
- Improve wxRect2DDouble (Blake-Madden, #25497).
- Restore compatibility in wxPropertyGrid (#25627).
- wxNumberFormatter improvements (#25614, #25635).
- Make static reproducible builds under Unix really reproducible (#25502).
wxGTK:
- Fix crash when sorting wxDataViewCtrl with single leaf node (#25625).
- Fix losing wxListCtrl contents after AppendColumn() (#25519).
wxMSW:
- Fix buffer overrun when getting preferred languages list (#25612).
- Fix crash when using per-window menu in MDI applications (#25522).
- Fix crash with wxStaticBitmap inside wxNotebook in dark mode (#25499).
- Fix disabled wxButton bitmaps appearance in dark mode (#25575).
- Fix disabled wxStaticText appearance in dark mode (#25574).
- Fix notebook background in dark high contrast themes (#25542).
- Fix regression in creation of wxAcceleratorTable with 0 entries (#25517).
- Fix regression in wxDataViewCtrl border in light mode (#25532).
- Fix regression in wxTreeCtrl::EnsureVisible() while frozen (#18435).
- Fix selected toolbar buttons in dark mode (Stefan Ziegler, #25616).
- Fix wxComboCtrl appearance in dark mode (#23766).
- Fix wxTE_RICH wxTextCtrl appearance in dark mode (#25602).
- Restore date/time pickers behaviour under non-English OS (#25511).
wxOSX:
- Fix border look for wxDVC, wxListBox, wxTextCtrl (Will Cosgrove, #25570).
- Fix crash on startup when using Farsi as system language (#25561).
3.3.0: (released 2025-06-06)
----------------------------
This release contains the following major changes compared to 3.2.8:
- Add experimental dark mode support to wxMSW (#23028)
- Add Chromium-based wxWebView backend (#706).
- Add support for WebP images (Hermann Höhne, Maarten Bent, #25205).
- Add support for pinned/locked (#25187) and multi-row (#25076) wxAUI tabs.
- Add synchronous (blocking) version of wxWebRequest (#24760).
- Add API for raw touch events (Martin Koegler, #17077).
- Implement accessibility support for wxGrid (Dietmar Schwertberger, #24368).
- Implement power events and blockers support under Unix (#22396, #23717)
- Use native file dialogs if possible in wxGTK (#24486, #25104).
- Provide access to native wxTextCtrl contents (Blake-Madden, #24626, #24912).
Other changes are listed in alphabetical order in platform-specific sections:
All:
- Accept std::initializer_list in wxArray ctor (Lotendan, #23309).
- Add US Catholic Feasts support to wxDateTime (Blake Madden, #24094)
- Add WXLOG_TIME_FORMAT environment variable (#23576).
- Add __WXFUNCTION_SIG__ (Blake-Madden, #24554).
- Add catch-unhandled-exceptions system option (Lauri Nurmi, #25257).
- Add date-related localization functions (Ulrich Telle, #23556).
- Add support for setting base URL in wxWebRequest (#24769).
- Add support for setting the proxy to use in wxWebRequest (#24762).
- Add wxGrid::Enable{Row,Col}Resize().
- Add wxNODISCARD and use it for some functions (PB, #22943).
- Add wxNO_REQUIRE_LITERAL_MSGIDS (Lauri Nurmi, #24957).
- Add wxString::wc_string() (#23463).
- Add wxURI::SetUserAndPassword() (#25240).
- Add wxWARN_UNUSED and use it for wxString (Lauri Nurmi, #24833).
- Add wxWebSession::EnablePersistentStorage() (Tobias Taschner, #23743).
- Add wxXmlParseError to wxXmlDocument::Load() (Randalphwa, #24215).
- Allow customizing exit code in case of error (#24770).
- Allow using lambdas with Bind() without RTTI (MapleLeaf-X, #14850).
- Allow using wxMessageQueue with move-only types (#25026).
- Avoid DNS lookup when constructing wxIPV4address from IP (SMMB-DEV, #23109).
- Fix multiple bugs in wxURI parsing (Ryan Norton, #23360).
- Fix wxSocket::Peek() with UDP sockets (Brian Nixon, #23594).
- Fix wxWebResponse::GetMimeType(), add GetContentType() (Blake-Madden, #23461).
- Improve locale matching algorithm (Ulrich Telle, #24855)
- Make wxLogXXX(string) safe to use (#25414).
- Make wxPlatformInfo::Get() thread-safe (#25459).
- Make wxString {To,From}CDouble() faster and more robust (#23287).
- Make wxrc-generated code faster to build (DoctorNoobingstoneIPresume, #24579).
- Multiple headers with same name in wxWebRequest (Stefan Dinkelacker, #24878).
- Operators on wx types are not defined in global scope any more (#24190).
- Optimize wxString by supporting move operations (Pavel Tyunin, #23215)
- Optimize wxString::operator<<() for numeric types (#25388).
- Preserve errno in wxString methods (Lauri Nurmi, #23113).
- Support constructing wxString from std::string_view (Ian McInerney, #23711).
- Update 3rd party libraries to latest versions (Maarten Bent, #25112, #25325).
- Update translations for Brazilian Portuguese (Felipe), Corsican (Patriccollu,
#25420), Czech (PB, #25412), French (#25400), German (tstkr),
Romanian (Cătălin Răceanu, #25403), Simplified Chinese (0tkl, #25450),
Turkish (Kerim Demirkaynak, #25267) and Ukrainian (Yuri Chornoivan, #25410).
- Update language database (Ulrich Telle, #23437).
- Use UTF-8 for environment variables (#25101).
- Use variadic templates for vararg functions (#22981).
- Use XDG-compliant location by default in wxFileConfig under Unix (#24195).
All (GUI):
- Add "feature" attribute to XRC (#23184).
- Add RTF support to wxTextCtrl (Blake-Madden, #24626).
- Add WXK_NUMPAD_CENTER (Ivan Sorokin, #23478).
- Add XRC handler for wxVListBox (Bill Su, #24361).
- Add checks for incorrect use of wxGridTable messages.
- Add high DPI support to generic wxListCtrl (Gerhard Stein, #22916).
- Add support for "id" attribute in wxHTML (Oleg Tolmatcev, #24968).
- Add support for high DPI animations (#23817).
- Add support for high DPI cursors via wxCursorBundle (#25374).
- Add support for loading wxPropertyGrid from XRC (#24274).
- Add support for printing multiple page ranges (Stefan Ziegler, #25030).
- Add wxApp::SetAppearance() to explicitly set dark or light mode (#24461).
- Add wxAuiManager::{Save,Load}Layout() (#24235).
- Add wxGrid::CopySelection() (Blake Madden, #24124).
- Add wxInfoBar::ShowCheckBox() (Blake Madden, #25394).
- Add wxRadioButton group support to wxGenericValidator (Bill Su, #24264).
- Add wxRibbonBar::GetPageById() (Blake Madden, #24211).
- Add wxStatusBar::AddFieldControl() (AliKet, #24092).
- Add wxTexTCtrl::SearchText() (Blake-Madden, #24756).
- Allow resizing row and column labels in wxGrid (Dietmar Schwertberger, #24362).
- Allow setting fonts in wxAuiTabArt to work (#24829).
- Allow specifying size of wxTextEntryDialog (Blake-Madden, #24467).
- Allow using wxVListBox wxXRC_NO_SUBCLASSING (Bill Su, #25144).
- Derive wxSearchCtrl from wxTextEntry in all ports (Martin Corino, #23686).
- Fix default background of RLE bitmaps (Brian Nixon, #23599).
- Fix handling of sizers inside <windowlabel> XRC tag.
- Fix loading some bitmaps using BI_BITFIELDS (Brian Nixon, #23601).
- Fix print preview in high DPI (taler21, #24666).
- Fix wxAUI dock art appearance after DPI change (Maarten Bent, #23420).
- Fix wxFontList::FindOrCreateFont() for non-integral sizes (PB).
- Fix wxGrid::GetDropTarget() (Dan Allen, #24448)
- Fix wxNUM_VAL_ZERO_AS_BLANK behaviour on focus loss (#24859).
- Fix wxPGVIterator used in wxPropertyGridManager (#23273).
- Fix wxTextCtrl proof checking functions return values (mcorino, #23832).
- Implement client data support in wxAuiToolBar (Miguel Gimenez, #23271).
- Improve generic and MSW "About" dialog appearance (#23196).
- Improve item sorting in generic wx{File,Dir}Ctrl (PB, #23962).
- Improve wxImage resizing quality (Alex Shvartzkop, #25252).
- Make date/time picker controls locale-aware (Ulrich Telle, #23965).
- Make wxEL_ALLOW_NEW without wxEL_ALLOW_EDIT work (Martin Corino, #24099).
- Make wxGenericValidator more flexible (Bill Su, #24134).
- Make wxGrid::ProcessTableMessage() more convenient to use (Joachim Wiesemann).
- Provide reason for wxNotificationMessage dismissal (Lauri Nurmi, #24340).
- Respect menu path style in wxFileHistory::AddFilesToMenu() (Bill Su, #25451).
- Restore non-live-resize in wxAUI and wxSplitterWindow (AliKet, #24193).
- Save/restore wxAuiNotebook layout (#24950).
- Several fixes to scrolling in wxVListBox (Bill Su, #24278).
- Support high DPI bitmaps in wxBusyInfo (#23813).
- Support specifying dark mode colours in XRC (#23571).
- Support wxCHK_UNDETERMINED in wxUpdateUIEvent (Bill Su, #24764).
- Update Scintilla to 5.0 and Lexilla to 5.3 (Maarten Bent, #23117, #24369).
- Update nanosvg to fix possible crashes (#24213).
- Use CSS colour names (#23518).
- Use new default flat tab art provider in wxAUI (#25316).
- Use thousands separators in page numbers when printing (Blake-Madden, #25320).
All (CMake):
- Add CMake presets (Tobias Taschner, #23335).
- Add option to use all built-in libraries (Maarten Bent).
- Build mfc sample too (Maarten Bent, #25402).
- Fix generated wx-config when using custom flavour (#25398).
- Fix using static runtime with msvc (Maarten Bent, #25098).
All (WebView):
- Add support for clearing browsing data (Tobias Taschner, #24431).
- Add advanced requests (Tobias Taschner, #22797).
- Add child window handling (Tobias Taschner, #23334).
- Add new wxEVT_WEBVIEW_CREATED (#706).
- Add wxWebView::EnableBrowserAcceleratorKeys() (Tobias Taschner, #23070)
- Add wxWebView::EnablePersistentStorage() (Tobias Taschner, #24405).
- Add wxWebView::GetNativeConfiguration() (Tobias Taschner, #22781).
- Add wxWebView::SetProxy() (#23854).
- Add wxWebView::ShowDevTools() (#24799).
- Add wxWebViewConfiguration (Tobias Taschner, #23374).
- Add wxWebViewEvent::IsTargetMainFrame() (Tobias Taschner, #23238).
- Allow setting wxWebViewEdge UA after creation (Tobias Taschner, #23225).
- Implement StartRequest() in wxWebViewChromium (John R. Patek, #25395).
- Queue Edge wxWebView events (Tobias Taschner, #22744, #19075).
wxGTK:
- Add support for building with libwebkit2gtk-4.1 (Scott Talbert, #23633).
- Add support for wxRB_SINGLE (Stefan Hansson, #23652).
- Add wxTextCtrl::GTKSetPangoMarkup() (Blake-Madden, #24912)
- Add wxWindow::GTKGetWin32Handle() (Ryan Ogurek, #24675).
- Don't require libsecret-1.so presence at run-time (#25355).
- Fix handling of binary secrets in wxSecretStore (Martin Corino, #24352).
- Fix handling total window size with GNOME with X11 (#25348).
- Fix height of read-only wxBitmapComboBox (#25468).
- Fix missing enter/leave window events (#24339).
- Fix wxGLCanvas scale when using EGL/Wayland in high DPI (Popax21, #23733).
- Fix using wrong colour in wxPrinterDC (#24729).
- Fix wxKeyEvent::GetKeyCode() in non-US layouts (Ivan Sorokin, #23379).
- Implement generation of wxDPIChangedEvent (#19290, #24040).
- Implement max length limit for multiline wxTextCtrl (Igor Korot, #24751).
- Implement wxTextCtrl::SearchText() (Blake-Madden, #24897).
- Improve wxInfoBar appearance when text doesn't fit (#24695).
- Improve wxSlider min/max labels positioning (#24106).
- Limit radius in wxDC::DrawRoundedRectangle() (Alex Shvartzkop, #24327).
- Multiple fixes to mouse event generation (#24931, #24932, #24933).
wxMSW:
- Add support for extended-length paths (#25033).
- Add support for markup to wxStaticText (#25000).
- Allow changing wxHyperLink colour (#23549).
- Allow using static CRT in MSBuild projects (David Connet).
- Change default wxTreeCtrl to use more modern look (PB, #23844).
- Don't append unwanted extension in wxFileDialg (Martin Corino, #24949).
- Enable double buffering for all windows (#22851).
- Fix AUI tab close button size on DPI change (Kumazuma, #23400).
- Fix background of wxCollapsiblePane inside wxNotebook (#23274).
- Fix background of wxStaticText in wxAuiToolbar (#24765).
- Fix build issues with llvm clang (Sergey Khalyutn, Maarten Bent, #23468).
- Fix loading message catalogs with "@" in their names (Mike Wang).
- Fix missing closing line in wxGDIPlusContext::DrawLines() (#24645).
- Fix multiple problems in UTF-8 build (#23313).
- Fix not showing help text for submenus (David Langhals, #24724).
- Fix resizing of TLWs with single child on DPI change (#22983)
- Fix saving geometry of Aero-snapped windows (Randalphwa).
- Fix security issue when running on secure desktop (Sean Budd).
- Fix using strings with Unicode characters outside of BMP (#25128).
- Fix wxDisplay invalidation on connected display change (Marcel Pham, #25396).
- Fix wxOverlay and wxScrolled auto-scrolling in RTL layout (AliKet, #25413).
- Fix wxPropertyGrid expander buttons appearance in high DPI (#24304).
- Implement support for wxBG_STYLE_TRANSPARENT (Maarten Bent, #23412).
- Implement RTL support in wxGraphicsContext with GDI+ (AliKet, #25431).
- Improve wxGetUserName() implementation (Blake-Madden, #24242).
- Increase wxButton default size in high DPI (#25297).
- Link with gdiplus.lib and msimg32.lib directly (Maarten Bent, #24614).
- Reimplement wxOverlay using layered windows (AliKet, #23261).
- Return bool from wxBitmap::UseAlpha() (PB, #23919).
- Support printing current or selected pages (Stefan Ziegler, #23372).
- Turn wxCAPTION on automatically if required by other styles (#23575).
- wxNotebook::HitTest() for tabs on the right/left (Gerhard Gruber, #23023)
- wxMessageOutputBest uses associated console, if any (#25068).
wxOSX:
- Add loading wxCursor from resources (oneeyeman1, Maarten Bent, #24374)
- Add missing const wxFontDialog::GetFontData() (Martin Corino, #23691).
- Do not activate "Close" button on Cmd-C (nobugshere, #25346).
- Ensure that wxEventLoop::OnExit() is called (#25409).
- Fix setting cursor for TLWs (unawarez, #25131).
- Make wxUIActionSimulator actually work (Martin Corino, #23692).
wxQt:
- Fix clipping in wxDC to work as expected (AliKet, #23600).
- Fix wxButton::GetLabel() (AliKet, #22929).
- Fix wxEVT_TEXT_ENTER processing (AliKet, #22942).
- Fix wxFrame::ClientToScreen() (AliKet, #22969).
- Fix wxPopupWindow implementation under wxQt (AliKet, #23904).
- Fix wxRadioButton selection (AliKet, #22991).
- Fixes for Qt 6.8.2 (AliKet, #25207).
- Fixes for wxSlider ticks and events (AliKet, #22989).
- Implement clipboard and undo support in wxTextCtrl (AliKet, #22973).
- Implement more wxTextCtrl methods (AliKet, #23984).
- Implement wxRadio{Box,Button}::{Set,Get}Label() (Alex Shvartzkop, #24309).
- Implement wxTextCtrl::SearchText() (AliKet, #24899).
- Make wxGLCanvas work (Alex Shvartzkop, #24200).
- Make wxPen and wxBrush behaviour more consistent with the other ports (AliKet, #23863).
- Make wxTopLevelWindow::SetSizeHints() works (AliKet, #23917).
- Many improvements in wxListCtrl (AliKet, #23029).
- Many improvements to wxDC (Alex Shvartzkop, #24328).
- Many improvements to wxListBox (AliKet, #23063).
- Provide native wxOverlay implementation (AliKet, #24080).
- Provide native wx{Date,Time}Ctrl (AliKet, #23925).
- Provide wxRendererNative implementation (AliKet, #24223).
- Refresh children too in wxWindow::Refresh() (AliKet, #22918).
- Several fixes and improvements (AliKet, #22932).
- Support accelerators and radio items in wxMenu (AliKet, #22985).
- Support extended message and custom labels in wxMessageDialog (#24299).
- Support images and tab orientation in wxNotebook (AliKet, #22997).
- Use premultiplied ARGB32 format for wxBitmap (AliKet, #23872).

5027
libs/wxWidgets-3.3.1/docs/changes_30.txt Normal file
View File

File diff suppressed because it is too large Load Diff

1270
libs/wxWidgets-3.3.1/docs/changes_32.txt Normal file
View File

File diff suppressed because it is too large Load Diff

165
libs/wxWidgets-3.3.1/docs/contributing/about-platform-toolkit-and-library-names.md Normal file
View File

@@ -0,0 +1,165 @@
## wxWidgets naming conventions
Being a cross platform development library, it is naturally desirable
(at least to me ;) for wxWidgets to be exploited in a fully cross
platform development environment -- a single invocation of make should
be sufficient to build target executables for a variety of host platforms
when desired.
Since this is now in fact possible for at least the most commonly used
platforms, wxWidgets has been structured to allow multiple, simultaneous
installations of the library. Common files are shared, platform and port
specific files and libraries are arranged so as to be unambiguous when
installed together.
To manage this sanely we need a sufficiently descriptive and logical
labelling convention for file and install path names -- this document (at
least at its time of writing) describes the system we have adopted.
It is not fine grained enough to include every possible build configuration
for wxWidgets, but is encompassing enough to maintain a relatively complete
set of cross platform build tools on a single machine and to provide an
obvious slot for new ports to slip into.
The libraries use the following naming convention.
When an item of the name is empty, `'_'` or `'-'` are omitted.
*UNIX libraries* (configure, CMake on Linux/macOS/Cygwin):
libwx_$(toolkit)$(widgetset)u_$(flavour)_$(name)-$(version)-$(host).$(lib_extension)
*Windows libraries* (VS solution, makefile.gcc/vc, CMake on Windows, shared libraries on Windows):
wx$(toolkit)$(widgetset)$(version)u$(debug)_$(flavour)_$(name)_$(compiler)_$(arch)_$(vendor).$(lib_extension)
Where:
--------------------------------------------------------------------
`$toolkit` can currently be one of the following:
- `base`
- `msw`
- `gtk`, `gtk2`, `gtk3`, `gtk4`
- `osx_cocoa`, `osx_iphone`
- `x11`
- `dfb`
- `qt`
--------------------------------------------------------------------
`$widgetset` may be one of:
- `univ`
or empty if the widget set is the same as the toolkit.
--------------------------------------------------------------------
`$version` is a string encoding the major and minor version number,
separated by a dot on UNIX and without separator on Windows.
Windows shared libraries of development versions (odd minor releases)
contain the full version (major, minor, release).
On UNIX, the `$so_version` contains the release number.
Eg. for wxWidgets 3.1.5, `$version` is `315` for Windows shared libraries,
`31` for Windows static libraries, and `3.1` for UNIX libraries. And the
`$so_version` for UNIX libraries is `.5` and `.5.0.0`.
The rationale for this is that under UNIX-like systems it is desirable
that differently 'minor numbered' releases can be installed together,
meaning 3.0 apps can continue to work even if you migrate development
to the next stable or unstable release (eg. 3.2, 3.3), but binary
compatibility is maintained between point releases (those with the same
major.minor number).
A known break in binary compatibility should be addressed by updating
the library soname (see the notes in configure.ac for details on this).
--------------------------------------------------------------------
The `'u'` in the library names refers to "Unicode" build, which is now the only
supported one, but which used to be optional.
--------------------------------------------------------------------
`$debug` is set to `'d'` for the libraries using debug version of CRT and is empty
for release libraries. It is only really useful for the libraries created with MSVC,
as MSVC debug and release CRT are not ABI-compatible, but is also used by MinGW
(makefile.gcc, CMake) for consistency with MSVC builds. When using configure under
MSW or UNIX, it is always empty.
--------------------------------------------------------------------
`$flavour` is an optional name to identify the build. It is empty by default.
--------------------------------------------------------------------
`$name` is the name of the library. It is empty for the `'base'` library.
--------------------------------------------------------------------
`$compiler` is the used compiler, for example `'vc'` or `'gcc'`.
It is only added to shared libraries on Windows.
--------------------------------------------------------------------
`$arch` is used only when building with MSVC. It is empty for 32-bit builds and
`'x64'` for 64-bit builds. It is only added to shared libraries.
--------------------------------------------------------------------
`$vendor` is an optional name appended to the library name. It is only
added to shared libraries on Windows. It defaults to `'custom'` and is
empty for the official Windows binaries.
--------------------------------------------------------------------
`$host` is empty for a 'native' library, (that is one where the host
system is the same as the build system) or set to the value returned
by the autoconf ${host_alias} variable in configure for libraries
that are cross compiled.
--------------------------------------------------------------------
`$lib_extension` is system specific. On UNIX, it is most usually set
to `'.a'` for a static library and `'.so.$so_version'` for a shared library.
On Windows, it is `'.lib'` for a static or import MSVC library, `'.a'` for a
static or import GCC or clang library, and `'.dll'` for a shared library.
--------------------------------------------------------------------
`type` is used to indicate a shared or static build. On Windows, type is
`'dll'` for shared libraries and `'lib'` for static libraries.
On UNIX, type is empty for shared libraries and `'static'` for static libraries.
--------------------------------------------------------------------
## setup.h
The installed location of the library specific setup.h is also
determined by the values of these items. On UNIX they will be found in:
$(prefix)/lib/wx/include/$(host)-$(toolkit)$(widgetset)-unicode-$(type)-$(version)-$(flavour)/wx/setup.h
which will be in the include search path returned by the relevant
wx-config for that library (or presumably set in the relevant
make/project files for platforms that do not use wx-config).
For MSVC and gcc/vc makefile, the file is found in:
$(prefix)/lib/$(compiler)_$(arch)_$(type)/$(toolkit)$(widgetset)u$(debug)/wx/setup.h
--------------------------------------------------------------------
## wx-config
The port specific wx-config file for each library shall be named:
$(prefix)/lib/wx/config/$(host)-$(toolkit)$(widgetset)-unicode-$(type)-$(version)-$(flavour)
${prefix}/bin/wx-config shall exist as a link to (or copy of) one of
these port specific files (on platforms which support it) and as such
it defines the default build configuration for wxApps on the system.
It may be modified by the system user at any time.

39
libs/wxWidgets-3.3.1/docs/contributing/about-version-numbers.md Normal file
View File

@@ -0,0 +1,39 @@
All about wxWidgets Version Numbers
===================================
## Where to update the version numbers
There are several places in the wxWidgets source tree that
define the version number for the library.
The script `misc/scripts/inc_release` can be used for incrementing the release
field of the version, i.e. changing 2.8.x to 2.8.x+1 but it does not take
care of version.bkl and can't be used for changing the other version
components, this needs to be done manually. It also doesn't update
version.bkl file which always needs to be updated manually, follow the
instructions there.
Here is the list of files that need to be updated:
- build/bakefiles/version.bkl {C:R:A} [NOT UPDATED AUTOMATICALLY]
- configure.ac
- build/osx/wxvers.xcconfig
- docs/changes.txt
- docs/readme.txt (date needs manual editing) [NOT UPDATED AUTOMATICALLY]
- docs/doxygen/Doxyfile (PROJECT_NUMBER and DOCSET_FEEDNAME)
- docs/doxygen/mainpages/manual.h (just date) [NOT UPDATED AUTOMATICALLY]
- include/wx/version.h
- include/wx/osx/config_xcode.h
- samples/minimal/Info_cocoa.plist
- samples/minimal/CMakeListst.txt [major/minor only]
Do not forget to rebake everything after updating version.bkl!
## When to update the version numbers
Version should be updated immediately after releasing the previous version
so that the sources in the repository always correspond to the next release
and not the past one.
See also [binary compatibility notes](binary-compatibility.md)

292
libs/wxWidgets-3.3.1/docs/contributing/binary-compatibility.md Normal file
View File

@@ -0,0 +1,292 @@
Binary Compatibility and wxWidgets
==================================
Purpose
-------
This is a broad technote covering all aspects of binary compatibility with
wxWidgets.
Releases
--------
General overview of releases can be found in [wxWidgets naming conventions](about-platform-toolkit-and-library-names.md),
but for completeness the wxWidgets release version number is as follows:
2.6.2
Where
2 6 2
Major Minor Release
(i.e. Major.Minor.Release).
All versions with EVEN minor version component (e.g. 2.8.x, 3.0.x etc.)
are expected to be binary compatible (ODD minors are development versions
and the compatibility constraints don't apply to them). Note that by
preserving binary compatibility we mean BACKWARDS compatibility only,
meaning that applications built with old wxWidgets headers should continue
to work with new wxWidgets (shared/dynamic) libraries without the need to
rebuild. There is no requirement to preserve compatibility in the other
direction (i.e. make new headers compatible with old libraries) as this
would preclude any additions whatsoever to the stable branch. But see
also the section about `wxABI_VERSION`.
What kind of changes are NOT binary compatible
----------------------------------------------
[The KDE guide](https://community.kde.org/Policies/Binary_Compatibility_Issues_With_C%2B%2B)
is a good reference.
The changes that are NOT binary compatible:
- Adding a virtual function
- Changing the name of any function or variable
- Changing the signature of a virtual function (adding a parameter,
even a default one)
- Changing the order of the virtual functions in a class ("switching" them, etc.)
- Changing access privileges of a function: some compilers (among which MSVC)
use the function access specifier in its mangled name. Moreover, while
changing a private function to public should be compatible (as the old
symbol can't be referenced from outside the library anyhow), changing a
virtual private function to public is NOT compatible because the old symbol
is referenced by the virtual tables in the executable code and so an old
program compiled with MSVC wouldn't start up with a new DLL even if it
doesn't use the affected symbol at all!
- Adding a member variable
- Changing the order of non-static member variables
Changes which are compatible
----------------------------
- Adding a new class
- Adding a new non-virtual method to an existing class
- Adding a new constructor to an existing class
- Overriding the implementation of an existing virtual function
(this is considered to be backwards binary compatible until we find a
counter example; currently it's known to work with Apple gcc at least)
- Anything which doesn't result in ABI change at all, e.g. adding new
macros, constants and, of course, private changes in the implementation
`wxABI_VERSION` and "forward" binary compatibility
--------------------------------------------------
As mentioned we do not support "forward" binary compatibility, that is the
ability to run applications compiled with new wxWidgets headers on systems
with old wxWidgets libraries.
However, for the developers who want to ensure that their application works
with some fixed old wxWidgets version and doesn't (inadvertently) require
features added in later releases, we provide the macro `wxABI_VERSION` which
can be defined to restrict the API exported by wxWidgets headers to that of
a fixed old release.
For this to work, all new symbols added to binary compatible releases must
be `#if`'ed with `wxABI_VERSION`.
The layout of `wxABI_VERSION` is as follows:
20602
where
2 06 02
Major Minor Release
I.e. it corresponds to the wxWidgets release in section Releases.
An example of using `wxABI_VERSION` is as follows for symbols
only in a 2.6.2 release:
```cpp
#if wxABI_VERSION >= 20602 /* 2.6.2+ only */
bool Load(const wxURI& location, const wxURI& proxy);
wxFileOffset GetDownloadProgress();
wxFileOffset GetDownloadTotal();
bool ShowPlayerControls(
wxMediaCtrlPlayerControls flags =
wxMEDIACTRLPLAYERCONTROLS_DEFAULT);
//helpers for the wxPython people
bool LoadURI(const wxString& fileName)
{ return Load(wxURI(fileName)); }
bool LoadURIWithProxy(const wxString& fileName, const wxString& proxy)
{ return Load(wxURI(fileName), wxURI(proxy)); }
#endif
```
Workarounds for adding virtual functions
----------------------------------------
Originally the idea for adding virtual functions to binary compatible
releases was to pad out some empty "reserved" functions and then
rename those later when someone needed to add a virtual function.
However, after there was some actual testing of the idea a lot of
controversy erupted. Eventually we decided against the idea, and
instead devised a new method for doing so called wxShadowObject.
wxShadowObject is a class derived from wxObject that provides a means
of adding functions and/or member variables to a class internally
to wxWidgets. It does so by storing these in a hash map inside of
it, looking it up when the function etc. is called. wxShadowObject
is generally stored inside a reserved member variable.
wxShadowObject resides in include/wx/clntdata.h.
To use wxShadowObject, you first call AddMethod or AddField with
the first parameter being the name of the field and/or method
you want, and the second parameter being the value of the
field and/or method.
In the case of fields this is a void*, and in the case of method
is a wxShadowObjectMethod which is a typedef:
typedef int (*wxShadowObjectMethod)(void*, void*);
After you add a field, you can set it via SetField with the same
parameters as AddField, the second parameter being the value to set
the field to. You can get the field after you call AddField
via GetField, with the parameters as the other two field functions,
only in the case the second parameter is the fallback
value for the field in the case of it not being found in the
hash map.
You can call a method after you add it via InvokeMethod, which
returns a bool indicating whether or not the method was found
in the hash map, and has 4 parameters. The first parameter is
the name of the method you wish to call, the second is the first
parameter passed to the wxShadowObjectMethod, the third is the
second parameter passed to that wxShadowObjectMethod, and the
fourth is the return value of the wxShadowObjectMethod.
version-script.in
-----------------
For ld/libtool we use sun-style version scripts. Basically
anything which fits the conditions of being `#if`'ed via `wxABI_VERSION`
needs to go here also.
See 'info ld scripts version' on a GNU system, it's online here:
https://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_node/ld_25.html
Or see chapter 5 of the 'Linker and Libraries Guide' for Solaris, available
online here:
https://docs.oracle.com/cd/E19120-01/open.solaris/819-0690/chapter5-84101/index.html
The file has the layout as follows:
@WX_VERSION_TAG@.X
Where X is the current Release as mentioned earlier, i.e. 2. This
is following by an opening bracket "{", followed by "global:",
followed by patterns matching added symbols, then followed by "}", and then
the file is either followed by earlier Releases or ended by
a @WX_VERSION_TAG@ block without the period or Release.
The patterns used to specify added symbols are globbing patters and can
contain wildcards such as '*'.
For example for a new class member such as:
wxFont wxGenericListCtrl::GetItemFont( long item ) const;
the mangled symbol might be:
_ZNK17wxGenericListCtrl11GetItemFontEl
so a line like this could be added to version-script.in:
\*wxGenericListCtrl*GetItemFont*;
Allow for the fact that the name mangling is going to vary from compiler to
compiler.
When adding a class you can match all the symbols it adds with a single
pattern, so long as that pattern is not likely to also match other symbols.
For example for wxLogBuffer a line like this:
\*wxLogBuffer*;
Checking the version information in libraries and programs
----------------------------------------------------------
On Sun there is a tool for this, see pvs(1). On GNU you can use objdump, below
are some examples.
To see what versions of each library a program (or library) depends on:
$ objdump -p widgets | sed -ne '/Version References/,/^$/p'
Version References:
required from libgcc_s.so.1:
0x0b792650 0x00 10 GCC_3.0
required from libwx_based-2.6.so.0:
0x0cca2546 0x00 07 WXD_2.6
required from libstdc++.so.6:
0x056bafd3 0x00 09 CXXABI_1.3
0x08922974 0x00 06 GLIBCXX_3.4
required from libwx_gtk2d_core-2.6.so.0:
0x0a2545d2 0x00 08 WXD_2.6.2
0x0cca2546 0x00 05 WXD_2.6
required from libc.so.6:
0x09691a75 0x00 04 GLIBC_2.2.5
To see what WXD_2.6.2 symbols a program uses:
$ objdump -T widgets | grep 'WXD_2\.6\.2'
0000000000000000 g DO *ABS* 0000000000000000 WXD_2.6.2 WXD_2.6.2
00000000004126d8 DF *UND* 0000000000000177 WXD_2.6.2 _ZN19wxTopLevelWindowGTK20RequestUserAttentionEi
To see what WXD_2.6.2 symbols a library defines:
$ objdump -T libwx_based-2.6.so | grep 'WXD_2\.6\.2' | grep -v 'UND\|ABS'
0000000000259a10 w DO .data 0000000000000018 WXD_2.6.2 _ZTI19wxMessageOutputBest
00000000002599e0 w DO .data 0000000000000028 WXD_2.6.2 _ZTV19wxMessageOutputBest
000000000010a98e w DF .text 000000000000003e WXD_2.6.2 _ZN19wxMessageOutputBestD0Ev
0000000000114efb w DO .rodata 000000000000000e WXD_2.6.2 _ZTS11wxLogBuffer
0000000000255590 w DO .data 0000000000000018 WXD_2.6.2 _ZTI11wxLogBuffer
000000000011b550 w DO .rodata 0000000000000016 WXD_2.6.2 _ZTS19wxMessageOutputBest
00000000000bfcc8 g DF .text 00000000000000dd WXD_2.6.2 _ZN11wxLogBuffer5DoLogEmPKcl
000000000010a3a6 g DF .text 0000000000000153 WXD_2.6.2 _ZN19wxMessageOutputBest6PrintfEPKcz
00000000000c0b22 w DF .text 000000000000004b WXD_2.6.2 _ZN11wxLogBufferD0Ev
00000000000bfc3e g DF .text 0000000000000089 WXD_2.6.2 _ZN11wxLogBuffer5FlushEv
00000000000c0ad6 w DF .text 000000000000004b WXD_2.6.2 _ZN11wxLogBufferD1Ev
00000000000b1130 w DF .text 0000000000000036 WXD_2.6.2 _ZN11wxLogBufferC1Ev
00000000000c095c w DF .text 0000000000000029 WXD_2.6.2 _ZN19wxMessageOutputBestC1Ev
00000000000c08e8 w DF .text 000000000000003e WXD_2.6.2 _ZN19wxMessageOutputBestD1Ev
00000000002554c0 w DO .data 0000000000000038 WXD_2.6.2 _ZTV11wxLogBuffer
00000000000bfda6 g DF .text 0000000000000036 WXD_2.6.2 _ZN11wxLogBuffer11DoLogStringEPKcl
00000000000abe10 g DF .text 0000000000000088 WXD_2.6.2 _ZN14wxZipFSHandler7CleanupEv
Testing binary compatibility between releases
---------------------------------------------
An easy way of testing binary compatibility is just to build wxWidgets
in dll/dynamic library mode and then switch out the current library
in question with an earlier stable version of the library, then running
the application in question again. If it runs OK then there is usually
binary compatibility between those releases.
You can also break into your debugger or whatever program you want
to use and check the memory layout of the class. If it is the same
then it is binary compatible.
(In GDB the command x/d will show addresses as pointers to functions if
possible so you can see if the order of the functions in vtbl doesn't change.)
Another way to check for binary compatibility is to build wxWidgets in shared mode
and use the 'abicheck.sh --generate' script before doing your changes to generate
the current ABI (if the 'expected_abi' file is not already in the repo).
Then rebuild wxWidgets with your changes and use 'abicheck.sh' to compare the
resulting ABI with the expected one.
Note that the abicheck.sh script is in the "lib" folder.

314
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-class-documentation.md Normal file
View File

@@ -0,0 +1,314 @@
Adding wxWidgets class documentation
====================================
This note is aimed at people wishing to add documentation for a
class to either the main wxWidgets manual, or to their own
manual.
wxWidgets uses Doxygen to process header input files with embedded
documentation in the form of C++ comments and output in HTML, and XML
(Doxygen itself can also output Latex, manpages, RTF, PDF etc).
See http://www.doxygen.org for more info about Doxygen.
If you want to add documentation of a new class/function to the
existing manual in docs/doxygen, you need to create a new .h file,
e.g. myclass.h, under the interface folder, which contains the public
interface of the new class/function in C++ syntax.
The documentation can then be added in form of Doxygen comments to
the header file.
You may also want to write a separate topic file,
e.g. `docs/doxygen/overviews/myclass.h`, and add the entry to
`docs/doxygen/mainpages/topics.h`.
If applicable, also add an entry to one of the `docs/doxygen/mainpages/cat_*.h`
files.
You can generate a first raw version of myclass.h simply taking its
"real" header and removing all the private and protected sections and
in general removing everything the user "shouldn't know": i.e. all things
which are implementation details.
Running Doxygen
---------------
First, make sure you have a recent version of Doxygen (currently Doxygen 1.8.8
is used) and Graphviz installed in your system (under Windows Graphviz
location should be in %PATH%).
On Unix:
1. run `wxWidgets/docs/doxygen/regen.sh [format-to-generate]`
On Windows:
1. cd wxWidgets/docs/doxygen
2. run `regen.bat [format-to-generate]`
If you don't specify which format to generate, all output formats will
be enabled. Possible values for `format-to-generate` are: `html`, `chm`, `latex`,
`xml` and `all`.
The output of Doxygen is all placed in the wxWidgets/docs/doxygen/out folder.
Important Dos and Don'ts
------------------------
DO:
- use present tense verbs in 3rd person singular form to describe functions,
i.e. write "Returns the answer to life, universe and everything", rather than
the imperative mood used in Git commit message ("Return the answer ...").
- Doxygen supports both commands in the form \command and @command;
all wxWidgets documentation uses the @command form.
Follow strictly this rule.
- strive to use dedicated Doxygen commands for e.g. notes, lists,
sections, etc. The "Special commands" page:
http://www.doxygen.org/manual/commands.html
is your friend!
It's also very important to make a consistent use of the ALIASES
defined by wxWidgets' Doxyfile. Open that file for more info.
- when you write true, false and nullptr with their C++ semantic meaning,
then use the @true, @false and @NULL commands.
- separate different paragraphs with an empty comment line.
This is important otherwise Doxygen puts everything in the same
paragraph making the result less readable.
- leave a blank comment line between a @section, @subsection, @page
and the next paragraph.
- test your changes, both reading the generated HTML docs and by looking
at the "doxygen.log" file produced (which will warn you about any
eventual mistake found in the comments).
- quote all the following characters prefixing them with a "@" char:
@ $ \ & < > # %
unless they appear inside a @code or @verbatim section
(you can also use HTML-style escaping, e.g. &amp; rather than @ escaping)
- when using a Doxygen alias like @itemdef{}, you need to escape the
comma characters which appear on the first argument, otherwise Doxygen
will interpret them as the marker of the end of the first argument and
the beginning of the second argument's text.
E.g. if you want to define the item "wxEVT_MACRO(id, func)" you need to write:
@itemdef{wxEVT_MACRO(id\, func), This is the description of the macro}
Also note that you need to escape only the commas of the first argument's
text; second argument can have up to 10 commas unescaped (see the Doxyfile
for the trick used to implement this).
- for linking use one of:
- the @ref command to refer to topic overviews;
- the () suffix to refer to function members of the same class you're
- documenting or to refer to global functions or macros;
- the classname:: operator to refer to functions of classes different
- from the one you're documenting;
- the `::` prefix to refer to global variables (e.g. ::wxEmptyString).
Class names are auto-linked by Doxygen without the need of any explicit
command.
DON'T:
- use jargon, such as 'gonna', or omit the definite article.
The manual is intended to be a fluent, English document and
not a collection of rough notes.
- use non-alphanumeric characters in link anchors.
- use Doxygen @b @c @e commands when referring to more than a single word;
in that case you need to use the `<b>...</b>`, `<tt>...</tt>`, `<em>...</em>`
HTML-style tags instead
- use HTML style tags for creation of tables or lists.
Use wx aliases instead like @beginTable, @row2col, @row3col, @endTable and
@beginDefList, @itemdef, @endDefList, etc.
See the Doxyfile.inc for more info.
Documentation comment for a class
---------------------------------
Start off with:
/**
@class wxMyClass
...here goes the description...
@beginEventTable
@event{EVT_SOME_EVENT(id, func)}:
Description for EVT_SOME_EVENT.
@endEventTable
@beginStyleTable
@style{wxSOME_STYLE}:
Description for wxSOME_STYLE.
...
@endStyleTable
@beginExtraStyleTable
@style{wxSOME_EXTRA_STYLE}:
Description for wxSOME_EXTRA_STYLE.
...
@endExtraStyleTable
@library{wxbase}
@category{cat_shortcut}
@nativeimpl{wxgtk, wxmsw, ...}
@onlyfor{wxgtk, wxmsw, ...}
@appearance{button.png}
@stdobjects
...here goes the list of predefined instances...
@see ...here goes the see-also list...
you can make references to topic overviews or other
manual pages using the @ref command
*/
Note that everything *except* the @class, @library and @category
commands are optionals.
Also note that if you use @section and @subsection in the class description
(at the beginning), you should use as the section's anchor name "xxxx_yyyy"
where "xxxx" is the class name without the initial "wx" in lowercase
and "yyyy" is a lowercase word which uniquely identifies that section.
E.g.:
/**
@class wxMyClass
This class does not exist really and is only used as an example
of best documentation practices.
@section myclass_special Special functions of this class
This section describes the functions whose usage is reserved for
wxWidgets internal mechanisms... etc etc...
@section myclass_custom Customizing wxMyClass
What if you want to customize this powerful class?
First you should do this and that, etc etc...
@library{wxbase}
@category{misc}
@see wxMyOtherClass
*/
Documentation comment for a function
------------------------------------
Start off with:
/**
...here goes the description of the function....
@param param1
...here goes the description for the first parameter of this function
@param param2
...here goes the description for the second parameter of this function
...
@return
...here goes the description of what the function returns...
@note ...here go any eventual notes about this function...
@remarks ...here go any eventual remarks about this function...
@see ...here goes the see-also list...
*/
Note that the @return, @note, @remarks, @see commands are optional.
The @param command has an optional attribute specifying the direction of
the attribute. Possible values are "in" and "out". E.g.
/**
* Copies bytes from a source memory area to a destination memory area,
* where both areas may not overlap.
* @param[out] dest The memory area to copy to.
* @param[in] src The memory area to copy from.
* @param[in] n The number of bytes to copy.
* @param[in,out] pmisc Used both as input and as output.
*/
void func(void *dest, const void *src, size_t n, void *pmisc);
Documentation comment for a topic overview
------------------------------------------
Topic overviews are stored inside the docs/doxygen/overviews folder
and are completely placed inside a single comment block in the form of:
/*!
@page overview_tname wxSomeStuff overview
This page provides an overview of the wxSomeStuff and related classes.
....
@li @ref overview_tname_intro
@li @ref overview_tname_details
...
<hr>
@section overview_tname_intro Introduction
...here goes the introduction to this topic...
@section overview_tname_details Details
...here go the details to this topic...
*/
Note that there is a convention in the anchor link names.
Doxygen in fact requires that for each @page, @section, @subsection, etc tag,
there is a corresponding link anchor.
The following conventions are used in wxWidgets doxygen comments:
1. all "main" pages of the manual (those which are placed in
docs/doxygen/mainpages) have link anchors which begin with `page_`
2. all topic overviews (those which are placed in docs/doxygen/overviews) have
link anchors which begin with `overview_`
3. all @section, @subsection, @subsubsection tags should have as link anchor
name the name of the parent section plus a specific word separated with an
underscore; e.g.:
/*!
@page overview_tname wxSomeStuff overview
@section overview_tname_intro Introduction
@subsection overview_tname_intro_firstpart First part
@subsection overview_tname_intro_secondpart Second part
@subsubsection overview_tname_intro_secondpart_sub Second part subsection
@subsection overview_tname_intro_thirdpart Third part
@section overview_tname_details Details
...
*/

230
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-files-to-build-system.md Normal file
View File

@@ -0,0 +1,230 @@
How to add new files and libraries to wxWidgets build system
============================================================
Regenerating makefiles
----------------------
wxWidgets uses the legacy 0.2 branch [Bakefile](https://www.bakefile.org) to
generate native makefiles.
Currently the latest version from legacy-0.2-branch must be used, so you need
to compile it from source, which requires Python 2 headers and libraries.
Once you have installed Bakefile, you can easily regenerate the makefiles using
the `bakefile_gen` tool. Run it from `$(wx)/build/bakefiles` directory and it will
regenerate all outdated makefiles. See `$(wx)/build/bakefiles/README` for more
details.
You can also run Bakefile from a Docker or Podman container and avoid the need
to install it (expanding "$(wx)" to be the path to wx install):
docker run --rm -v $(wx):$(wx) -w `pwd`
ghcr.io/vslavik/bakefile:0.2 bakefile_gen
Note that it generates makefiles for samples, too.
IMPORTANT NOTE: Don't forget to run autoconf in wxWidgets root directory
(after running Bakefile) if you changed any conditional
variable or target condition in .bkl files! You will know that
this happened if `$(wx)/autoconf_inc.m4` content changed.
You can use Bakefile to generate makefiles or projects customized to your
needs, too. See `Bakefiles.bkgen` for details on bakefile commands used to
generate makefiles. For example, you can use this command to generate
VC++ project files without wxUniversal configurations:
bakefile -v -fmsvc6prj -o../wxmy.dsw -DRUNTIME_LIBS=dynamic
-DDEBUG_INFO=default -DDEBUG_FLAG=default
-DOFFICIAL_BUILD=0 -DUSE_HTML=1 -DUSE_OPENGL=1
-DMONOLITHIC=0 -DUSE_GUI=1 -DWXUNIV=0 wx.bkl
Or monolithic instead of multilib (the default):
bakefile -v -fmsvc6prj -o../wxmono.dsw -DRUNTIME_LIBS=dynamic
-DDEBUG_INFO=default -DDEBUG_FLAG=default
-DOFFICIAL_BUILD=0 -DUSE_HTML=1 -DUSE_OPENGL=1
-DMONOLITHIC=1 -DUSE_GUI=1 wx.bkl
Or monolithic wxBase:
bakefile -v -fmsvc6prj -o../wxBase.dsw -DRUNTIME_LIBS=dynamic
-DDEBUG_INFO=default -DDEBUG_FLAG=default
-DOFFICIAL_BUILD=0 -DUSE_HTML=0 -DUSE_OPENGL=0
-DMONOLITHIC=1 -DUSE_GUI=0 wx.bkl
It is, however, recommended to modify `Bakefiles.bkgen` (or
`Bakefiles.local.bkgen)` by means of `<add-flags>` and `<del-flags>` directives
and use `bakefile_gen` instead of running bakefile directly.
Bakefile files organization
---------------------------
Makefile are generated from .bkl files ("bakefiles") from two places:
- `$(wx)/build/bakefiles` directory
- samples directories
`$(wx)/build/bakefiles` contains bakefiles for main library and support files
that simplify writing bakefiles for samples.
Support files are:
- `wxwin.py` - helper functions
- `common.bkl`
- `common_samples.bkl`
- `config.bkl` - user-configurable build options
- `make_dist.mk` - implementation of "make dist" on Unix
Files used to build the library are:
- `wx.bkl` - main file
- `files.bkl` - lists of source files
- `monolithic.bkl` - targets for wxWin built as single big library
- `multilib.bkl` - targets for multilib build
- `opengl.bkl` - GL library with wxGLCanvas (this one is not
included in monolithic library for historical reasons, so "monolithic" really
means "two libs")
- `{expat,jpeg,png,tiff, regex,zlib,odbc}.bkl` - 3rd party libraries makefiles
Adding files to existing library
--------------------------------
**UPDATE:** `files.bkl` is now itself partially generated from the master file
`build/files`. If the variable which you need to modify, according to the
instructions below, is already defined in `build/files`, update it there and run
`build/upmake` to update `files.bkl`.
All files used by main libraries are listed in `files.bkl`. The file is
organized into variables for toolkits, platforms and libraries. The variables
come in pairs: there's always `FOO_SRC` for source files and `FOO_HDR` for header
files. Platform or toolkit specific files are grouped together in variable
with platform or toolkit name in them, e.g. `BASE_WIN32_SRC`, `BASE_UNIX_SRC`,
`GTK_SRC`.
Note: A side effect of this toolkit-centric organization is that one file may
be present several times in `files.bkl` in different contexts.
When you are adding a file, you must put it into appropriate variable. This is
easy if you are adding the file to library that is always built from same
sources on all platforms (e.g. wxXml or wxXML) -- simply add the file to e.g.
`HTML_SRC` or `HTML_HDR`.
If the file is used only on one platform and is part of wxBase, add it to
`BASE_{platform}_SRC/HDR`. If it is used on all platforms, add it to `BASE_CMN`.
If it is built on more than one platform but not on all of them, add the file
to *all* platforms that use it!
If a file is not wxBase file, but GUI file, then the variables are named after
toolkits/ports, not platforms. Same rules as for wxBase files apply
(substitute "platform" with "toolkit"). Make sure you correctly choose between
`{port}_LOWLEVEL_SRC` and `{port}_SRC` -- the former is for files used by
wxUniversal, e.g. GDI classes. Files shared by all X Window System ports
should be put into `XWIN_LOWLEVEL_SRC`.
Adding a new sample
-------------------
This is explained in details in `how-to-add-new-sample.md` file, please see
there.
Adding new core library
-----------------------
When adding new library to the core set of libraries, the files must be
added to both a newly added library in multilib build and into the single
library built in monolithic mode. We will assume that the new library is
called wxFoo.
a) Add files to files.bkl:
* If wxFoo builds from same files on all platforms (e.g. wxNet),
add `FOO_SRC` and `FOO_HDR` variables with lists of sources and headers.
* If wxFoo have no files in common (e.g. wxGL), add `FOO_SRC` and `FOO_HDR`
with toolkit or platform conditions. Have a look at `OPENGL_SRC` for an
example.
* Otherwise add `FOO_CMN_SRC` and `FOO_CMN_HDR` for common files and
`FOO_{platform}_{SRC,HDR}` or `FOO_{toolkit}_{SRC,HDR}` as appropriate. Add
`FOO_PLATFORM_{SRC,HDR}` into "Define sources for specific libraries"
section that is conditionally set to one of `FOO_xxx_{SRC,HDR}` based on
target platform/toolkit (see `NET_PLATFORM_SRC` definition for an example).
Finally, define `FOO_SRC` and `FOO_HDR` to contain both
`FOO_PLATFORM_{SRC,HDR}` and `FOO_{SRC,HDR}` (see `NET_SRC` definition for an
example).
* Add `FOO_HDR` to `ALL_GUI_HEADERS` or `ALL_BASE_HEADERS`.
* If wxFoo is wxBase library (doesn't use GUI), add `FOO_SRC` to
`ALL_BASE_SOURCES`.
(You can apply different approaches to HDR and SRC variables, if e.g.
headers are all common but sources are not.)
Note that the conditions can only test for equality, due to limitations of
native make tools.
b) Modify bakefile system in build/bakefiles/ to recognize wxFoo:
* Add 'foo' to `MAIN_LIBS` and `LIBS_NOGUI` or `LIBS_GUI` (depending on whether
the library depends on wxCore or not) to wxwin.py file.
* Add extra libraries needed by wxFoo (if any) to EXTRALIBS in wxwin.py
* Add `WXLIB_FOO` definition to common.bkl (into the "Names of component
libraries" section). It looks like this:
<set var="WXLIB_FOO">
<if cond="MONOLITHIC=='0'">$(mk.evalExpr(wxwin.mkLibName('foo')))</if>
</set>
c) Modify monolithic.bkl to add files to monolithic build: it's enough to add
`FOO_SRC` to `MONOLIB_GUI_SRC` or `MONOLIB_SRC`, depending on whether wxFoo uses
GUI or not.
d) Modify multilib.bkl to add files to multilib build: add foolib and foodll
targets. Don't use wxBase targets as the template, use e.g. wxXML or wxHTML.
Make sure `WXMAKINGDLL_FOO` is defined in foodll.
e) Regenerate all makefiles (don't forget to run autoconf)
f) Update configure.ac and wx-config.in to contain information about
the library and needed linker flags:
* Add "foo" to `BUILT_WX_LIBS` in configure.ac.
* If appropriate, but it rarely is, so normally this should _not_ be done,
add "foo" to either `STD_BASE_LIBS` or `STD_GUI_LIBS` in configure.ac.
* If wxFoo links against additional libraries, add necessary linker
flags and libraries to ldflags_foo and ldlibs_foo variables in
wx-config.in (both are optional).
g) Update dlimpexp.h to define `WXMAKINGDLL_FOO` if `WXMAKINGDLL` is defined (add
`#define WXMAKINGDLL_FOO` inside first `#ifdef WXMAKINGDLL` block in
dlimpexp.h) and to define `WXDLLIMPEXP_FOO` and `WXDLLIMPEXP_DATA_FOO`. You
can copy e.g. `WXDLLIMPEXP_NET` definition, it is something like this:
#ifdef WXMAKINGDLL_NET
#define WXDLLIMPEXP_NET WXEXPORT
#define WXDLLIMPEXP_DATA_NET(type) WXEXPORT type
#elif defined(WXUSINGDLL)
#define WXDLLIMPEXP_NET WXIMPORT
#define WXDLLIMPEXP_DATA_NET(type) WXIMPORT type
#else // not making nor using DLL
#define WXDLLIMPEXP_NET
#define WXDLLIMPEXP_DATA_NET(type) type
#endif
Don't forget to add `WXDLLIMPEXP_FWD_FOO` definitions too.
Use `WXDLLIMPEXP_FOO` when declaring wxFoo classes and functions.
h) Add this code to one of wxFoo's files (the more often used, the better):
// DLL options compatibility check:
#include "wx/app.h"
WX_CHECK_BUILD_OPTIONS("wxFoo")
i) Add information about wxFoo to the manual ("Libraries list" section
in libs.tex) and update `docs/latex/wx/libs.dia` (you need Dia for this)
to show the dependencies of the new library.
j) Also please add `#pragma comment(lib, "foo")` (for all build configuration
combinations) to the file include/msvc/wx/setup.h and
add a check for `WXMAKINGDLL_FOO` to the test whether we're building a DLL at
the end of `include/wx/msw/chkconf.h`.

63
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-new-font-encoding.md Normal file
View File

@@ -0,0 +1,63 @@
How to add a new font encoding to wxWidgets
===========================================
Introduction
------------
wxWidgets has built in support for a certain number of font encodings (which
is synonymous with code sets and character sets for us here even though it is
not exactly the same thing), look at include/wx/fontenc.h for the full list.
This list is far from being exhaustive though and if you have enough knowledge
about an encoding to add support for it to wxWidgets, this tech note is for
you!
A word of warning though: this is written out of my head and is surely
incomplete. Please correct the text here, especially if you detect problems
when you try following it.
Also note that I completely ignore all the difficult issues of support for
non European languages in the GUI (i.e. BiDi and text orientation support).
The recipe
----------
Suppose you want to add support for Klingon to wxWidgets. This is what you'd
have to do:
1. include/wx/fontenc.h: add a new `wxFONTENCODING_KLINGON` enum element, if
possible without changing the values of the existing elements of the enum
and be careful to now make it equal to some other elements -- this means
that you have to put it before `wxFONTENCODING_MAX`
2. `wxFONTENCODING_MAX` must be the same as the number of elements in 3
(hopefully) self explanatory arrays in src/common/fmapbase.cpp:
- gs_encodings
- gs_encodingDescs
- gs_encodingNames
You must update all of them, e.g. you'd add `wxFONTENCODING_KLINGON`,
"Klingon (Star Trek)" and "klingon" to them in this example. The latter
name should ideally be understandable to both Win32 and iconv as it is used
to convert to/from this encoding under Windows and Unix respectively.
Typically any reasonable name will be supported by iconv, if unsure run
"iconv -l" on your favourite Unix system. For the list of charsets
supported under Win32, look under HKEY_CLASSES_ROOT\MIME\Database\Charset
in regedit. Of course, being consistent with the existing encoding names
wouldn't hurt either.
3. Normally you don't have to do anything else if you've got support for this
encoding under both Win32 and Unix. If you haven't, you should modify
wxEncodingConverter to support it (this could be useful anyhow as a
fallback for systems where iconv is unavailable). To do it you must:
a) add a new table to src/common/unictabl.inc: note that this file is auto
generated so you have to modify misc/unictabl script instead (probably)
b) possibly update EquivalentEncodings table in src/common/encconv.cpp
if `wxFONTENCODING_KLINGON` can be converted into another one
(losslessly only or not?)
4. Add a [unit test](how-to-write-unit-tests.md) for support of your new encoding (with
time we should have a wxCSConv unit test so you would just add a case to
it for `wxFONTENCODING_KLINGON`) and test everything on as many different
platforms as you can.

70
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-new-msvs-version.md Normal file
View File

@@ -0,0 +1,70 @@
How to add support for a new MSVS version
=========================================
MSVS versions
-------------
This is confusing because there are several of them:
- Marketing IDE/product version, which is the year of the release, e.g. 2019.
- Actual internal IDE version, visible in `Help|About` dialog, for example,
e.g. 16.1.4.
- Compiler version, visible in `cl /?` output, e.g. 19.21.27702.2. This version
also corresponds to the value of the predefined `_MSC_VER` symbol.
- Toolset version: this is similar to the compiler version, but uses different
format, e.g. it's 14x for compiler version 19, with `x` being 0, 1 or 2
depending on the minor compiler version (00, 14 or 21).
Moreover, historically, different IDE versions corresponded to different major
compiler versions, however this hasn't been the case any more for the last few
releases (2015, 2017, 2019 or 14, 15, 16 IDE versions) that all use the same
major compiler version (19) as they are ABI-compatible. Also, historically,
each compiler used its own toolset, but these last few versions can each use
any of 140, 141, 142 toolset.
wxWidgets uses the IDE version for the project/solution files (but notice that
project files are the same for all MSVS 201x versions) and the toolset version
for the names of build directories.
TODO list
---------
Here is a list of things that need to be done when adding support for the next
MSVS version:
- If the major compiler version changed, add a new `__VISUALCxx__` symbol to
`include/wx/compiler.h` (`xx` here are the first 2 digits of the toolset
version, i.e. basically correspond to the major compiler version, except
that 13 was skipped for superstitious reasons, see the comment in that file).
- Add `wxCOMPILER_PREFIX` definition for the new version to
`include/msvc/wx/setup.h`.
- Add the new solution file `build/msw/wx_vcNN.sln` (where `NN` is the internal
IDE version), typically by opening an existing solution in the new IDE and
letting it to update it.
- Add the new solution files `samples/samples_vcNN.sln`, `tests/test_vcNN.sln`
and `tests/test_gui_vcNN.sln` in a similar way.
- Add the new version to the instructions in `how-to-add-new-sample.md` in this
directory.
- Discard changes to the project files that were done by the IDE during the
update and instead update `build/msw/wx_config.props` and add a new condition
checking `VisualStudioVersion` value for choosing the value of
`PlatformToolset`.
- Update the lists of supported compiler versions in the different
documentation files (search for "Microsoft Visual C++" to find the places
that need updating):
- `README.md`
- `docs/doxygen/mainpages/introduction.h`
- `docs/msw/install.md`
- `docs/release.md`
- Update `build/tools/msvs/officialbuild.bat` to support the new toolset version
and also update `build/tools/msvs/buildall.bat` to call it with this new version
(these files are used to build the official binaries for the releases).
- If necessary, i.e. if the warning C4535 appears when compiling
`src/msw/main.cpp` with the new version, check that this warning is still
harmless, i.e. that catching Win32 exceptions still works correctly (this
can be tested with the "Crash" menu item in the except sample) and update
the version check in `include/wx/msw/seh.h` to suppress this warning for the
new version too.
- Update checks for `VISUALSTUDIOVERSION` in `build/bakefiles/common.bkl` to
take the new version into account.

94
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-new-sample.md Normal file
View File

@@ -0,0 +1,94 @@
How to add a new sample to wxWidgets.
=====================================
To add a new sample "foo" under directory "samples/foo" you need to do
the following: (note that all this applies also to demos: just replace
samples/ with demos/ where needed).
1. Create the directory samples/foo.
2. "git add" the sample sources (usually based on minimal.cpp) as well.
Note that unless your sample requires something special you shouldn't
add foo.rc, foo.ico, ... any more, please just reuse the generic `sample.*`
files in the samples subdirectory. In particular, the Windows resource
specification should use the central `.rc` file, i.e. do not use
`<win32-res>` bakefile tag unless it is really necessary.
3. Create the make and project files:
- Create MSVS project for the sample and add it to the solution file:
* In the simplest case, run the following command, which requires some
version of Perl to be available, from the root of the wxWidgets source
tree:
./build/clone-minimal-vcxproj samples/foo/foo
* If you need to base the sample on some other project, e.g. console one
for a new non-GUI sample, you can alternatively run
./build/vcxproj-clone samples/console/console.vcxproj samples/foo/foo
* In either case, open the `samples/samples_vc17.sln` and move the new
project under the appropriate folder in the solution tree.
* The following one-liner can be used to update all the other solution files
(but you may also update them manually if you can't use this command,
which requires Unix-like environment):
$ for v in 14 15 16; do
git diff samples/samples_vc17.sln | \
sed "s/samples_vc17.sln/samples_vc${v}.sln/g" | \
git apply -v
done
- modify samples/samples.bkl (just copy an existing line)
- create `foo.bkl`, typically by just copying an existing bakefile from
another sample (`sed 's/minimal/foo/g' minimal.bkl > foo.bkl` is usually
enough, but you may need to add more `<wx-lib>` lines if your sample uses
anything not in the core lib)
- add `<wx-data>` element with the data files used by the sample that need
to be copied to its build directory, if any (see e.g.
`samples/image/image.bkl` for an example of using this tag).
- generate the makefiles for your sample using bakefile. For this you
need to:
- install bakefile (see `how-to-add-files-to-build-system.md`)
- run `bakefile_gen` in `build/bakefiles` which will regenerate all
makefiles which are not up to date
You may also use `bakefile_gen -b ../../samples/foo/foo.bkl` to
regenerate only the makefiles for this sample (path must be relative!)
or even add a `-f<compiler>` to generate just the makefiles for the given
compiler (run `bakefile --help` to get the list of possible values).
Again, see `how-to-add-files-to-build-system.md` for more information.
4. Modify configure.ac Unix compilation:
- if the sample should only be built if `wxUSE_FOO` is enabled, locate
the test for `wxUSE_FOO = yes` in configure.ac and add a line
`SAMPLES_SUBDIRS="$SAMPLES_SUBDIRS foo"` under it
- if it should be always built, locate the line `if test $wxUSE_GUI = yes`
near the end of configure.ac and modify the assignment to
`SAMPLES_SUBDIRS` to include "foo" (put in alphabetical order)
After this, regenerate configure from configure.ac
by running "autoconf" on a Unix system in the corresponding directory.
5. Modify `build/cmake/samples/CMakeLists.txt` to include the sample in
CMake. Add a new line like this:
wx_add_sample(foo DEPENDS wxUSE_FOO)
Use `DATA` CMake variable if the sample uses any data files.
For a complete list of parameters to the `wx_add_sample()` function see
the description in `build/cmake/functions.cmake`.
6. Add a short description of what the sample does and how does it work
to the "samples overview" section in the wxWidgets manual. That section
lives in `docs/doxygen/mainpages/samples.h`; look at the descriptions for
other samples, if you are not familiar with Doxygen.
7. Add any non-standard sample's files to `build/bakefiles/make_dist.mk` (the
makefiles copies all bmp, cpp, h, ico, png, rc, xpm and makefiles by
default, you only need to update it if the sample uses some other files)
and run the `./update-manifests.sh` script in distrib/scripts.

119
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-new-ui-bitmaps.md Normal file
View File

@@ -0,0 +1,119 @@
How to add new bitmaps to wxWidgets UI elements
===============================================
0. Introduction
---------------
Since the introduction of wxArtProvider class, it is no longer desired to
hardcode art resources (e.g. icons and toolbar or button bitmaps) into the
code. This was previously done either by including the bitmap in win32
resource file (include/wx/msw/wx.rc) or by including XPM files in the code.
wxArtProvider should be used instead, to allow users to customize the look of
their wxWidgets app. This technote is a detailed description of steps needed
when adding new bitmap/icon.
1. Adding new resource
----------------------
(Please see wxArtProvider reference documentation for explanation of "art ID"
and "art client" terms.)
First of all, you have to add new wxArtID constant to include/wx/artprov.h.
Look for "Art IDs" and add new definition to the list, e.g.
#define wxART_MY_BITMAP wxART_MAKE_ART_ID(wxART_MY_BITMAP)
Add it to interface/wx/artprov.h, too.
It may happen that the intended use of the new resource doesn't fit into any
of defined client categories (search for "Art clients" in the header). In case
the new resource is part of a larger category, you need to define a new
client. Just add it to the list of existing clients (and don't forget to
update artprov.tex):
#define wxART_MY_CLIENT wxART_MAKE_CLIENT_ID(wxART_MY_CLIENT)
Alternatively, you may use wxART_OTHER when accessing the resource if the
bitmap is standalone.
Once the header is updated, it's time to add XPM file with the bitmap to
$(wx)/art. Add it to $(wx)/art if it is platform-independent or to
$(wx)/art/$(toolkit) if it is something specific to one of the toolkits. Note
that "specific to one of the toolkits" doesn't mean that the bitmap is *used*
by only one toolkit, but that it doesn't make sense for any of the others! For
example, a GTK wxART_WARNING icon ($(wx)/art/gtk/warning.xpm) is specific to
wxGTK, but new_dir.xpm makes sense even under wxMSW even though it is
currently only used by the generic file dialog. Remember that wxArtProvider
can be used by users, not only the library.
Finally, wxDefaultArtProvider in $(wx)/src/common/artstd.cpp must be updated.
This consists of two steps:
- add #include line for your XPM file, e.g. #include "../../art/my_bmp.xpm"
- add ART(...) line to wxDefaultArtProvider::CreateBitmap(). The first
argument is wxArtID, the other is XPM file name (w/o extension), e.g.
ART(wxART_MY_BITMAP, my_bmp)
That's all. The bitmap is now available to wxArtProvider users.
Note: there's no difference between icons and bitmaps, always treat them as
bitmaps inside wx(Default)ArtProvider.
1b. Adding Tango version of the resource.
-----------------------------------------
While all the bitmaps are provided in XPM format so that they are available in
all builds of wxWidgets, we also provide most of them in PNG format with full
transparency support that is not available in XPM. Another advantage of the PNG
versions is that the icons used are those of the Tango project and so have the
consistent look, unlike the XPM ones.
So if you an icon exists in http://tango.freedesktop.org/Tango_Icon_Gallery you
should add it too. For this you need to:
1. Convert the PNG to a C array of bytes suitable for inclusion in the code.
This is done using misc/scripts/png2c.py script, e.g. if the variable "f"
contains the name of the icon you want to add and you have installed Tango
icons in a standard location under a Linux system:
./misc/scripts/png2c.py -s /usr/share/icons/Tango/{16x16,24x24}/*/$f.png >
art/tango/${f//-/_}.h
Of course, the same command may be ran with different paths under Windows.
Just remember to add both 16 and 24 pixel versions of the bitmap to the
header and use the "-s" option to embed the image size in its array name.
2. Add #include for the newly created file to src/common/arttango.cpp.
3. Add an entry to s_allBitmaps array in the same file.
2. Accessing the resource
-------------------------
The file that will use the bitmap needs to include "wx/artprov.h". The code to
access the bitmap (or icon) is trivial:
wxBitmap bmp = wxArtProvider::GetBitmap(wxART_MY_BITMAP, wxART_MY_CLIENT);
// this would be "wxBitmap bmp(my_bmp_xpm);" before
wxIcon icon = wxArtProvider::GetIcon(wxART_MY_ICON, wxART_MY_CLIENT);
Substitute wxART_MY_CLIENT in the example with a suitable client ID. If the
client is wxART_OTHER you may write only
wxArtProvider::GetBitmap(wxART_MY_BITMAP).
3. Providing a demo
-------------------
It is highly desirable to let the users know what stock bitmaps are available
in wxWidgets. The "artprov" sample serves this purpose: it contains a browser
dialog that displays all available art resources.
It has to be updated to accommodate for new bitmaps. Fortunately, this is
trivial: open $(wx)/samples/artprov/artbrows.cpp in text editor and
`ART_ICON(wxART_MY_BITMAP)` line to the FillBitmaps() function.
Similarly, if you add a new client, please update FillClients() by adding new
client to the end of the list.

87
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-new-wxUSE_XXX.md Normal file
View File

@@ -0,0 +1,87 @@
How to add a new `wxUSE_XXX` preprocessor constant
================================================
Purpose
-------
Detailed description of what needs to be done when you want to add a new
`wxUSE_XXX` compilation flag. The text below assumes you need new `wxUSE_FOO`.
Overview
--------
wxWidgets uses `wxUSE_XXX` macros for conditionally compiling in (or not)
optional components. In general, whenever a new non critical (i.e. not
absolutely required by important parts of the library) class Foo is added it
should use its own `wxUSE_FOO` compilation flag.
`wxUSE_FOO` must be always defined and have value of 0 or 1. Be careful with
testing for it in wx/foo.h: don't do it at the very beginning of the file
because then `wxUSE_FOO` would be not defined at all if the user directly
includes wx/foo.h, include "wx/defs.h" before testing for `wxUSE_FOO`.
Files to update
---------------
The following files need to be modified when adding a new `wxUSE_FOO`:
- `include/wx/setup_inc.h`
This file contains all common `wxUSE_XXXs`, and is used to update wxMSW, wxMac
setup.h and Unix setup.h.in using build/update-setup-h. Please try to add
the new define in a logical place (i.e. near any related ones) and write a
detailed comment explaining what does it do and why would you want to turn
it on/off. Choose the appropriate default value: this should be usually 1
but can be 0 if there are some problems preventing the use of Foo by default
(e.g. it requires installation of some non standard 3rd party libraries).
After changing this file, run the update-setup-h script (this is probably
better done on a Unix machine although it should work under Cygwin too).
- `include/wx/msw/setup_inc.h` for MSW-specific options
This file contains MSW-specific options, so if the new option is only used
under MSW, add it here instead of include/wx/setup_inc.h. The rest of the
instructions is the same as above.
- `include/wx/chkconf.h`
Add the check for `wxUSE_FOO` definedness in the corresponding (base or GUI)
section. Please keep the alphabetic order.
If there are any dependencies, i.e. `wxUSE_FOO` requires `wxUSE_BAR` and
`wxUSE_BAZ`, check for them here too.
- `include/wx/msw/chkconf.h` for MSW-specific options
These options won't be defined for the other ports, so shouldn't be added to
the common `include/wx/chkconf.h` but to this file instead.
- `configure.ac`
Here you need to add `DEFAULT_wxUSE_FOO` define. It should be added in the
block beginning after `WX_ARG_CACHE_INIT` line and should default to "no" for
`if DEBUG_CONFIGURE = 1` branch (this is used for absolutely minimal builds)
and the same as default value in `setup_inc.h` in the "else" branch.
You also need to add a `WX_ARG_ENABLE` (or, if new functionality can be
reasonably described as support for a 3rd party library, `WX_ARG_WITH`)
line together with all the existing `WX_ARG_ENABLE`s.
If you have a sample/foo which should be only built when `wxUSE_FOO==1`,
then only add it to the `SAMPLES_SUBDIRS` if `wxUSE_FOO=yes` in configure.
- `build/cmake/options.cmake`
To include the option in CMake, add a new line in the appropriate
section of `options.cmake`.
wx_option(wxUSE_FOO "enable FOO")
As an optional third parameter you may specify `OFF` when the option
should be disabled by default.
- `docs/doxygen/mainpages/const_wxusedef.h`
Add a brief description of the new constant.

48
libs/wxWidgets-3.3.1/docs/contributing/how-to-add-new-xrc-handler.md Normal file
View File

@@ -0,0 +1,48 @@
How to add a new XRC handler
============================
0. Purpose
----------
This note describes what needs to be done to add a new XRC handler, i.e. add
support for loading the objects of some class wxFoo from XRC.
1. Implement the handler
------------------------
By convention, the XRC handler for a class wxFoo declared in wx/foo.h is called
wxFooXmlHandler and is declared in the file wx/xrc/xh_foo.h (this last rule
wasn't always respected in the past, however it's not a reason to not respect
it in the future). The steps for adding a new handler are:
- Add handler declaration in include/wx/xrc/xh_foo.h, it will usually be the
same as in the other files so you can get inspiration for your brand new
handler from e.g. wx/xrc/xh_srchctrl.h. Notice the use of `wxUSE_FOO` if wxFoo
is guarded by this symbol.
- Add implementation in src/xrc/xh_foo.cpp: again, it will be almost always
very similar to the existing controls. You will need to add support for
the control-specific styles.
2. Update the other files
-------------------------
There are a few other files to update to make wxWidgets aware of the new
handler:
- Add the new files created above to build/bakefiles/files.bkl: search for
"xh_srchctrl" to see where you need to add them
- Add #include "wx/xrc/xh_foo.h" to wx/xrc/xh_all.h.
- Register the new handler in wxXmlResource::InitAllHandlers() in
src/xrc/xmlrsall.cpp
3. Update the sample
--------------------
Demonstrate that the new handler works by adding a control using it to
samples/xrc/rc/controls.xrc.

218
libs/wxWidgets-3.3.1/docs/contributing/how-to-release.md Normal file
View File

@@ -0,0 +1,218 @@
# Making a New wxWidgets Release
## Checking ABI Compatibility
For the stable (even) releases only, check that binary compatibility hasn't
been broken since the last stable release.
### Checking under Unix systems using `libabigail`.
Instructions:
1. Get [the tools](https://sourceware.org/libabigail/). Under Debian and
derived systems `apt install abigail-tools` can be used.
1. Build the old (vX.Y.Z-1) library with `-g` option, i.e. configure it
with `--enable-debug`. For convenience, let's assume it's built in "$old"
subdirectory.
1. Build the new (vX.Y.Z) library with the same options in "$new".
1. Create directories for temporary files containing the ABI dumps for the old
and new libraries: `mkdir -p ../compat/{$old,$new}`.
1. Run `abidw` on all libraries: `for l in $old/lib/*.so; do abidw $l
--out-file ../compat/$old/$(basename $l).abi; done` and the same thing with
the new libraries.
1. Run `abidiff` on each pair of produced dumps to generate HTML
reports: `for l in $old/*.abi; do abidiff $l -new $new/$(basename $l); done`.
1. If everything is good, update the ABI files in `$old` with the `$new` ones.
See also `build/elfabi/check_all.sh` which checks the ABI of the newly built
libraries and is simpler to use if there is no need to update the ABI files.
### Checking under MSW systems.
Manually check compatibility by building the widgets samples from the old tree
and then run it using the new DLLs.
## Requesting to Update the Translations
Post to wx-translators@googlegroups.com to ask to update the translations
before the release. This needs to be done some time before making it, of
course.
## Pre-Release Steps
Start by copying all the changes since the previous release to the change log
file as explained in the comment there.
Then update the files below. You can run `build/tools/pre-release.sh` to do
the straightforward changes like updating the dates and checksums
automatically, but please also review and update the contents of the README
and announcement text.
The Post-Release step of the previous release will have updated
the micro version of this release. If this release represents a major
or minor release, these changes will have to be performed manually at
this point.
Note that the best order depends on the release being prepared: for a
development release, `docs/publicity/announce.txt` contains the list of the
major changes since the last stable release and should be updated first, as
this part of it can then be copied verbatim to the corresponding section of
the README file. For the stable releases, it's probably more convenient to
update the README with the details of the changes first.
Here is the list of the files, for reference:
* Update `docs/readme.txt`: version needs to be changed, content updated.
* Update `docs/release.md`: also version and reset SHA-1 sums to zeroes.
* Update `docs/changes.txt`: update the date on the release line.
* Update the date in the manual (`docs/doxygen/mainpages/manual.h`).
* Update the release announcement post in `docs/publicity/announce.txt`.
* Update `docs/msw/binaries.md`: at least the version, but possibly also
the list of supported compilers.
Commit the changes and tag the release using your GPG key:
git tag -s -m 'Tag X.Y.Z release' vX.Y.Z
Don't overwrite existing tags. For non-final releases use e.g. `X.Y.Z-rc1`
instead of `X.Y.Z`.
## Creating Release On GitHub
Go to https://github.com/wxWidgets/wxWidgets/actions/workflows/make_release.yml
and use the "Run workflow" button to manually run this workflow for the
appropriate branch (either `master` or `3.2` currently). This will create a new
draft release that can be found in the release list or you can see its exact
URL in the output of the "Add Files to the Release" workflow step.
On the release page, use the "Edit" button to manually move the checksums at
the very end of the announcement text to their correct locations (i.e. replace
the all zero checksums with the actual ones).
Also review the announcement for correctness.
Build and upload the binaries to the existing release.
Finally, publish it.
## Update documentation
This requires being able to ssh to docs.wxwidgets.org, please ask Bryan if you
think you should be able to do it, but can't.
Once logged in, copy the contents of either `latest` or `stable` directory to
`public_html/x.y.z`, switch any links, such as `3.1` to point to `x.y.z` by
doing
$ cd ~/public_html
$ ln -sfn 3.y.z 3.y
and edit `~/public_html/index.html` to add the link to the new release to it.
If the docs must be generated from the tag itself, run the documentation
generation workflow on GitHub manually providing the tag before doing the
above.
Note that the docs web site currently uses Cloudflare for caching, which means
that it won't update for several hours after the change, unless you purge the
cache manually in the Cloudflare console (which requires an account).
## Announcement
Update https://www.wxwidgets.org:
* Update release information (at least `version` and `released`) in `_data/releases.yml`.
* Update the list of compilers used for making MSW binaries in
`downloads/index.md` if necessary (note that there is no need to update
anything else, the page will dynamically show the release files with the
specified prefixes).
* Add a news item. Usually a news item is enough but something
more can be called for major releases
* Push the changes (or create the PR with them) to GitHub. Note that this will
trigger the site rebuild which will fail if the release statistics are not
available yet, so make sure to publish the release on GitHub first (or wait
an hour for the next scheduled site rebuild to happen).
* If this is a new minor release, update `docs/index.md` to add a link to the
documentation for the new branch and update the existing links descriptions.
Post `docs/publicity/announce.txt` at least to wx-announce@googlegroups.com and
to wx-users.
Submit a link to https://www.reddit.com/r/cpp or r/programming (depending on
the release importance).
Submit to https://isocpp.org/blog/suggest (need to be logged in to do it).
For major releases, submit the announcement to https://slashdot.org/submission
## Post-Release Steps
* Update the SHA-1 sums in `docs/release.md` using the checksums from the release
announcement, then commit the changes.
* Mark the milestone corresponding to the release as completed at
https://github.com/wxWidgets/wxWidgets/milestones
* Update the roadmap at https://wxwidgets.org/develop/roadmap/ to at
least mention the new release there (the text of this page lives in
wxWidgets/website repository).
* Run `misc/scripts/inc_release` to increment micro version,
i.e. replace x.y.z with x.y.z+1. When changing another version component,
all the files updated by this script need to be changed manually.
* Update the C:R:A settings in `build/bakefiles/version.bkl` to C:R+1:A.
Then from the build/bakesfiles directory run
bakefile_gen
and from the root directory run
autoconf
or, if you're not using Debian Stable version of autoconf, see the instructions
in `build/tools/autoconf/README.md` for regenerating configure on a different
system.
* Restore the description of the Git notes use and create a skeleton section
for the next release in `docs/changes.txt`.
## MSW Visual Studio Official Builds
To build official x86 and x64 shared binaries the following are prerequisites:
- Visual Studio 2008, 2010, 2012, 2013 and 2015
- Windows SDK 6.1, 7.1 (required for x64 builds for Visual Studio 2008, 2010)
- 7z (required for packaging the files)
- fciv (required for generating the checksums)
The VSxxxCOMNTOOLS environment variables are used to locate the tools required
for Visual Studio 2012, 2013 and 2015. There are no Microsoft defined variables
for the SDKs used for Visual Studio 2008 and 2010. The build will look for the
following environment variables for the Visual Studio 2008 and 2010 SDK tools:
WINDOWS61SDK
WINDOWS71SDK
If either of these are blank they are set to the default install location.
To build binaries for a single compiler, open a command prompt (for Visual
Studio 2008 only an SDK 6.1 developer's command prompt must be used),
cd to the build\tools\msvs folder and run the batch file 'officialbuild'
with the vcXXX version number:
Visual Studio 2008 vc90
Visual Studio 2010 vc100
Visual Studio 2012 vc110
Visual Studio 2014 vc120
Visual Studio 2015 vc14x
The Visual Studio 2015, 2017, 2019 and 2022 are binary compatible, allowing the
vc14x binary to be used with any of them.
This will build all of the x86 and x64 binaries for the selected compiler version,
package them in 7z files and calculate the checksums. The 7z files and the
checksums are output to the build\msw\packages folder.
All of the compiler packages can be built at the same time by executing the
build\tools\msvs\buildall.bat file from a command prompt. Each build will be
launched in its own shell.

129
libs/wxWidgets-3.3.1/docs/contributing/how-to-update-third-party-library.md Normal file
View File

@@ -0,0 +1,129 @@
How to update a third party library to a newer version
======================================================
Introduction
------------
wxWidgets includes several third party libraries, i.e. libraries which are
used by wxWidgets and distributed with it but which we don't maintain nor even
modify, inasmuch as possible, ourselves. These libraries are developed by
their maintainers and from time to time we need to replace the versions used
by wxWidgets with newer versions.
Submodules
----------
All third party libraries are managed using Git submodules. This includes
3rdparty/catch and expat, jpeg, png, tiff and zlib subdirectories of src.
As always with submodules, updating a library involves updating its sources in
the submodule, pushing this submodule out and then committing the changes in
the top-level repository.
Updating the submodule
----------------------
All submodules use `master` branch for the upstream master and `wx` for the
version used by wxWidgets. To update the latter, just merge the appropriate
commit from master into `wx`, e.g.
$ cd src/expat
$ git checkout wx
$ git merge R_x_y_z # For the latest x.y.z release
After resolving any conflicts, commit the result.
Special instructions for specific libraries
-------------------------------------------
Some libraries, notably those for which we store the generated build files in
our submodules, require extra actions to be undertaken after merging with the
upstream:
## libexpat
Run `buildconf.sh` to update the generated files and commit the changes.
## jpeg
There is no upstream repository available with the latest version. So download
and commit the releases from https://www.ijg.org/files/.
## libpng
We use a special hack for libpng as we want to prefix all its symbols with
`wx_` but don't want to use its build system which makes this easily possible
(perhaps we should, but for now we don't). So, when upgrading libpng, you need
to perform an extra step after merging the new version (and before committing
your changes):
Create a temporary build directory and run libpng configure from it using
`--with-libpng-prefix=wx_` option. Then run `make pnglibconf.h pngprefix.h`
to create these files in the build directory. Next, search for the line
containing `PNG_ZLIB_VERNUM` in the `pnglibconf.h` and set it to 0 to disable
zlib version checks (this looks dangerous but seems to be unavoidable with the
current build system). And then, finally, copy these files to src/png
subdirectory of the wxWidgets source tree, overwriting the versions there.
Notice that config.h generated by libpng configure is not used, we build it
without `-DHAVE_CONFIG_H` as it works just fine without it on any ANSI C system
(i.e. anywhere by now).
## libtiff
The forked upstream shown in github is incorrect. It is based on the official
TIFF repository https://gitlab.com/libtiff/libtiff.
Run `autogen.sh` to update the generated files and commit the changes.
Update `tif_config.h` and `tifconf.h` with the updated entries from their `.in` files.
Update the version numbers in `tiffvers.h`.
## zlib
Check for the newly added public systems in `zlib.map` and update `zconf.h` to
include if necessary -- at least with zlib 1.2.12 release this file wasn't
updated at all in the upstream version, resulting in problems such as #22280.
If `zconf.h` is updated, you probably already had to resolve the conflicts in
it, as our file differs from the upstream version due to having the changes
from [Z_PREFIX PR](https://github.com/madler/zlib/pull/323) included in it.
## pcre2
The forked upstream shown in github is incorrect. It is based on the official
PCRE2 repository https://github.com/PCRE2Project/pcre2.
You might need to use `git merge --allow-unrelated-histories`.
Updating the main repository
----------------------------
If there are any changes to the source files used by the library, update the
corresponding `build/bakefiles/$lib.bkl` file (e.g. `expat.bkl` for Expat) and
rerun bakefile to regenerate most of the makefiles and project files. Currently
you will need to update `build/msw/wx_wx$lib.vcxproj{,.filters}` files
manually.
After updating the `bkl` file, run `build/osx/makeprojects.py` to generate
the Xcode projects.
Commit these changes and the changes to the submodule itself, but don't push
them to GitHub yet.
Test and push
-------------
The updates need to be tested under MSW and under Unix using
`--disable-sys-libs` configure option.
If everything seems to work, push the updated branch out. Notice that you may
want to use the ssh GitHub repository URL instead of the default (because more
convenient for checking them out) HTTPS one:
$ git push --set-upstream git@github.com:wxWidgets/libexpat.git wx
Finally, create a PR to let the CI builds to run and test changes too. If no
problems are found, merge the PR as usual.

125
libs/wxWidgets-3.3.1/docs/contributing/how-to-write-unit-tests.md Normal file
View File

@@ -0,0 +1,125 @@
How to write unit tests for wxWidgets
=====================================
wxWidgets unit tests use [Catch](http://catch-lib.net/) framework. It is
included in wxWidgets as a submodule, so you will need to run
$ git submodule update --init 3rdparty/catch
to get it before the first use. Catch is header-only and doesn't need to be
compiled.
Building the tests
------------------
Before starting modifying the tests, please make sure you can build the
existing tests. This requires having built the library itself successfully
first and the way to build the test must correspond to the way you used to
build the library:
- When using MSVS under MSW: just open the provided `tests/test_vcX.sln` (for
non-GUI tests) or `tests/test_gui_vcX.sln` (for the GUI ones) solution file
(where `X` corresponds to the version of MSVS you use, e.g. 16 for MSVS 2019)
and build it in the configuration of your choice.
- When using configure under Unix or in a Unix-like environment, such as MSYS:
go to the `tests` subdirectory under the _build_ directory (i.e. the
directory where you ran configure, not the one in the source tree) and run
`make test` (non-GUI tests) or `make test_gui` (GUI ones) to build.
- When using CMake, add `-DwxBUILD_TESTS=ALL` (or `=CONSOLE_ONLY` for non-GUI tests
only) to the command line arguments, or choose the desired `wxBUILD_TESTS`
option in `cmake-gui`.
- When using `makefile.vc` or `makefile.gcc` under MSW to build the libraries,
use the same makefile under `tests` to build the tests.
Once the tests were built successfully, you can run them to check that
everything works correctly by simply launching the corresponding test binary.
See the last subsection for more details about running the tests.
Testing with Catch
------------------
**WARNING**: Most of the existing tests are currently still written in the
CppUnit style, please do _not_ follow them when writing new tests, the old
style is too complex and unnecessary.
Writing tests with Catch is almost embarrassingly simple: you need to just
add a new test case and use Catch assertion macros inside it, e.g.
TEST_CASE("MyNewTest", "[my][new][another-tag]")
{
wxString s("Hello, world!");
CHECK( s.BeforeFirst(",") == "Hello" );
CHECK( s.AfterLast(" ") == "world!" );
}
This is all, the new test will be automatically run when you run the full test
suite or you can run just it using
$ ./test MyNewTest
(see below for more about running tests).
See [Catch tutorial](https://github.com/philsquared/Catch/blob/v1.11.0/docs/tutorial.md)
for more information.
Tests physical structure
------------------------
All (i.e. both GUI and non-GUI) unit tests are under `tests` subdirectory. When
adding a new test, try to find an existing file to add it to. If there are no
applicable files, try to add a new file to an existing directory. If there is
no applicable directory either, create a new one and put the new file there
(i.e. do _not_ put new files directly under `tests`). If your test is small,
consider adding it to `tests/misc/misctests.cpp`.
If you add a new file, you need to update `tests/test.bkl` and add a
`<sources>` tag for your new file.bkl. Make sure it's in the correct section:
the one starting `<exe id="test_gui"` for a gui test, the one starting `<exe
id="test" template="wx_sample_console` otherwise. After modifying this file,
rerun bakefile to regenerate the tests make- and project files:
$ cd build/bakefiles
$ bakefile_gen -b ../../tests/test.bkl
Writing GUI-specific tests
--------------------------
`wxUIActionSimulator` can be used when user input is required, for example
clicking buttons or typing text. A simple example of this can be found in
`tests/controls/buttontest.cpp`. After simulating some user input always
call `wxYield()` to allow event processing. When writing a test using
`wxUIActionSimulator` wrap it in `#if wxUSE_UIACTIONSIMULATOR` block.
There are a number of classes that are available to help with testing GUI
elements. Firstly throughout the test run there is a frame of type
`wxTestableFrame` that you can access through `wxTheApp->GetTopWindow()`. This
class adds two new functions, `GetEventCount()`, which takes an optional
`wxEventType`. It then returns the number of events of that type that it has
received since the last call. Passing nothing returns the total number of event
received since the last call. Also there is `OnEvent()`, which counts the events
based on type that are passed to it. To make it easy to count events there is
also a new class called `EventCounter` which takes a window and event type and
connects the window to the top level `wxTestableFrame` with the specific event
type. It disconnects again once it is out of scope. It simply reduces the
amount of typing required to count events.
Running the tests
-----------------
Run the main test suite by using the command `test` for the console tests,
or `test_gui` for the GUI ones. With no arguments, all the default set of tests
(all those registered without `[hide]` tag) are run.
To list the test suites without running them use `-l` command-line option.
To run a particular test case, use `./test NameTestCase`. To run all tests
using the specified tag, use `./test [tag_name]` (the square brackets may need
to be escaped from your shell).

52
libs/wxWidgets-3.3.1/docs/contributing/translators-guide.md Normal file
View File

@@ -0,0 +1,52 @@
wxWidgets translator guide
==========================
This note is addressed to wxWidgets translators.
First of all, here is what you will need:
1. GNU gettext package
- For Unix systems you can download gettext-0.xx.yy.tar.gz from any GNU
mirror (RPMs and DEBs are also available from the usual places)
- For Windows you can download the precompiled binaries from
www.wxwidgets.org or install [Poedit](https://poedit.net/) and add
`<installdir>/poEdit/bin` to your path (so it can find xgettext).
2. A way to run a program recursively on an entire directory from the command
line:
- For Unix systems, this is done in `locale/Makefile` using the standard `find`
command and `xargs` which is installed on almost all modern Unices.
- For Win32 systems you can use Cygwin, MSYS or WSL.
3. Access to the git repository is not necessary strictly speaking, but will
make things a lot easier for you and others.
Now a brief overview of the process of translations (please refer to GNU
gettext documentation for more details). It happens in several steps:
1. the strings to translate are extracted from the C++ sources using `xgettext`
program into a `wxstd.pot` file which is a "text message catalog"
2. this new wxstd.pot file (which is updated from time to time by running
`make wxstd.pot` in the `locale` subdirectory) is merged with existing
translations in another .po file (for example, de.po) and replaces this
file (this is done using the program `msgmerge`)
3. the resulting .po file must be translated
4. finally, `msgformat` must be run to produce a .mo file: "binary message catalog"
How does it happen in practice? There is a Makefile in the "locale"
directory which will do almost everything (except translations) for you. i.e.
just type `make lang.po` to create or update the message catalog for 'lang'.
Then edit the resulting `lang.po` and make sure that there are no empty or fuzzy
translations left (empty translations are the ones with `msgstr ""`, fuzzy
translations are those which have the word "fuzzy" in a comment just above
them). Then type `make lang.mo` which will create the binary message catalog.
Under Windows (If you don't have Cygwin or MinGW), you should execute the
commands manually, please have a look at Makefile to see what must be done.

68
libs/wxWidgets-3.3.1/docs/contributing/wxmsw-contributor-guide.md Normal file
View File

@@ -0,0 +1,68 @@
Special notes about writing wxMSW code
======================================
0. Purpose
----------
This is just a collection of various notes which should be useful to anybody
working on wxMSW codebase, please feel free to add more here.
This text assumes familiarity with both Windows programming and wxWidgets so it
doesn't cover any wxWidgets-wide issues not specific to Windows.
1. Windows headers wrappers
---------------------------
In no event should the Windows headers such as `<windows.h>` or `<commctrl.h>` be
included directly. So instead of `#include <...>` use `"wx/msw/wrapwin.h"` or
`wx/msw/wrapcctl.h`.
For convenience it is also possible to replace `#include <commdlg.h>` and
`<shlobj.h>` with `#include "wx/msw/wrapcdlg.h"` and `wrapshl.h` but this is less
vital.
Also notice that many convenient (albeit undocumented) functions and classes
are declared in "wx/msw/private.h", please do become familiar with this file
contents and use the utility classes and functions from it instead of
duplicating their functionality (which can often be done only in exception
unsafe way).
2. Utility classes
---------------------------
wxWidgets provides a couple of useful (mostly undocumented) classes making
Windows API easier to work with.
Please whenever possible do not use raw pointers for BSTR, COM interfaces
or task memory, use the appropriate RAII wrapper instead (see below).
Grep wxWidgets source code for the class name to see how it is to be used.
*wxBasicString*: for `BSTR`, in `"wx/msw/ole/oleutils.h"`
*wxCOMPtr*: simplistic smart pointer for COM interfaces, in `"wx/msw/private/comptr.h"`
*wxCoTaskMemPtr*: smart pointer for memory allocated/freed with `CoTaskMem{Alloc/Free}()`,
in `"wx/msw/private/cotaskmemptr.h"`
*wxSafeArray*: for `SAFEARRAY`, in `"wx/msw/ole/safearray.h"`
3. Windows features checks
--------------------------
All checks of features not present in all Windows versions must be done both at
compile-time (because, even though we use maximal value for WINVER in our code,
some compilers come with headers too old to declare them) and at run-time
(because wxMSW applications should run everywhere).
The functions wxGetWinVersion() (from wx/msw/private.h) and wxApp::
GetComCtl32Version() should be used to check Windows and comctl32.dll versions
respectively.
Any functions which may not be present in kernel32.dll/user32.dll/... in all
Windows versions should be resolved dynamically, i.e. using wxDynamicLibrary as
otherwise any wx application -- even not needing them at all -- would refuse to
start up on Windows versions not implementing the feature in question. As an
example, look at AlphaBlt()-related code in src/msw/dc.cpp.

88
libs/wxWidgets-3.3.1/docs/dfb/install.txt Normal file
View File

@@ -0,0 +1,88 @@
wxWidgets for DirectFB installation
===================================
IMPORTANT NOTE:
wxDFB is currently incomplete and some parts of the wxWidgets library
don't yet compile and must be disabled during configuration. In particular,
the coverage of wxDC API is limited.
Dependencies
------------
wxDFB requires the DirectFB library (http://www.directfb.org), which must
be installed before compiling wxDFB.
Compiling
---------
Compilation is done in the standard Unix fashion, using configure and make.
Please refer to e.g. wxGTK's install.txt for details if you are unfamiliar
with configure.
When configuring, use the --with-directfb option instead of e.g. --with-gtk
to specify that the wxDFB port should be built. You may also need to disable
wxUniv themes that don't work in wxDFB yet (alternatively you can set the
WXTHEME environment variable to "mono"):
$ ./configure --with-directfb --with-themes=mono
$ make
Configuring fonts
-----------------
DirectFB doesn't have native fonts configuration mechanism (such as
fontconfig used by GTK+) and so wxDFB implements a simple configuration
mechanism itself.
No fonts are installed and configured by "make install", you have to manually
configure fonts after you install the library.
wxDFB looks the fonts up in directories specified in the WXDFB_FONTPATH
environment variable (separated with :, similarly to the PATH variable). If
the variable is not set, $prefix/share/wx/fonts directory is used. All
subdirectories of the directories on the path are scanned for FontsIndex
files. These files are parsed and fonts defined in them are added to the fonts
list.
The FontsIndex file is standard wxFileConfig file text file. Each toplevel
group specifies one font bundle, font's name is the name of group. Group's
entries look like this:
[Font Name]
# font files (at least one of them must be present):
Regular=RegularFaceFile.ttf
Italic=ItalicFaceFile.ttf
Bold=BoldFaceFile.ttf
BoldItalic=BoldItalicFaceFile.ttf
# optional tag indicating this font is fixed-with (default is false):
IsFixed=1
Additionally, there may be DefaultXXX entries at the toplevel for every family
XXX and a Default entry that is shortcut for setting all families' default,
their value is name of the default font:
# optional tags indicating the default font for given family:
DefaultDecorative=Font Name
DefaultRoman=Font Name
DefaultScript=Font Name
DefaultSwiss=Font Name
DefaultModern=Font Name
DefaultTeletype=Font Name
# indicate the font that is default for all families (optional):
Default=Font Name
Any font formats supported by DirectFB (which typically includes formats
supported by the FreeType library) can be used.
Bug reports
-----------
Please send bug reports with a description of your environment,
compiler and the error message(s) to the developers mailing list at:
https://www.wxwidgets.org/support/mailing-lists/

587
libs/wxWidgets-3.3.1/docs/doxygen/Doxyfile Normal file
View File

@@ -0,0 +1,587 @@
# Doxyfile 1.8.8
#---------------------------------------------------------------------------
# Project Options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = wxWidgets
PROJECT_NUMBER = 3.3.1
PROJECT_BRIEF =
PROJECT_LOGO = logo.png
OUTPUT_DIRECTORY = out
CREATE_SUBDIRS = NO
ALLOW_UNICODE_NAMES = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF =
ALWAYS_DETAILED_SEC = YES # Default: NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = YES
STRIP_FROM_PATH = ../..
STRIP_FROM_INC_PATH = "$(WXWIDGETS)/include/" \
"$(WXWIDGETS)/interface/"
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES # Default: NO
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 4
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
EXTENSION_MAPPING =
MARKDOWN_SUPPORT = YES
AUTOLINK_SUPPORT = YES
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
IDL_PROPERTY_SUPPORT = NO # Default: YES
DISTRIBUTE_GROUP_DOC = YES # Default: NO
SUBGROUPING = YES
INLINE_GROUPED_CLASSES = NO # TODO: Examine this setting.
INLINE_SIMPLE_STRUCTS = NO # TODO: Examine this setting.
TYPEDEF_HIDES_STRUCT = NO
LOOKUP_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Aliases
#---------------------------------------------------------------------------
# This is the most important part of the wxWidgets Doxyfile. Aliases allow
# us to keep the headers readable and "implement" wxWidgets-specific commands.
# Aliases for documenting C++ classes
#---------------------------------------------------------------------------
# aliases to be used by classes which emit wxEvents (e.g. wxWindow, wxTextCtrl, etc):
ALIASES = beginEventEmissionTable="^^<h2>Events emitted by this class</h2><p>Event macros for events emitted by this class:</p><div>"
ALIASES += beginEventEmissionTable{1}="^^<h2>Events emitted by this class</h2><p>The following event handler macros redirect the events to member function handlers '<b>func</b>' with prototypes like: <div class='eventHandler'><span>void&nbsp;handlerFuncName(\1&&nbsp;event)</span></div></p>Event macros for events emitted by this class:<div>"
ALIASES += beginEventEmissionTable{2}="^^<h2>Events emitted by this class</h2><p>The following event handler macros redirect the events to member function handlers '<b>func</b>' with prototypes like: <div class='eventHandler'><span>void&nbsp;handlerFuncName(\1&&nbsp;event)</span> or <span>void&nbsp;handlerFuncName(\2&&nbsp;event)</span></div></p>Event macros for events emitted by this class:<div>"
# aliases to be used in wxEvent-derived classes:
ALIASES += beginEventTable{1}="^^<h2>Events using this class</h2><p>The following event handler macros redirect the events to member function handlers '<b>func</b>' with prototypes like: <div class='eventHandler'><span>void&nbsp;handlerFuncName(\1&&nbsp;event)</span></div></p>Event macros:<div>"
ALIASES += beginEventTable{2}="^^<h2>Events using this class</h2><p>The following event handler macros redirect the events to member function handlers '<b>func</b>' with prototypes like: <div class='eventHandler'><span>void&nbsp;handlerFuncName(\1&&nbsp;event)</span> or <span>void&nbsp;handlerFuncName(\2&&nbsp;event)</span></div></p>Event macros:<div>"
# common event aliases:
ALIASES += event{1}="</div>\li <span class='event'>\1</span>:<div class='eventDesc'>"
ALIASES += event{2}="</div>\li <span class='event'>\1, \2</span>:<div class='eventDesc'>"
ALIASES += event{3}="</div>\li <span class='event'>\1, \2, \3</span>:<div class='eventDesc'>"
ALIASES += event{4}="</div>\li <span class='event'>\1, \2, \3, \4</span>:<div class='eventDesc'>"
ALIASES += endEventTable="</div>^^"
# style aliases
ALIASES += beginStyleTable="^^<h2>Styles</h2><p>This class supports the following styles:</p><div>"
ALIASES += style{1}="</div>\li <span class='style'>\1</span>:<div class='styleDesc'>"
ALIASES += endStyleTable="</div>^^"
# extra style aliases
ALIASES += beginExtraStyleTable="^^<hr><h2>Extra Styles</h2><p>This class supports the following extra styles:</p><div>"
ALIASES += endExtraStyleTable="</div>^^"
# flag aliases
ALIASES += beginFlagTable="<div>"
ALIASES += flag{1}="</div>\li <span class='flag'>\1</span>:<div class='flagDesc'>"
ALIASES += endFlagTable="</div>^^"
# creates appearance section: this should be used for all main GUI controls
# that look different in different ports. genericAppearance can be used for the
# controls that always look the same.
ALIASES += appearance{1}="\htmlonly<div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td>\endhtmlonly^^\image html appear-\1-msw.png \"wxMSW Appearance\"^^\htmlonly</td><td>\endhtmlonly^^\image html appear-\1-gtk.png \"wxGTK Appearance\"^^\htmlonly</td><td>\endhtmlonly^^\image html appear-\1-mac.png \"wxOSX Appearance\"^^\htmlonly</td></tr></table></div>\endhtmlonly"
ALIASES += genericAppearance{1}="\htmlonly<div class='appearance'><span class='appearance'>Appearance:</span><table class='appearance'><tr><td>\endhtmlonly^^\image html generic/\1.png \"Generic Appearance\"^^\htmlonly</td></tr></table></div>\endhtmlonly"
# these compact versions are only used on the screenshots page
ALIASES += appearance_brief{2}="\htmlonly<div class='appearance_brief'><table><tr><td>\endhtmlonly^^\1\htmlonly</td><td>\endhtmlonly^^\image html appear-\2-msw.png ^^\htmlonly</td><td>\endhtmlonly^^\image html appear-\2-gtk.png ^^\htmlonly</td><td>\endhtmlonly^^\image html appear-\2-mac.png ^^\htmlonly</td></tr></table></div>\endhtmlonly"
ALIASES += genericAppearance_brief{2}="\htmlonly<div class='appearance_brief'><table><tr><td>\endhtmlonly^^\1\htmlonly</td><td>\endhtmlonly^^\image html generic/\2.png ^^\htmlonly</td></tr></table></div>\endhtmlonly"
# aliases for the creation of "named member groups"
# USAGE: the first argument must not contain spaces and be a unique identifier
# of the member group for the class being documented;
# the second argument is the member group name and can contain spaces
# See wxString as an usage example.
# NOTE: no warnings are given for wrong member group names so be careful and check
# the doxygen output to verify that there are no typos
ALIASES += member_group_name{2}="<a name='\1'></a> \name \2"
ALIASES += ref_member_group{2}="<a href='#\1' class='el'>\2</a>"
# Aliases for documenting any C++ entity
#---------------------------------------------------------------------------
# aliases for additional wx-specific infos
ALIASES += category{1}="\ingroup group_class_\1 ^^<div><span class='category'>Category:</span>&nbsp;&nbsp;<span class='category_text'>\ref group_class_\1</span></div>"
ALIASES += category{2}="\ingroup group_class_\1 group_class_\2 ^^<div><span class='category'>Category:</span>&nbsp;&nbsp;<span class='category_text'>\ref group_class_\1, \ref group_class_\2</span></div>"
ALIASES += category{3}="\ingroup group_class_\1 group_class_\2 group_class_\3 ^^<div><span class='category'>Category:</span>&nbsp;&nbsp;<span class='category_text'>\ref group_class_\1, \ref group_class_\2, \ref group_class_\3</span></div>"
ALIASES += library{1}="<h2></h2><div><span class='lib'>Library:</span>&nbsp;&nbsp;<span class='lib_text'>\ref page_libs_\1</span></div>"
ALIASES += nolibrary="<h2></h2><div><span class='lib'>Library:</span>&nbsp;&nbsp;<span class='lib_text'>None; this class implementation is entirely header-based.</span></div>"
ALIASES += stdobjects="<span class='stdobj'>Predefined objects/pointers:</span>"
# native implementation infos:
ALIASES += nativeimpl{1}="<div><span class='impl'>Implementations:</span>&nbsp;&nbsp;native under \ref page_port_\1 port; a generic implementation is used elsewhere.</div>"
ALIASES += nativeimpl{2}="<div><span class='impl'>Implementations:</span>&nbsp;&nbsp;native under \ref page_port_\1, \ref page_port_\2 ports; a generic implementation is used elsewhere.</div>"
ALIASES += nativeimpl{3}="<div><span class='impl'>Implementations:</span>&nbsp;&nbsp;native under \ref page_port_\1, \ref page_port_\2, \ref page_port_\3 ports; a generic implementation is used elsewhere.</div>"
ALIASES += nativeimpl{4}="<div><span class='impl'>Implementations:</span>&nbsp;&nbsp;native under \ref page_port_\1, \ref page_port_\2, \ref page_port_\3, \ref page_port_\4 ports; a generic implementation is used elsewhere.</div>"
# onlyfor infos:
# NOTE: we need to be able to retrieve these infos also from the XML output, thus
# we use the \xmlonly and \endxmlonly commands to include custom XML tags
ALIASES += onlyfor{1}="<div><span class='avail'>Availability:</span>&nbsp;&nbsp;only available for the \ref page_port_\1 port.</div> \xmlonly <onlyfor>\1</onlyfor> \endxmlonly"
ALIASES += onlyfor{2}="<div><span class='avail'>Availability:</span>&nbsp;&nbsp;only available for the \ref page_port_\1, \ref page_port_\2 ports.</div> \xmlonly <onlyfor>\1,\2</onlyfor> \endxmlonly"
ALIASES += onlyfor{3}="<div><span class='avail'>Availability:</span>&nbsp;&nbsp;only available for the \ref page_port_\1, \ref page_port_\2, \ref page_port_\3 ports.</div> \xmlonly <onlyfor>\1,\2,\3</onlyfor> \endxmlonly"
ALIASES += onlyfor{4}="<div><span class='avail'>Availability:</span>&nbsp;&nbsp;only available for the \ref page_port_\1, \ref page_port_\2, \ref page_port_\3, \ref page_port_\4 ports.</div> \xmlonly <onlyfor>\1,\2,\3,\4</onlyfor> \endxmlonly"
# similar to standard @since but keeps everything on the same line:
ALIASES += since_wx{1}="Available since wxWidgets version \1."
# Use this in grouped global functions, and macros since they
# wouldn't otherwise indicate what header they are defined in.
ALIASES += header{1}="Include file:^^ \verbatim #include <\1> \endverbatim"
# some formatting aliases
ALIASES += true="<span class='literal'>true</span>"
ALIASES += false="<span class='literal'>false</span>"
ALIASES += nullptr="<span class='literal'>nullptr</span>"
ALIASES += NULL="<span class='literal'>nullptr</span>"
ALIASES += NUL="<span class='literal'>NUL</span>"
# NOTE: these are important as you can't write in the docs
# just #ifdef since the # character is used by Doxygen
# for explicit linking; use the following aliases instead!
# However to avoid overwriting e.g. \if Doxygen command the _
# character is postfixed
ALIASES += ifdef_="<span class='literal'>\#ifdef</span>"
ALIASES += ifndef_="<span class='literal'>\#ifndef</span>"
ALIASES += if_="<span class='literal'>\#if</span>"
ALIASES += endif_="<span class='literal'>\#endif</span>"
# table aliases for 2 and 3 column tables
ALIASES += beginTable="<table class='doctable' border='1' cellspacing='0' cellpadding='3'>"
ALIASES += beginInvisibleTable="<table class='doctable' border='0' cellspacing='0' cellpadding='4'>"
ALIASES += row2col{2}="<tr><td>\1</td> <td>\2</td></tr>"
ALIASES += row2col{3}="<tr><td>\1</td> <td>\2,\3</td></tr>"
ALIASES += row2col{4}="<tr><td>\1</td> <td>\2,\3,\4</td></tr>"
ALIASES += row2col{5}="<tr><td>\1</td> <td>\2,\3,\4,\5</td></tr>"
ALIASES += row2col{6}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6</td></tr>"
ALIASES += row2col{7}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7</td></tr>"
ALIASES += row2col{8}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7,\8</td></tr>"
ALIASES += row2col{9}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7,\8,\9</td></tr>"
ALIASES += row2col{10}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7,\8,\9,\10</td></tr>"
ALIASES += row3col{3}="<tr><td>\1</td> <td>\2</td> <td>\3</td></tr>"
ALIASES += row3col{4}="<tr><td>\1</td> <td>\2</td> <td>\3,\4</td></tr>"
ALIASES += row3col{5}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5</td></tr>"
ALIASES += row3col{6}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6</td></tr>"
ALIASES += row3col{7}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7</td></tr>"
ALIASES += row3col{8}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8</td></tr>"
ALIASES += row3col{9}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9</td></tr>"
ALIASES += row3col{10}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10</td></tr>"
ALIASES += row3col{11}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10,\11</td></tr>"
ALIASES += row3col{12}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10,\11,\12</td></tr>"
ALIASES += row3col{13}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10,\11,\12,\13</td></tr>"
ALIASES += row3col{14}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10,\11,\12,\13,\14</td></tr>"
ALIASES += row3col{15}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10,\11,\12,\13,\14,\15</td></tr>"
ALIASES += row3col{16}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10,\11,\12,\13,\14,\15,\16</td></tr>"
ALIASES += hdr3col{3}="<tr><th>\1</th> <th>\2</th> <th>\3</th></tr>"
ALIASES += endTable="</table>"
# definition list aliases
# a definition list currently is rendered as 2-column table but it may use as
# well the <dl>, <dt> and <dd> HTML tags in future.
# In any case a definition list differs from a table because of its semantic
# nature and because it is always the association of a "title" with a "description"
# (in contrast a table may have more than 2 columns of data)...
ALIASES += beginDefList="<table class='doclist' border='1' cellspacing='0'>"
ALIASES += itemdef{2}="<tr><td><span class='itemdef'>\1</span></td> <td>\2</td></tr>"
ALIASES += itemdef{3}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3</td></tr>"
ALIASES += itemdef{4}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3,\4</td></tr>"
ALIASES += itemdef{5}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3,\4,\5</td></tr>"
ALIASES += itemdef{6}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3,\4,\5,\6</td></tr>"
ALIASES += itemdef{7}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3,\4,\5,\6,\7</td></tr>"
ALIASES += itemdef{8}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3,\4,\5,\6,\7,\8</td></tr>"
ALIASES += itemdef{9}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3,\4,\5,\6,\7,\8,\9</td></tr>"
ALIASES += itemdef{10}="<tr><td><span class='itemdef'>\1</span></td> <td>\2,\3,\4,\5,\6,\7,\8,\9,\10</td></tr>"
ALIASES += endDefList="</table>"
ALIASES += stock{3}="<tr><td><span class='itemdef'>\1</span></td> <td>\2</td> <td> @image html gtk-\3.png </td></tr>"
# Aliases for documenting wxPerl/wxPython-specific parts
#---------------------------------------------------------------------------
# See ENABLED_SECTIONS configuration key for more info about these:
ALIASES += beginWxPerlOnly="\if WXPERL_MANUAL <b>wxPerl Note:</b> "
ALIASES += endWxPerlOnly="\endif"
# This is to get around a bug in Doxygen that prevents use of '{' or '}'
# inside of any aliased command in parameters.
ALIASES += leftCurly="{"
ALIASES += rightCurly="}"
# Aliases for documenting samples
#---------------------------------------------------------------------------
# For indicating a sample location
ALIASES += sampledir{1}="@e Location: @c samples/\1 subdirectory of your wxWidgets installation or https://github.com/wxWidgets/wxWidgets/tree/master/samples/\1"
# For referring to the corresponding sample in a class document or a overview
# Usually placed in the queue of @see
ALIASES += sample{1}="\ref page_samples_\1"
# For generating a general description for a sample
# \1 could be a class or an overview or a descriptive sentence
# Shall be replaced by manual written description soon
ALIASES += sampleabout{1}="This sample demonstrates \1."
# For indicating the necessary condition of a sample or a class
# \1 is the wxUSE_XXX macro
ALIASES += buildwith{1}="<b>Build Note:</b> You may need to build the wxWidgets library with <tt>\1</tt> being set to 1 to be able to make it work, please read comments in @c <wx/setup_inc.h> for more info."
ALIASES += buildwith{2}="<b>Build Note:</b> You may need to build the wxWidgets library with <tt>\1</tt> and <tt>\2</tt> being set to 1 to be able to make it work, please read comments in @c <wx/setup_inc.h> for more info."
#---------------------------------------------------------------------------
# Build Options
#---------------------------------------------------------------------------
EXTRACT_ALL = YES # Default: NO
EXTRACT_PRIVATE = YES # Default: NO
EXTRACT_PACKAGE = NO
EXTRACT_STATIC = YES # Default: NO
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = YES # TODO: Default: NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = NO # Default: YES
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
SHOW_GROUPED_MEMB_INC = NO # TODO: YES
FORCE_LOCAL_INCLUDES = NO
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO # Don't set to YES, it renders our named groups out of order.
SORT_MEMBERS_CTORS_1ST = NO # Default: NO
SORT_GROUP_NAMES = YES # Default: NO
SORT_BY_SCOPE_NAME = NO
STRICT_PROTO_MATCHING = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS = WXPERL_MANUAL \
WXPYTHON_MANUAL
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = NO # Default: YES
SHOW_FILES = YES
SHOW_NAMESPACES = NO # TODO: Default: YES
FILE_VERSION_FILTER =
LAYOUT_FILE = DoxygenLayout.xml
CITE_BIB_FILES =
#---------------------------------------------------------------------------
# Warning and Progress Message Options
#---------------------------------------------------------------------------
QUIET = YES # Default: NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = YES # Default: NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE = doxygen.log
#---------------------------------------------------------------------------
# Input File Options
#---------------------------------------------------------------------------
INPUT = mainpages \
groups \
overviews \
../gtk \
../ios \
../msw \
../osx \
../qt \
../x11 \
../../interface
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.h *.md
RECURSIVE = YES # Default: NO
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS =
EXAMPLE_PATH = ../
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH = images
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
FILTER_SOURCE_PATTERNS =
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# Source Browsing Options
#---------------------------------------------------------------------------
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
SOURCE_TOOLTIPS = YES
USE_HTAGS = NO
VERBATIM_HEADERS = NO # Default: YES
#---------------------------------------------------------------------------
# Alphabetical Class Index Options
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
IGNORE_PREFIX = wx
#---------------------------------------------------------------------------
# HTML Output Options
#---------------------------------------------------------------------------
GENERATE_HTML = $(GENERATE_HTML)
HTML_OUTPUT = $(WX_HTML_OUTPUT_DIR)
HTML_FILE_EXTENSION = .html
HTML_HEADER = $(HTML_HEADER)
HTML_FOOTER = custom_footer.html
HTML_STYLESHEET =
HTML_EXTRA_STYLESHEET = $(CUSTOM_THEME_CSS) extra_stylesheet.css
HTML_EXTRA_FILES = $(CUSTOM_THEME_JS1) $(CUSTOM_THEME_JS2) wxwidgets.js
HTML_COLORSTYLE_HUE = 220 # Default: 220
HTML_COLORSTYLE_SAT = 255 # Default: 100
HTML_COLORSTYLE_GAMMA = 100 # Default: 80
HTML_TIMESTAMP = YES
HTML_DYNAMIC_SECTIONS = YES # Default: NO
HTML_INDEX_NUM_ENTRIES = 100
#---------------------------------------------------------------------------
# Docset Output Options
#---------------------------------------------------------------------------
GENERATE_DOCSET = $(GENERATE_DOCSET)
DOCSET_FEEDNAME = "wxWidgets 3.3"
DOCSET_BUNDLE_ID = org.wxwidgets.doxygen.wx31
DOCSET_PUBLISHER_ID = org.wxwidgets.doxygen
DOCSET_PUBLISHER_NAME = wxWidgets
#---------------------------------------------------------------------------
# CHM Output Options
#---------------------------------------------------------------------------
GENERATE_HTMLHELP = $(GENERATE_HTMLHELP)
CHM_FILE = ..\wx.chm # Windows style separator is required.
HHC_LOCATION = hhc.exe
GENERATE_CHI = NO
CHM_INDEX_ENCODING =
BINARY_TOC = NO
TOC_EXPAND = NO
TOC_INCLUDE_HEADINGS = 3
#---------------------------------------------------------------------------
# QHP Output Options
#---------------------------------------------------------------------------
GENERATE_QHP = $(GENERATE_QHP)
QCH_FILE =
QHP_NAMESPACE = org.wxwidgets.doxygen
QHP_VIRTUAL_FOLDER = doc
QHP_CUST_FILTER_NAME =
QHP_CUST_FILTER_ATTRS =
QHP_SECT_FILTER_ATTRS =
QHG_LOCATION =
#---------------------------------------------------------------------------
# Eclipse Output Options
#---------------------------------------------------------------------------
GENERATE_ECLIPSEHELP = NO
ECLIPSE_DOC_ID = org.wxwidgets.doxygen
#---------------------------------------------------------------------------
# Other Output Options
#---------------------------------------------------------------------------
DISABLE_INDEX = NO
GENERATE_TREEVIEW = NO
ENUM_VALUES_PER_LINE = 1 # Default: 4
TREEVIEW_WIDTH = 250
EXT_LINKS_IN_WINDOW = YES # Default: NO
FORMULA_FONTSIZE = 10
FORMULA_TRANSPARENT = YES
USE_MATHJAX = NO
MATHJAX_FORMAT = HTML-CSS
MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
MATHJAX_EXTENSIONS =
MATHJAX_CODEFILE =
SEARCHENGINE = $(SEARCHENGINE)
SERVER_BASED_SEARCH = $(SERVER_BASED_SEARCH)
EXTERNAL_SEARCH = NO
SEARCHENGINE_URL =
SEARCHDATA_FILE = searchdata.xml
EXTERNAL_SEARCH_ID =
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# LaTeX Output Options
#---------------------------------------------------------------------------
GENERATE_LATEX = $(GENERATE_LATEX)
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4
EXTRA_PACKAGES =
LATEX_HEADER = latex_header.tex
LATEX_FOOTER =
LATEX_EXTRA_FILES =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = YES # Default: NO
LATEX_HIDE_INDICES = NO
LATEX_SOURCE_CODE = NO
LATEX_BIB_STYLE = plain
#---------------------------------------------------------------------------
# RTF Output Options
#---------------------------------------------------------------------------
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# Man Page Output Options
#---------------------------------------------------------------------------
GENERATE_MAN = NO
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_SUBDIR =
MAN_LINKS = NO
#---------------------------------------------------------------------------
# XML Output Options
#---------------------------------------------------------------------------
GENERATE_XML = $(GENERATE_XML)
XML_OUTPUT = xml
XML_PROGRAMLISTING = NO # Default: YES
#---------------------------------------------------------------------------
# DOCBOOK Output Options
#---------------------------------------------------------------------------
GENERATE_DOCBOOK = NO
DOCBOOK_OUTPUT = docbook
DOCBOOK_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
# AutoGen Definitions Output Options
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# Perl Module Output Options
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = YES # Default: NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Preprocessor Options
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED = wxUSE_BASE \
wxUSE_GUI
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Additions Related to External References
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE = $(GENERATE_TAGFILE)
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
EXTERNAL_PAGES = YES
#---------------------------------------------------------------------------
# dot Tool Options
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
DIA_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES # Default: NO
DOT_NUM_THREADS = 0
DOT_FONTNAME =
DOT_FONTSIZE = 10
DOT_FONTPATH =
CLASS_GRAPH = YES
COLLABORATION_GRAPH = NO # Default: YES
GROUP_GRAPHS = NO # Default: YES
UML_LOOK = NO
UML_LIMIT_NUM_FIELDS = 10
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = NO # Default: YES
INCLUDED_BY_GRAPH = NO # Default: YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = NO # TODO: Default: YES
DIRECTORY_GRAPH = NO # Default: YES
DOT_IMAGE_FORMAT = $(DOT_IMAGE_FORMAT)
INTERACTIVE_SVG = NO
DOT_PATH =
DOTFILE_DIRS =
MSCFILE_DIRS =
DIAFILE_DIRS =
PLANTUML_JAR_PATH =
DOT_GRAPH_MAX_NODES = 150 # Default 50, we currently have 108 for wxObject
MAX_DOT_GRAPH_DEPTH = 1000 # Default: 0
DOT_TRANSPARENT = yes
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES

187
libs/wxWidgets-3.3.1/docs/doxygen/DoxygenLayout.xml Normal file
View File

@@ -0,0 +1,187 @@
<doxygenlayout version="1.0">
<!-- Navigation index tabs for HTML output -->
<navindex>
<tab type="mainpage" visible="yes" title=""/>
<tab type="pages" visible="yes" title="" intro=""/>
<tab type="modules" visible="yes" title="Categories" intro=""/>
<tab type="namespaces" visible="yes" title="">
<tab type="namespacelist" visible="yes" title="" intro=""/>
<tab type="namespacemembers" visible="yes" title="" intro=""/>
</tab>
<tab type="classes" visible="yes" title="">
<tab type="classlist" visible="yes" title="" intro=""/>
<tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
<tab type="hierarchy" visible="yes" title="" intro=""/>
<tab type="classmembers" visible="yes" title="" intro=""/>
</tab>
<tab type="files" visible="yes" title="">
<tab type="filelist" visible="yes" title="" intro=""/>
<tab type="globals" visible="yes" title="" intro=""/>
</tab>
<tab type="examples" visible="yes" title="" intro=""/>
</navindex>
<!-- Layout definition for a class page -->
<class>
<briefdescription visible="no"/>
<includes visible="$SHOW_INCLUDE_FILES"/>
<inheritancegraph visible="$CLASS_GRAPH"/>
<collaborationgraph visible="$COLLABORATION_GRAPH"/>
<detaileddescription title=""/>
<memberdecl>
<membergroups visible="yes"/>
<nestedclasses visible="yes" title=""/>
<publictypes title=""/>
<publicslots title=""/>
<signals title=""/>
<publicmethods title=""/>
<publicstaticmethods title=""/>
<publicattributes title=""/>
<publicstaticattributes title=""/>
<protectedtypes title=""/>
<protectedslots title=""/>
<protectedmethods title=""/>
<protectedstaticmethods title=""/>
<protectedattributes title=""/>
<protectedstaticattributes title=""/>
<packagetypes title=""/>
<packagemethods title=""/>
<packagestaticmethods title=""/>
<packageattributes title=""/>
<packagestaticattributes title=""/>
<properties title=""/>
<events title=""/>
<privatetypes title=""/>
<privateslots title=""/>
<privatemethods title=""/>
<privatestaticmethods title=""/>
<privateattributes title=""/>
<privatestaticattributes title=""/>
<friends title=""/>
<related title="" subtitle=""/>
</memberdecl>
<allmemberslink visible="yes"/>
<memberdef>
<inlineclasses title=""/>
<typedefs title=""/>
<enums title=""/>
<constructors title=""/>
<functions title=""/>
<related title=""/>
<variables title=""/>
<properties title=""/>
<events title=""/>
</memberdef>
<usedfiles visible="$SHOW_USED_FILES"/>
<authorsection visible="yes"/>
</class>
<!-- Layout definition for a namespace page -->
<namespace>
<briefdescription visible="no"/>
<detaileddescription title=""/>
<memberdecl>
<membergroups visible="yes"/>
<nestednamespaces visible="yes" title=""/>
<classes visible="yes" title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
</memberdecl>
<memberdef>
<inlineclasses title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
</memberdef>
<authorsection visible="yes"/>
</namespace>
<!-- Layout definition for a file page -->
<file>
<briefdescription visible="no"/>
<includes visible="$SHOW_INCLUDE_FILES"/>
<includegraph visible="$INCLUDE_GRAPH"/>
<includedbygraph visible="$INCLUDED_BY_GRAPH"/>
<sourcelink visible="yes"/>
<detaileddescription title=""/>
<memberdecl>
<membergroups visible="yes"/>
<classes visible="yes" title=""/>
<namespaces visible="yes" title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
</memberdecl>
<memberdef>
<inlineclasses title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
</memberdef>
<authorsection/>
</file>
<!-- Layout definition for a group page -->
<group>
<briefdescription visible="no"/>
<groupgraph visible="$GROUP_GRAPHS"/>
<detaileddescription title=""/>
<memberdecl>
<membergroups visible="yes"/>
<nestedgroups visible="yes" title=""/>
<dirs visible="yes" title=""/>
<files visible="yes" title=""/>
<namespaces visible="yes" title=""/>
<classes visible="yes" title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<enumvalues title=""/>
<functions title=""/>
<variables title=""/>
<signals title=""/>
<publicslots title=""/>
<protectedslots title=""/>
<privateslots title=""/>
<events title=""/>
<properties title=""/>
<friends title=""/>
</memberdecl>
<memberdef>
<pagedocs/>
<inlineclasses title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<enumvalues title=""/>
<functions title=""/>
<variables title=""/>
<signals title=""/>
<publicslots title=""/>
<protectedslots title=""/>
<privateslots title=""/>
<events title=""/>
<properties title=""/>
<friends title=""/>
</memberdef>
<authorsection visible="yes"/>
</group>
<!-- Layout definition for a directory page -->
<directory>
<briefdescription visible="yes"/>
<directorygraph visible="yes"/>
<detaileddescription title=""/>
<memberdecl>
<dirs visible="yes"/>
<files visible="yes"/>
</memberdecl>
</directory>
</doxygenlayout>

26
libs/wxWidgets-3.3.1/docs/doxygen/custom_footer.html Normal file
View File

@@ -0,0 +1,26 @@
<!--BEGIN GENERATE_TREEVIEW-->
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
<ul>
$navpath
<li class="footer">
$generatedby <a href="http://www.doxygen.org/index.html" target="_new">Doxygen</a> $doxygenversion
</li>
</ul>
</div>
<!--END GENERATE_TREEVIEW-->
<!--BEGIN !GENERATE_TREEVIEW-->
<address class="footer">
<small>
$generatedby <a href="http://www.doxygen.org/index.html" target="_new">Doxygen</a> $doxygenversion
</small>
</address>
<!--END !GENERATE_TREEVIEW-->
<script src="wxwidgets.js" type="text/javascript"></script>
<!--EXTRA FOOTER SCRIPT-->
</div><!-- #page_container -->
</body>
</html>

49
libs/wxWidgets-3.3.1/docs/doxygen/custom_header.html Normal file
View File

@@ -0,0 +1,49 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<!--BEGIN PROJECT_NAME--><title>$title | $projectname</title><!--END PROJECT_NAME-->
<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
<link href="$relpath$tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="$relpath$jquery.js"></script>
<script type="text/javascript" src="$relpath$dynsections.js"></script>
<script type="text/javascript" src="$relpath^doxygen-awesome-darkmode-toggle.js"></script>
<script type="text/javascript">DoxygenAwesomeDarkModeToggle.init()</script>
<script type="text/javascript" src="$relpath^doxygen-awesome-fragment-copy-button.js"></script>
<script type="text/javascript">DoxygenAwesomeFragmentCopyButton.init()</script>
$treeview
$search
$mathjax
<link href="$relpath$$stylesheet" rel="stylesheet" type="text/css" />
$extrastylesheet
</head>
<body>
<div id="page_container">
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<!--BEGIN TITLEAREA-->
<div id="titlearea">
<table cellspacing="0" cellpadding="0" style="width: 100%;">
<tbody>
<tr>
<!--BEGIN PROJECT_LOGO-->
<td id="projectlogo">
<a href="https://www.wxwidgets.org/" target="_new">
<img alt="wxWidgets" src="$relpath$$projectlogo"/>
</a>
</td>
<!--END PROJECT_LOGO-->
<td style="padding-left: 0.5em; text-align: right;">
<!--BEGIN PROJECT_NUMBER--><span id="projectnumber">Version: $projectnumber</span><!--END PROJECT_NUMBER-->
</td>
<!--BEGIN DISABLE_INDEX-->
<!--BEGIN SEARCHENGINE-->
<td>$searchbox</td>
<!--END SEARCHENGINE-->
<!--END DISABLE_INDEX-->
</tr>
</tbody>
</table>
</div>
<!--END TITLEAREA-->

45
libs/wxWidgets-3.3.1/docs/doxygen/custom_header_simple.html Normal file
View File

@@ -0,0 +1,45 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
<link href="$relpath$tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="$relpath$jquery.js"></script>
<script type="text/javascript" src="$relpath$dynsections.js"></script>
$treeview
$search
$mathjax
<link href="$relpath$$stylesheet" rel="stylesheet" type="text/css" />
$extrastylesheet
</head>
<body>
<div id="page_container">
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<!--BEGIN TITLEAREA-->
<div id="titlearea">
<table cellspacing="0" cellpadding="0" style="width: 100%;">
<tbody>
<tr>
<!--BEGIN PROJECT_LOGO-->
<td id="projectlogo">
<a href="https://www.wxwidgets.org/" target="_new">
<img alt="wxWidgets" src="$relpath$$projectlogo"/>
</a>
</td>
<!--END PROJECT_LOGO-->
<td style="padding-left: 0.5em; text-align: right;">
<!--BEGIN PROJECT_NUMBER--><span id="projectnumber">Version: $projectnumber</span><!--END PROJECT_NUMBER-->
</td>
<!--BEGIN DISABLE_INDEX-->
<!--BEGIN SEARCHENGINE-->
<td>$searchbox</td>
<!--END SEARCHENGINE-->
<!--END DISABLE_INDEX-->
</tr>
</tbody>
</table>
</div>
<!--END TITLEAREA-->

360
libs/wxWidgets-3.3.1/docs/doxygen/custom_search_functions.php Normal file
View File

@@ -0,0 +1,360 @@
<?php
require_once "search_config.php";
function end_form($value)
{
global $config;
global $translator;
if ($config['DISABLE_INDEX'] == false)
{
echo "</div>\n";
}
if ($config['GENERATE_TREEVIEW'])
{
echo $translator['split_bar'];
}
}
function search_results()
{
global $translator;
return $translator['search_results_title'];
}
function matches_text($num)
{
global $translator;
$string = $translator['search_results'][($num>2)?2:$num];
// The eval is used so that translator strings can contain $num.
eval("\$result = \"$string\";");
return $result;
}
function report_matches()
{
global $translator;
return $translator['search_matches'];
}
function readInt($file)
{
$b1 = ord(fgetc($file)); $b2 = ord(fgetc($file));
$b3 = ord(fgetc($file)); $b4 = ord(fgetc($file));
return ($b1<<24)|($b2<<16)|($b3<<8)|$b4;
}
function readString($file)
{
$result="";
while (ord($c=fgetc($file))) $result.=$c;
return $result;
}
function readHeader($file)
{
$header =fgetc($file); $header.=fgetc($file);
$header.=fgetc($file); $header.=fgetc($file);
return $header;
}
function computeIndex($word)
{
// Simple hashing that allows for substring search
if (strlen($word)<2) return -1;
// high char of the index
$hi = ord($word{0});
if ($hi==0) return -1;
// low char of the index
$lo = ord($word{1});
if ($lo==0) return -1;
// return index
return $hi*256+$lo;
}
function search($file,$word,&$statsList)
{
$index = computeIndex($word);
if ($index!=-1) // found a valid index
{
fseek($file,$index*4+4); // 4 bytes per entry, skip header
$index = readInt($file);
if ($index) // found words matching the hash key
{
$start=sizeof($statsList);
$count=$start;
fseek($file,$index);
$w = readString($file);
while ($w)
{
$statIdx = readInt($file);
if ($word==substr($w,0,strlen($word)))
{ // found word that matches (as substring)
$statsList[$count++]=array(
"word"=>$word,
"match"=>$w,
"index"=>$statIdx,
"full"=>strlen($w)==strlen($word),
"docs"=>array()
);
}
$w = readString($file);
}
$totalHi=0;
$totalFreqHi=0;
$totalFreqLo=0;
for ($count=$start;$count<sizeof($statsList);$count++)
{
$statInfo = &$statsList[$count];
$multiplier = 1;
// whole word matches have a double weight
if ($statInfo["full"]) $multiplier=2;
fseek($file,$statInfo["index"]);
$numDocs = readInt($file);
$docInfo = array();
// read docs info + occurrence frequency of the word
for ($i=0;$i<$numDocs;$i++)
{
$idx=readInt($file);
$freq=readInt($file);
$docInfo[$i]=array("idx" => $idx,
"freq" => $freq>>1,
"rank" => 0.0,
"hi" => $freq&1
);
if ($freq&1) // word occurs in high priority doc
{
$totalHi++;
$totalFreqHi+=$freq*$multiplier;
}
else // word occurs in low priority doc
{
$totalFreqLo+=$freq*$multiplier;
}
}
// read name and url info for the doc
for ($i=0;$i<$numDocs;$i++)
{
fseek($file,$docInfo[$i]["idx"]);
$docInfo[$i]["name"]=readString($file);
$docInfo[$i]["url"]=readString($file);
}
$statInfo["docs"]=$docInfo;
}
$totalFreq=($totalHi+1)*$totalFreqLo + $totalFreqHi;
for ($count=$start;$count<sizeof($statsList);$count++)
{
$statInfo = &$statsList[$count];
$multiplier = 1;
// whole word matches have a double weight
if ($statInfo["full"]) $multiplier=2;
for ($i=0;$i<sizeof($statInfo["docs"]);$i++)
{
$docInfo = &$statInfo["docs"];
// compute frequency rank of the word in each doc
$freq=$docInfo[$i]["freq"];
if ($docInfo[$i]["hi"])
{
$statInfo["docs"][$i]["rank"]=
(float)($freq*$multiplier+$totalFreqLo)/$totalFreq;
}
else
{
$statInfo["docs"][$i]["rank"]=
(float)($freq*$multiplier)/$totalFreq;
}
}
}
}
}
return $statsList;
}
function combine_results($results,&$docs)
{
foreach ($results as $wordInfo)
{
$docsList = &$wordInfo["docs"];
foreach ($docsList as $di)
{
$key=$di["url"];
$rank=$di["rank"];
if (isset($docs[$key]))
{
$docs[$key]["rank"]+=$rank;
}
else
{
$docs[$key] = array("url"=>$key,
"name"=>$di["name"],
"rank"=>$rank
);
}
$docs[$key]["words"][] = array(
"word"=>$wordInfo["word"],
"match"=>$wordInfo["match"],
"freq"=>$di["freq"]
);
}
}
return $docs;
}
function filter_results($docs,&$requiredWords,&$forbiddenWords)
{
$filteredDocs=array();
while (list ($key, $val) = each ($docs))
{
$words = &$docs[$key]["words"];
$copy=1; // copy entry by default
if (sizeof($requiredWords)>0)
{
foreach ($requiredWords as $reqWord)
{
$found=0;
foreach ($words as $wordInfo)
{
$found = $wordInfo["word"]==$reqWord;
if ($found) break;
}
if (!$found)
{
$copy=0; // document contains none of the required words
break;
}
}
}
if (sizeof($forbiddenWords)>0)
{
foreach ($words as $wordInfo)
{
if (in_array($wordInfo["word"],$forbiddenWords))
{
$copy=0; // document contains a forbidden word
break;
}
}
}
if ($copy) $filteredDocs[$key]=$docs[$key];
}
return $filteredDocs;
}
function compare_rank($a,$b)
{
if ($a["rank"] == $b["rank"])
{
return 0;
}
return ($a["rank"]>$b["rank"]) ? -1 : 1;
}
function sort_results($docs,&$sorted)
{
$sorted = $docs;
usort($sorted,"compare_rank");
return $sorted;
}
function report_results(&$docs)
{
echo "<div class=\"header\">";
echo " <div class=\"headertitle\">\n";
echo " <h1>".search_results()."</h1>\n";
echo " </div>\n";
echo "</div>\n";
echo "<div class=\"searchresults\">\n";
echo "<table cellspacing=\"2\">\n";
$numDocs = sizeof($docs);
if ($numDocs==0)
{
echo " <tr>\n";
echo " <td colspan=\"2\">".matches_text(0)."</td>\n";
echo " </tr>\n";
}
else
{
echo " <tr>\n";
echo " <td colspan=\"2\">".matches_text($numDocs);
echo "\n";
echo " </td>\n";
echo " </tr>\n";
$num=1;
foreach ($docs as $doc)
{
echo " <tr>\n";
echo " <td align=\"right\">$num.</td>";
echo "<td><a class=\"el\" href=\"".$doc["url"]."\">".$doc["name"]."</a></td>\n";
echo " <tr>\n";
echo " <td></td><td class=\"tiny\">".report_matches()." ";
foreach ($doc["words"] as $wordInfo)
{
$word = $wordInfo["word"];
$matchRight = substr($wordInfo["match"],strlen($word));
echo "<b>$word</b>$matchRight(".$wordInfo["freq"].") ";
}
echo " </td>\n";
echo " </tr>\n";
$num++;
}
}
echo "</table>\n";
echo "</div>\n";
}
function run_query($query)
{
if(strcmp('4.1.0', phpversion()) > 0)
{
die("Error: PHP version 4.1.0 or above required!");
}
if (!($file=fopen("search/search.idx","rb")))
{
die("Error: Search index file could NOT be opened!");
}
if (readHeader($file)!="DOXS")
{
die("Error: Header of index file is invalid!");
}
$results = array();
$requiredWords = array();
$forbiddenWords = array();
$foundWords = array();
$word=strtok($query," ");
while ($word) // for each word in the search query
{
if (($word{0}=='+')) { $word=substr($word,1); $requiredWords[]=$word; }
if (($word{0}=='-')) { $word=substr($word,1); $forbiddenWords[]=$word; }
if (!in_array($word,$foundWords))
{
$foundWords[]=$word;
search($file,strtolower($word),$results);
}
$word=strtok(" ");
}
fclose($file);
$docs = array();
combine_results($results,$docs);
// filter out documents with forbidden word or that do not contain
// required words
$filteredDocs = filter_results($docs,$requiredWords,$forbiddenWords);
// sort the results based on rank
$sorted = array();
sort_results($filteredDocs,$sorted);
return $sorted;
}
function main()
{
$query = "";
if (array_key_exists("query", $_GET))
{
$query=$_GET["query"];
}
$sorted = run_query($query);
// Now output the HTML stuff...
// End the HTML form
end_form(preg_replace("/[^a-zA-Z0-9\-\_\.\x80-\xFF]/i", " ", $query ));
// report results to the user
report_results($sorted);
}
?>

4
libs/wxWidgets-3.3.1/docs/doxygen/doxygen-awesome-css/README.md Normal file
View File

@@ -0,0 +1,4 @@
Files in this subdirectory were taken from the [Doxygen Awesome][1] CSS theme
and are under MIT licence.
[1]: https://github.com/jothepro/doxygen-awesome-css

157
libs/wxWidgets-3.3.1/docs/doxygen/doxygen-awesome-css/doxygen-awesome-darkmode-toggle.js Normal file
View File

@@ -0,0 +1,157 @@
/**
Doxygen Awesome
https://github.com/jothepro/doxygen-awesome-css
MIT License
Copyright (c) 2021 - 2022 jothepro
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
class DoxygenAwesomeDarkModeToggle extends HTMLElement {
// SVG icons from https://fonts.google.com/icons
// Licensed under the Apache 2.0 license:
// https://www.apache.org/licenses/LICENSE-2.0.html
static lightModeIcon = `<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24px" viewBox="0 0 24 24" width="24px" fill="#FCBF00"><rect fill="none" height="24" width="24"/><circle cx="12" cy="12" opacity=".3" r="3"/><path d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg>`
static darkModeIcon = `<svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24px" viewBox="0 0 24 24" width="24px" fill="#FE9700"><rect fill="none" height="24" width="24"/><path d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27 C17.45,17.19,14.93,19,12,19c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z" opacity=".3"/><path d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg>`
static title = "Toggle Light/Dark Mode"
static prefersLightModeInDarkModeKey = "prefers-light-mode-in-dark-mode"
static prefersDarkModeInLightModeKey = "prefers-dark-mode-in-light-mode"
static _staticConstructor = function() {
DoxygenAwesomeDarkModeToggle.enableDarkMode(DoxygenAwesomeDarkModeToggle.userPreference)
// Update the color scheme when the browsers preference changes
// without user interaction on the website.
window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
DoxygenAwesomeDarkModeToggle.onSystemPreferenceChanged()
})
// Update the color scheme when the tab is made visible again.
// It is possible that the appearance was changed in another tab
// while this tab was in the background.
document.addEventListener("visibilitychange", visibilityState => {
if (document.visibilityState === 'visible') {
DoxygenAwesomeDarkModeToggle.onSystemPreferenceChanged()
}
});
}()
static init() {
$(function() {
$(document).ready(function() {
const toggleButton = document.createElement('doxygen-awesome-dark-mode-toggle')
toggleButton.title = DoxygenAwesomeDarkModeToggle.title
toggleButton.updateIcon()
window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', event => {
toggleButton.updateIcon()
})
document.addEventListener("visibilitychange", visibilityState => {
if (document.visibilityState === 'visible') {
toggleButton.updateIcon()
}
});
$(document).ready(function(){
document.getElementById("MSearchBox").parentNode.appendChild(toggleButton)
})
$(window).resize(function(){
document.getElementById("MSearchBox").parentNode.appendChild(toggleButton)
})
})
})
}
constructor() {
super();
this.onclick=this.toggleDarkMode
}
/**
* @returns `true` for dark-mode, `false` for light-mode system preference
*/
static get systemPreference() {
return window.matchMedia('(prefers-color-scheme: dark)').matches
}
/**
* @returns `true` for dark-mode, `false` for light-mode user preference
*/
static get userPreference() {
return (!DoxygenAwesomeDarkModeToggle.systemPreference && localStorage.getItem(DoxygenAwesomeDarkModeToggle.prefersDarkModeInLightModeKey)) ||
(DoxygenAwesomeDarkModeToggle.systemPreference && !localStorage.getItem(DoxygenAwesomeDarkModeToggle.prefersLightModeInDarkModeKey))
}
static set userPreference(userPreference) {
DoxygenAwesomeDarkModeToggle.darkModeEnabled = userPreference
if(!userPreference) {
if(DoxygenAwesomeDarkModeToggle.systemPreference) {
localStorage.setItem(DoxygenAwesomeDarkModeToggle.prefersLightModeInDarkModeKey, true)
} else {
localStorage.removeItem(DoxygenAwesomeDarkModeToggle.prefersDarkModeInLightModeKey)
}
} else {
if(!DoxygenAwesomeDarkModeToggle.systemPreference) {
localStorage.setItem(DoxygenAwesomeDarkModeToggle.prefersDarkModeInLightModeKey, true)
} else {
localStorage.removeItem(DoxygenAwesomeDarkModeToggle.prefersLightModeInDarkModeKey)
}
}
DoxygenAwesomeDarkModeToggle.onUserPreferenceChanged()
}
static enableDarkMode(enable) {
if(enable) {
DoxygenAwesomeDarkModeToggle.darkModeEnabled = true
document.documentElement.classList.add("dark-mode")
document.documentElement.classList.remove("light-mode")
} else {
DoxygenAwesomeDarkModeToggle.darkModeEnabled = false
document.documentElement.classList.remove("dark-mode")
document.documentElement.classList.add("light-mode")
}
}
static onSystemPreferenceChanged() {
DoxygenAwesomeDarkModeToggle.darkModeEnabled = DoxygenAwesomeDarkModeToggle.userPreference
DoxygenAwesomeDarkModeToggle.enableDarkMode(DoxygenAwesomeDarkModeToggle.darkModeEnabled)
}
static onUserPreferenceChanged() {
DoxygenAwesomeDarkModeToggle.enableDarkMode(DoxygenAwesomeDarkModeToggle.darkModeEnabled)
}
toggleDarkMode() {
DoxygenAwesomeDarkModeToggle.userPreference = !DoxygenAwesomeDarkModeToggle.userPreference
this.updateIcon()
}
updateIcon() {
if(DoxygenAwesomeDarkModeToggle.darkModeEnabled) {
this.innerHTML = DoxygenAwesomeDarkModeToggle.darkModeIcon
} else {
this.innerHTML = DoxygenAwesomeDarkModeToggle.lightModeIcon
}
}
}
customElements.define("doxygen-awesome-dark-mode-toggle", DoxygenAwesomeDarkModeToggle);

85
libs/wxWidgets-3.3.1/docs/doxygen/doxygen-awesome-css/doxygen-awesome-fragment-copy-button.js Normal file
View File

@@ -0,0 +1,85 @@
/**
Doxygen Awesome
https://github.com/jothepro/doxygen-awesome-css
MIT License
Copyright (c) 2022 jothepro
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
class DoxygenAwesomeFragmentCopyButton extends HTMLElement {
constructor() {
super();
this.onclick=this.copyContent
}
static title = "Copy to clipboard"
static copyIcon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg>`
static successIcon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M0 0h24v24H0V0z" fill="none"/><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z"/></svg>`
static successDuration = 980
static init() {
$(function() {
$(document).ready(function() {
if(navigator.clipboard) {
const fragments = document.getElementsByClassName("fragment")
for(const fragment of fragments) {
const fragmentWrapper = document.createElement("div")
fragmentWrapper.className = "doxygen-awesome-fragment-wrapper"
const fragmentCopyButton = document.createElement("doxygen-awesome-fragment-copy-button")
fragmentCopyButton.innerHTML = DoxygenAwesomeFragmentCopyButton.copyIcon
fragmentCopyButton.title = DoxygenAwesomeFragmentCopyButton.title
fragment.parentNode.replaceChild(fragmentWrapper, fragment)
fragmentWrapper.appendChild(fragment)
fragmentWrapper.appendChild(fragmentCopyButton)
}
}
})
})
}
copyContent() {
const content = this.previousSibling.cloneNode(true)
// filter out line number from file listings
content.querySelectorAll(".lineno, .ttc").forEach((node) => {
node.remove()
})
let textContent = content.textContent
// remove trailing newlines that appear in file listings
let numberOfTrailingNewlines = 0
while(textContent.charAt(textContent.length - (numberOfTrailingNewlines + 1)) == '\n') {
numberOfTrailingNewlines++;
}
textContent = textContent.substring(0, textContent.length - numberOfTrailingNewlines)
navigator.clipboard.writeText(textContent);
this.classList.add("success")
this.innerHTML = DoxygenAwesomeFragmentCopyButton.successIcon
window.setTimeout(() => {
this.classList.remove("success")
this.innerHTML = DoxygenAwesomeFragmentCopyButton.copyIcon
}, DoxygenAwesomeFragmentCopyButton.successDuration);
}
}
customElements.define("doxygen-awesome-fragment-copy-button", DoxygenAwesomeFragmentCopyButton)

2137
libs/wxWidgets-3.3.1/docs/doxygen/doxygen-awesome-css/doxygen-awesome.css Normal file
View File

File diff suppressed because it is too large Load Diff

79
libs/wxWidgets-3.3.1/docs/doxygen/extra_stylesheet.css Normal file
View File

@@ -0,0 +1,79 @@
/* wxWidgets Custom Styles */
div.appearance {
margin: 1em 0em;
}
div.appearance table {
/* this is set to inline-block by the custom CSS theme, override it */
display: table !important;
margin: 0.5em 0em;
width: 100%;
text-align: center;
}
div.appearance img {
margin: 0.5em;
filter: none !important;
}
div.appearance .caption {
font-style: italic;
font-weight: normal;
font-size: 90%;
}
div.appearance_brief table {
width: 100%;
table-layout: fixed;
text-align: center;
border-collapse: collapse;
}
div.appearance_brief table td:first-child {
width: 20em;
text-align: left;
padding-left: 2em;
}
div.appearance_brief table td {
border-style: none solid solid none;
border-width: 1px;
border-color: lightblue;
}
td.green { color: green; }
td.orange { color: #ff8000; }
td.red { color: red; }
span.literal {
text-decoration: none;
font-weight: bold;
font-family: monospace, fixed;
}
/* we make all the following <span> tags render the text just like
the standard Doxygen @remarks, @see tags do, to obtain a uniform
look and feel */
span.itemdef, span.lib, span.category, span.stdobj, span.styles,
span.events, span.flags, span.appearance, span.impl, span.avail {
font-weight: bold;
line-height: 130%;
}
span.style, span.event, span.flag {
font-weight: bold;
}
div.styleDesc, div.eventDesc, div.flagDesc {
margin-left: 3%;
margin-bottom: 1ex;
}
div.eventHandler {
margin: 1em;
text-indent: 3%;
}
div.eventHandler span {
padding: 5px;
font-family: monospace, fixed;
}

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class.h
// Purpose: Main class group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class Class List by Category
This group contains all full class list groups. The @ref page_class_cat
provides a quick summary of these groups on one page.
*/

20
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_appmanagement.h Normal file
View File

@@ -0,0 +1,20 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_appmanagement.h
// Purpose: Application and Process Management classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_appmanagement Application and Process Management
@ingroup group_class
The classes in this section represent the application (see wxApp) or parts of it
(e.g. wxEventLoopBase, wxModule).
They can be used for initialization/shutdown of the application itself.
Related macros/global-functions group: @ref group_funcmacro_appinitterm.
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_archive.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_archive.h
// Purpose: wxArchive* classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_archive Archive support
@ingroup group_class
Classes for managing (eventually compressed) archives.
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_aui.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_aui.h
// Purpose: Window Docking (wxAUI) classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_aui Window Docking (wxAUI)
@ingroup group_class
wxAUI is a set classes for writing a customizable application interface
with built-in docking, floatable panes and a flexible MDI-like interface.
Related Overviews: @ref overview_aui
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_bookctrl.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_bookctrl.h
// Purpose: Book controls classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_bookctrl Book Controls
@ingroup group_class
A book control contains pages of other controls.
Related overview: @ref overview_bookctrl
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_cfg.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_cfg.h
// Purpose: Application and System configuration classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_cfg Application and System configuration
@ingroup group_class
The classes in this section are used to handle application-wide settings
and system-wide settings.
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_cmndlg.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_cmndlg.h
// Purpose: Common Dialog classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_cmndlg Common Dialogs
@ingroup group_class
Common dialogs are ready-made dialog classes which are frequently used in an
application.
Related Overviews: @ref overview_cmndlg
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_containers.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_containers.h
// Purpose: Container classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_containers Containers
@ingroup group_class
These are classes, templates and class macros are used by wxWidgets. Most of
these classes provide a subset or almost complete STL API.
Related Overviews: @ref overview_container
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_conv.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_conv.h
// Purpose: Conversion classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_conv Text Conversion
@ingroup group_class
These are the classes used for conversions between different text encodings.
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_ctrl.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_ctrl.h
// Purpose: Control classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_ctrl Controls
@ingroup group_class
Typically, these are small windows which provide interaction with the user.
Controls that are not static can have wxValidator associated with them.
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_data.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_data.h
// Purpose: Data Structure classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_data Data Structures
@ingroup group_class
These are the data structure classes provided by wxWidgets.
Some of them are used to store generic data (e.g. wxPoint, wxSize, etc),
others are mainly helpers of other classes (e.g. wxListItem, wxCalendarDateAttr,
wxFindReplaceDialogData, etc).
*/

20
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_dc.h Normal file
View File

@@ -0,0 +1,20 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_gdi.h
// Purpose: Graphics Device Interface classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_dc Device Contexts
@ingroup group_class
Device contexts are surfaces that may be drawn on, and provide an abstraction
that allows parameterisation of your drawing code by passing different device
contexts.
Related Overviews: @ref overview_dc
*/

21
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_debugging.h Normal file
View File

@@ -0,0 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_debugging.h
// Purpose: Debugging classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_debugging Debugging
@ingroup group_class
wxWidgets supports some aspects of debugging an application through classes,
functions and macros.
Related Overviews: @ref overview_debugging
Related macros/global-functions group: @ref group_funcmacro_debug
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_dnd.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_dnd.h
// Purpose: Clipboard and Drag & Drop classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_dnd Clipboard and Drag & Drop
@ingroup group_class
Related Overviews: @ref overview_dnd
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_docview.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_docview.h
// Purpose: Document/View Framework classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_docview Document/View Framework
@ingroup group_class
wxWidgets supports a document/view framework which provides housekeeping for a
document-centric application.
Related Overviews: @ref overview_docview
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_dvc.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_dvc.h
// Purpose: wxDataViewControl classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_dvc wxDataViewCtrl Related Classes
@ingroup group_class
These are all classes used or provided for use with wxDataViewCtrl.
*/

21
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_events.h Normal file
View File

@@ -0,0 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_events.h
// Purpose: Event classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_events Events
@ingroup group_class
An event object contains information about a specific event. Event handlers
(usually member functions) have a single, event argument.
Related Overviews: @ref overview_events
Related macros/global-functions group: @ref group_funcmacro_events
*/

20
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_file.h Normal file
View File

@@ -0,0 +1,20 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_file.h
// Purpose: File Handling classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_file File Handling
@ingroup group_class
wxWidgets has several small classes to work with disk files and directories.
Related Overviews: @ref overview_file
Related macros/global-functions group: @ref group_funcmacro_file
*/

22
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_gdi.h Normal file
View File

@@ -0,0 +1,22 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_gdi.h
// Purpose: Graphics Device Interface classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_gdi Graphics Device Interface (GDI)
@ingroup group_class
The following are classes related to GDI (Graphics Device Interface) access.
They provide an API for drawing on device contexts, windows, and printing.
Related Overviews: @ref overview_dc, @ref overview_bitmap
Related macros/global-functions group: @ref group_funcmacro_gdi
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_gl.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_gl.h
// Purpose: OpenGL classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_gl OpenGL
@ingroup group_class
Classes interfacing wxWidgets with OpenGL (http://opengl.org/).
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_grid.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_grid.h
// Purpose: wxGrid classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_grid Grid Related Classes
@ingroup group_class
Classes related to the wxGrid generic widget.
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_help.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_help.h
// Purpose: Help classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_help Help
@ingroup group_class
Classes for loading and displaying help manuals or help information in general.
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_html.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_html.h
// Purpose: HTML classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_html HTML
@ingroup group_class
wxWidgets provides a set of classes to display text in HTML format. These
classes include a help system based on the HTML widget.
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_ipc.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_ipc.h
// Purpose: Interprocess Communication classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_ipc Interprocess Communication
@ingroup group_class
wxWidgets provides simple interprocess communications facilities based on
Windows DDE, but they are available on most platforms using TCP.
Related Overviews: @ref overview_ipc
*/

20
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_logging.h Normal file
View File

@@ -0,0 +1,20 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_logging.h
// Purpose: Logging classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_logging Logging
@ingroup group_class
wxWidgets provides several classes and functions for message logging.
Related Overviews: @ref overview_log
Related macros/global-functions group: @ref group_funcmacro_log
*/

22
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_managedwnd.h Normal file
View File

@@ -0,0 +1,22 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_managedwnd.h
// Purpose: Managed Windows classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_managedwnd Managed Windows
@ingroup group_class
There are several types of window that are directly controlled by the window
manager (such as MS Windows, or the X11 Window Manager). Frames and dialogs
are similar in wxWidgets, but only dialogs may be modal.
Related Overviews: @ref overview_cmndlg
Related macros/global-functions group: @ref group_funcmacro_dialog
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_media.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_media.h
// Purpose: Multimedia classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_media Multimedia
@ingroup group_class
Classes for showing multimedia contents.
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_menus.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_menus.h
// Purpose: Menu classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_menus Menus
@ingroup group_class
Group of classes for handling menu bars and items.
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_misc.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_misc.h
// Purpose: Miscellaneous classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_misc Miscellaneous
@ingroup group_class
Group of miscellaneous classes.
Related macros/global-functions group: @ref group_funcmacro_misc
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_miscwnd.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_miscwnd.h
// Purpose: Miscellaneous Windows classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_miscwnd Miscellaneous Windows
@ingroup group_class
The following are a variety of classes that are derived from wxWindow.
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_net.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_net.h
// Purpose: Networking classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_net Networking
@ingroup group_class
wxWidgets provides its own classes for socket based networking.
Related macros/global-functions group: @ref group_funcmacro_networkuseros
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_pickers.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_pickers.h
// Purpose: Picker Control classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_pickers Picker Controls
@ingroup group_class
A picker control is a control whose appearance and behaviour is highly
platform-dependent.
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_printing.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_printing.h
// Purpose: Printing Framework classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_printing Printing Framework
@ingroup group_class
A printing and previewing framework is implemented to make it relatively
straightforward to provide document printing facilities.
Related Overviews: @ref overview_printing
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_propgrid.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_propgrid.h
// Purpose: wxPropertyGrid classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_propgrid wxPropertyGrid
@ingroup group_class
wxPropertyGrid is a specialized grid for editing properties (that is,
name=value pairs). This style of control has also been known as
property sheet or object grid.
Related Overviews: @ref overview_propgrid
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_ribbon.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_ribbon.h
// Purpose: Ribbon classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_ribbon Ribbon User Interface
@ingroup group_class
The wxRibbon library is a set of classes for writing a ribbon user interface.
At the most generic level, this is a combination of a tab control with a
toolbar. At a more functional level, it is similar to the user interface
present in recent versions of Microsoft Office.
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_richtext.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_richtext.h
// Purpose: Rich Text classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_richtext Rich Text
@ingroup group_class
wxWidgets provides a set of generic classes to edit and print simple rich text
with character and paragraph formatting.
*/

21
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_rtti.h Normal file
View File

@@ -0,0 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_rtti.h
// Purpose: Runtime Type Information (RTTI) classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_rtti Runtime Type Information (RTTI)
@ingroup group_class
wxWidgets supports runtime manipulation of class information, and dynamic
creation of objects given class names.
Related Overviews: @ref overview_rtti
Related macros/global-functions group: @ref group_funcmacro_rtti
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_smartpointers.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_smartpointers.h
// Purpose: Smart Pointer classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_smartpointers Smart Pointers
@ingroup group_class
wxWidgets provides a few smart pointer class templates.
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_stc.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_stc.h
// Purpose: Scintilla Text Editor classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_stc Scintilla Text Editor
@ingroup group_class
wxWidgets also provides a wrapper around the Scintilla text editor control,
which is a control for plain-text editing with support for highlighting, smart
indentation, etc.
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_streams.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_streams.h
// Purpose: Stream classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_streams Streams
@ingroup group_class
wxWidgets has its own set of stream classes, as an alternative to often buggy
standard stream libraries, and to provide enhanced functionality.
Related overviews: @ref overview_stream
*/

21
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_threading.h Normal file
View File

@@ -0,0 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_threading.h
// Purpose: Threading classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_threading Threading
@ingroup group_class
wxWidgets provides a set of classes to make use of the native thread
capabilities of the various platforms.
Related Overviews: @ref overview_thread
Related macros/global-functions group: @ref group_funcmacro_thread
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_validator.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_validator.h
// Purpose: Validator classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_validator Validators
@ingroup group_class
These are the window validators, used for filtering and validating user input.
Related Overviews: @ref overview_validator
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_vfs.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_vfs.h
// Purpose: Virtual File System classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_vfs Virtual File System
@ingroup group_class
wxWidgets provides a set of classes that implement an extensible virtual file
system, used internally by the HTML classes.
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_webview.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_webview.h
// Purpose: WebView classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_webview WebView
@ingroup group_class
The wxWebView library is a set of classes for viewing complex web documents and
for internet browsing. It is built around a series of backends, and exposes
common functions for them.
*/

21
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_winlayout.h Normal file
View File

@@ -0,0 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_winlayout.h
// Purpose: Window Layout classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_winlayout Window Layout
@ingroup group_class
wxWidgets makes window layout and sizing easy and painless using a set of
classes known as "sizers". Sizers allow for flexible window positioning and
sizes that can help with automatically handling localization differences, as
well as making it easy to write user resizable windows.
Related Overviews: @ref overview_sizer, @ref overview_windowsizing
*/

16
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_xml.h Normal file
View File

@@ -0,0 +1,16 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_xml.h
// Purpose: XML classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_xml XML
@ingroup group_class
Group of classes loading and saving XML documents (http://www.w3.org/XML/).
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/class_xrc.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: class_xrc.h
// Purpose: XML Based Resource System (XRC) classes group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_class_xrc XML Based Resource System (XRC)
@ingroup group_class
Resources allow your application to create controls and other user interface
elements from specifications stored in an XML format.
Related Overviews: @ref overview_xrc
*/

15
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro.h Normal file
View File

@@ -0,0 +1,15 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro.h
// Purpose: Main function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro Functions and Macros by Category
This group defines all major function and macro groups.
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_appinitterm.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_appinitterm.h
// Purpose: App Initialization and Termination fn and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_appinitterm Application Initialization and Termination
@ingroup group_funcmacro
The functions in this section are used on application startup/shutdown and also
to control the behaviour of the main event loop of the GUI programs.
Related macros/global-functions group: @ref group_class_appmanagement.
*/

27
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_atomic.h Normal file
View File

@@ -0,0 +1,27 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_atomic.h
// Purpose: Atomic Operation function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_atomic Atomic Operations
@ingroup group_funcmacro
When using multi-threaded applications, it is often required to access or
modify memory which is shared between threads. Atomic integer and pointer
operations are an efficient way to handle this issue (another, less efficient,
way is to use a wxMutex or wxCriticalSection). A native implementation exists
for Windows, Linux, Solaris and macOS; for others, a wxCriticalSection is
used to protect the data.
One particular application is reference counting (used by so-called
@ref group_class_smartpointers "smart pointers").
You should define your variable with the type wxAtomicInt in order to apply
atomic operations to it.
*/

21
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_byteorder.h Normal file
View File

@@ -0,0 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_byteorder.h
// Purpose: Byte Order function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_byteorder Byte Order
@ingroup group_funcmacro
The endian-ness issues (that is the difference between big-endian and
little-endian architectures) are important for the portable programs working
with the external binary data (for example, data files or data coming from
network) which is usually in some fixed, platform-independent format.
The macros are helpful for transforming the data to the correct format.
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_crt.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_crt.h
// Purpose: wx wrappers for CRT functions
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_crt Wrappers of CRT functions
@ingroup group_funcmacro
For documentation of these functions please refer to the documentation
of the standard CRT functions (see e.g.\ http://www.cppreference.com/wiki/c/start).
*/

36
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_debug.h Normal file
View File

@@ -0,0 +1,36 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_debug.h
// Purpose: Debugging function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_debug Debugging macros
@ingroup group_funcmacro
Useful macros and functions for error checking and defensive programming.
Starting with wxWidgets 2.9.1, debugging support in wxWidgets is always
compiled in by default, you need to explicitly define ::wxDEBUG_LEVEL as 0 to
disable it completely. However, by default debugging macros are dormant in the
release builds, i.e. when the main program is compiled with the standard @c
NDEBUG symbol being defined. You may explicitly activate the debugging checks
in the release build by calling wxSetAssertHandler() with a custom function if
needed.
When debugging support is active, failure of both wxASSERT() and wxCHECK()
macros conditions result in a debug alert. When debugging support is inactive
or turned off entirely at compilation time, wxASSERT() and wxFAIL() macros
don't do anything while wxCHECK() still checks its condition and returns if it
fails, even if no alerts are shown to the user.
Finally, the compile time assertions don't happen during the run-time but
result in the compilation error messages if the condition they check fail.
They are always enabled and are not affected by ::wxDEBUG_LEVEL.
Related class group: @ref group_class_debugging.
*/

20
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_dialog.h Normal file
View File

@@ -0,0 +1,20 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_dialog.h
// Purpose: Dialog function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_dialog Dialogs
@ingroup group_funcmacro
Below are a number of convenience functions for getting input from the user
or displaying messages. Note that in these functions the last three parameters
are optional. However, it is recommended to pass a parent frame parameter, or
the wrong window frame may be brought to the front when the dialog box is
popped up.
*/

25
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_env.h Normal file
View File

@@ -0,0 +1,25 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_env.h
// Purpose: Environment function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_env Environment
@ingroup group_funcmacro
These functions allow access to get or change the values of environment
variables in a portable way. They are currently implemented under Win32 and
POSIX-like systems (Unix).
Remember that these functions add/change/delete environment variables of the
current process only. Child processes copy the environment variables of the parent,
but do not share them (a wxSetEnv() in the parent process won't change the value
returned by wxGetEnv() in the child process and vice versa).
For more advanced interprocess communication techniques see @ref overview_ipc.
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_events.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_events.h
// Purpose: Event functions and macro group doc
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_events Events
@ingroup group_funcmacro
Below are a number of functions/macros used with wxWidgets event-handling system.
Related class group: @ref group_class_events
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_file.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_file.h
// Purpose: Files and Directories function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_file Files and Directories
@ingroup group_funcmacro
These functions provide a platform-independent API for common file and
directory functionality.
Related class group: @ref group_class_file
*/

21
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_gdi.h Normal file
View File

@@ -0,0 +1,21 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_gdi.h
// Purpose: Graphics Device Interface function and macro docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_gdi Graphics Device Interface (GDI)
@ingroup group_funcmacro
The following are functions and macros related to GDI (Graphics Device
Interface) access.
Related Overviews: @ref overview_dc
Related class group: @ref group_class_gdi
*/

28
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_locale.h Normal file
View File

@@ -0,0 +1,28 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_locale.h
// Purpose: wxXLocale-enabled functions
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_locale Locale-dependent functions
@ingroup group_funcmacro
Below are a number of functions/macros which accept as last parameter a
specific wxXLocale instance.
For the documentation of function @c wxFunc_l(), please see the documentation
of the standard @c Func() function (see e.g. http://www.cppreference.com/wiki/c/string/start)
and keep in mind that the wxWidgets function takes as last parameter the
locale which should be internally used for locale-dependent operations.
Last, note that when the @c wxHAS_XLOCALE_SUPPORT symbol is not defined,
then wxWidgets will provide implementations of these functions itself
and that they are not granted to be thread-safe (and they will work only with the
C locale; see @ref xlocale_avail).
*/

23
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_log.h Normal file
View File

@@ -0,0 +1,23 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_log.h
// Purpose: Logging function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_log Logging
@ingroup group_funcmacro
These functions provide a variety of logging functions. The functions use
(implicitly) the currently active log target, so their descriptions here may
not apply if the log target is not the standard one (installed by wxWidgets in
the beginning of the program).
Related Overviews: @ref overview_log
Related class group: @ref group_class_logging
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_math.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_math.h
// Purpose: Math function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_math Math
@ingroup group_funcmacro
The functions in this section are typically related with math operations and
floating point numbers.
*/

18
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_misc.h Normal file
View File

@@ -0,0 +1,18 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_misc.h
// Purpose: Miscellaneous function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_misc Miscellaneous
@ingroup group_funcmacro
Group of miscellaneous functions and macros.
Related class group: @ref group_class_misc
*/

19
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_networkuseros.h Normal file
View File

@@ -0,0 +1,19 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_networkuseros.h
// Purpose: Network, User and OS function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_networkuseros Network, User and OS
@ingroup group_funcmacro
The functions in this section are used to retrieve information about the
current computer and/or user characteristics.
Related class group: @ref group_class_net, wxPlatformInfo.
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_procctrl.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_procctrl.h
// Purpose: Process Control function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_procctrl Process Control
@ingroup group_funcmacro
The functions in this section are used to launch or terminate the other
processes.
*/

26
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_rtti.h Normal file
View File

@@ -0,0 +1,26 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_rtti.h
// Purpose: Runtime Type Information function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_rtti Runtime Type Information (RTTI)
@ingroup group_funcmacro
wxWidgets uses its own RTTI ("run-time type identification") system which
predates the current standard C++ RTTI and so is kept for backwards
compatibility reasons but also because it allows some things which the standard
RTTI doesn't directly support (such as creating a class from its name). The
standard C++ RTTI can be used in the user code without any problems and in
general you shouldn't need to use the functions and the macros in this section
unless you are thinking of modifying or adding any wxWidgets classes.
Related Overviews: @ref overview_rtti
Related class group: @ref group_class_rtti
*/

22
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_string.h Normal file
View File

@@ -0,0 +1,22 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_string.h
// Purpose: String function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_string Strings
@ingroup group_funcmacro
Global string functions and macros. See wxString for the wxWidgets string class.
Please note that all functions of this group which are documented to take @c char*
arrays are overloaded with @c wchar_t* variants.
Note also that wxWidgets wraps all standard CRT functions, even if the wrappers
are not (all) documented.
*/

28
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_thread.h Normal file
View File

@@ -0,0 +1,28 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_thread.h
// Purpose: Threads function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_thread Threads
@ingroup group_funcmacro
The functions and macros here mainly exist to make it possible to write code
which may be compiled in multi thread build (wxUSE_THREADS = 1) as well as in
single thread configuration (wxUSE_THREADS = 0).
For example, a static variable must be protected against simultaneous access by
multiple threads in the former configuration but in the latter the extra
overhead of using the critical section is not needed. To solve this problem,
the wxCRITICAL_SECTION() macro may be used to create and use the critical
section only when needed.
@see wxThread, wxMutex, @ref overview_thread
Related class group: @ref group_class_threading
*/

17
libs/wxWidgets-3.3.1/docs/doxygen/groups/funcmacro_time.h Normal file
View File

@@ -0,0 +1,17 @@
/////////////////////////////////////////////////////////////////////////////
// Name: funcmacro_time.h
// Purpose: Time function and macro group docs
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
@defgroup group_funcmacro_time Time
@ingroup group_funcmacro
The functions in this section deal with getting the current time and sleeping
for the specified time interval.
*/

Some files were not shown because too many files have changed in this diff Show More