wxWidgets

https://wxwidgets.org/docs/
Admin
wxWidgets is a cross-platform GUI library that enables developers to create native-looking graphical...
Tokens:23,927
Snippets:151
Trust Score:9.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### wxWidgets Hello World Tutorial

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the wxWidgets documentation for the 'Hello World' example, which is a fundamental starting point for learning the framework.

```URL
https://docs.wxwidgets.org/latest/overview_helloworld.html
```

--------------------------------

### wxWidgets Getting Started: Application and Window

Source: https://wxwidgets.org/docs/book

Covers the basic structure of a wxWidgets application, including the application class, main window, and event table, outlining the program flow.

```C++
// Example of a basic wxWidgets application structure:
// class MyApp : public wxApp {
// public:
//     virtual bool OnInit();
// };
// 
// class MyFrame : public wxFrame {
// public:
//     MyFrame(const wxString& title);
// };
// 
// IMPLEMENT_APP(MyApp);
// 
// bool MyApp::OnInit() {
//     MyFrame *frame = new MyFrame("Hello wxWidgets");
//     frame->Show(true);
//     return true;
// }
```

--------------------------------

### wxWidgets IDE Setup with MinGW and Code::Blocks

Source: https://wxwidgets.org/docs/tutorials

A guide for setting up a wxWidgets development environment on Windows using MinGW and the Code::Blocks IDE. It covers choosing wxWidgets versions, building wxWidgets with different parameters, and configuring projects in Code::Blocks.

```C++
// Configuration steps for setting up wxWidgets with MinGW and Code::Blocks.
// Includes guidance on building wxWidgets and project setup.
// ... actual code snippet would be here if available in the source text
```

--------------------------------

### wxWidgets Book - Appendices for Setup

Source: https://wxwidgets.org/docs/book

This documentation highlights crucial setup instructions found in the wxWidgets book's appendices. It emphasizes the importance of these sections for users looking to build their own applications.

```APIDOC
AppendixB: Application Setup Instructions
AppendixC: Application Setup Instructions
Purpose: Guide users on building their own applications using popular compilers.
KeyTool: DialogBlocks (included on CD-ROM) - facilitates compilation of wxWidgets library and user applications.
Note: Users are advised to consult these appendices for a smooth development setup.
```

--------------------------------

### wxWidgets Online Manual

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the comprehensive online manual for wxWidgets, providing detailed information on its features and usage.

```URL
https://docs.wxwidgets.org/3.2/
```

--------------------------------

### wxWidgets Developer Blog

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the wxWidgets developer blog, featuring articles and insights from the development team.

```URL
https://wxwidgets.org/blog/
```

--------------------------------

### Hello World in wxWidgets

Source: https://wxwidgets.org/docs/tutorials

A very short tutorial demonstrating the basic 'Hello World' application in wxWidgets. It provides a minimal code example from the wxWidgets manual.

```C++
/*
 * A tiny tutorial with code from wxWidgets manual.
 */
// ... actual code snippet would be here if available in the source text
```

--------------------------------

### wxWidgets Community Wiki

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the wxWidgets community wiki, a collaborative resource for users to share information, tips, and solutions.

```URL
https://wiki.wxwidgets.org/
```

--------------------------------

### Compiler and Installation Information

Source: https://wxwidgets.org/docs/faq/windows

Provides guidance on supported compilers and installation procedures for wxWidgets on Windows. For the most current information, consult the `docs/msw/install.md` file in the wxWidgets source repository or the introductory documentation.

```markdown
See [docs/msw/install.md](https://github.com/wxWidgets/wxWidgets/blob/master/docs/msw/install.md).
Also see [this article](https://docs.wxwidgets.org/latest/page_introduction.html#page_introduction_requirements).
```

--------------------------------

### Linux and Unix Installer Tools

Source: https://wxwidgets.org/docs/tutorials/building-installers

This section outlines common installation methods and tools for Linux and Unix-based systems. It covers native package managers and alternative installer solutions.

```text
Loki Setup: a GUI installer based on GTK+.
Red Hat Package Manager (RPM).
RUST: a drag and drop GTK+ application for building RPM files without messing with .spec files.
InstallAnywhere by Zero G
InstallShield Multiplatform
EPM
```

--------------------------------

### wxWidgets Development Roadmap

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the wxWidgets development roadmap, outlining the project's future plans and development direction.

```URL
https://wxwidgets.org/develop/roadmap/
```

--------------------------------

### Windows Installer Tools

Source: https://wxwidgets.org/docs/tutorials/building-installers

This section lists free installer tools for Windows that can be used to package wxWidgets applications. These tools help in creating a professional installation experience for users.

```text
Inno Setup: a free Windows installer with Pascal scripting
NSIS Nullsoft (SuperPiMP|Scriptable) Install System, originally written for installing Winamp
Install Creator: has a free version
```

--------------------------------

### wxWidgets GitHub Repository

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the official wxWidgets GitHub repository, providing access to the source code and project management tools.

```URL
https://github.com/wxWidgets/wxWidgets
```

--------------------------------

### Report a Bug for wxWidgets

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the GitHub issue tracker for wxWidgets, where users can report bugs and issues they encounter.

```URL
https://github.com/wxWidgets/wxWidgets/issues/new
```

--------------------------------

### Application Perfecting Techniques

Source: https://wxwidgets.org/docs/book

Covers single vs. multiple instances, event handling, flicker reduction, help system integration, command-line parsing, resource management, and application installation.

```C++
wxApp
wxCmdLineParser
wxHelpController
wxConfig
```

--------------------------------

### Starting a New wxWidgets Port

Source: https://wxwidgets.org/docs/faq/general

Guidance on initiating a new port for wxWidgets. This involves defining symbols, implementing core classes, and integrating build systems. It suggests strategies like adapting existing ports and focusing on essential components first.

```cpp
#define __WXXBOX__ // Example symbol definition

// Include necessary headers for character support and platform specifics
#include "wx/defs.h"
#include "wx/wxchar.h"

// Define __UNIX__ if the GUI runs on a Unix variant
// For makefiles: DEFINES += __UNIX__

// Implement core classes in order of priority:
// wxWindow, wxTopLevelWindow, wxFrame, wxDialog

// Consider using generic GDI objects if native ones are not available:
// See wxX11 port for examples of generic wxPen, wxBrush, etc.

// For wxUniversal widget set integration, implement basic classes like:
// device contexts, wxWindow, wxTopLevelWindow, GDI objects.

// Integrate with build systems:
// - configure (Unix-like systems, gcc on Windows)
// - bakefile (other Windows makefiles)

// Submit changes via GitHub pull requests, potentially separating common and port-specific code.
```

--------------------------------

### wxWidgets News RSS Feed

Source: https://wxwidgets.org/docs/tutorials/building-installers

A link to the RSS feed for wxWidgets news, allowing users to stay updated on project announcements and updates.

```URL
https://wxwidgets.org/atom.xml
```

--------------------------------

### Determining DLL Dependencies

Source: https://wxwidgets.org/docs/tutorials/building-installers

This snippet explains how to identify the dynamic-link libraries (DLLs) required by a wxWidgets application on Windows. This is crucial for ensuring the installer includes all necessary components.

```text
Use Steve Miller’s Dependency Walker to determine the DLL dependencies of your application.
```

--------------------------------

### Linux Desktop Entry Specification

Source: https://wxwidgets.org/docs/tutorials/building-installers

This entry references the standard specification for integrating applications into desktop environments like GNOME and KDE on Linux. It's relevant for creating consistent user experiences.

```APIDOC
KDE and GNOME desktop environment entry standard:
https://www.freedesktop.org/standards/desktop-entry-spec/desktop-entry-spec.html
```

--------------------------------

### wxWidgets Support Channels

Source: https://wxwidgets.org/docs/faq/general

Information on how to get support for wxWidgets, including official channels and community resources. It emphasizes the active user community.

```APIDOC
wxWidgets Support:

- **Official Support**: No official support is provided.
- **Mailing List**: The mailing list is a very helpful resource for support.
- **User Forum**: An active user forum is available where users can get questions answered and issues helped by other wxWidgets users.
- **Bug Fixes**: Developers are keen to fix bugs as soon as possible, though no guarantees are made.
```

--------------------------------

### Flood Fill Example Correction

Source: https://wxwidgets.org/docs/book/errata

Corrects a code example demonstrating wxDC's FloodFill functionality. The original example had a typo in a comment and incorrect spacing. This snippet provides the corrected code for drawing a rectangle, filling it with green, and then using FloodFill with different colors and modes.

```cpp
// Draw a green rectangle outlined in red
dc.SetPen(*wxRED_PEN);

dc.SetBrush(*wxGREEN_BRUSH);
dc.DrawRectangle(10, 10, 100, 100);

// Now fill the green area with black (while green is found)
dc.SetBrush(*wxBLACK_BRUSH);
dc.FloodFill(50, 50, *wxGREEN, wxFLOOD_SURFACE);

// Then fill with blue (until red is encountered)
dc.SetBrush(*wxBLUE_BRUSH);
dc.FloodFill(50, 50, *wxRED, wxFLOOD_BORDER);
```

--------------------------------

### wxWidgets Book - Core Concepts

Source: https://wxwidgets.org/docs/book

This section outlines the primary content of the wxWidgets book, focusing on its role as a guide for cross-platform GUI programming. It highlights the book's depth and the practical resources provided.

```APIDOC
BookTitle: Cross-Platform GUI Programming with wxWidgets
Authors: Julian Smart, Kevin Hock, Stefan Csomor
PublicationDate: July 27th 2005
Publisher: Prentice Hall (Open Source Series)
PageCount: 700
ContentSummary: Comprehensive guide to cross-platform GUI programming using wxWidgets in C++.
KeyFeatures:
  - Detailed explanations of wxWidgets concepts.
  - Practical code samples and examples.
  - Guidance on building applications with popular compilers.
  - Information on using DialogBlocks, a GUI editor.
IncludedResources:
  - CD-ROM with source code, compilers, and tools.
  - DialogBlocks (for Windows, Linux, Mac OS X).
Availability:
  - Digital PDF Download (Free, licensed under Open Publication License).
  - Paperback (Out of print, used copies available from various retailers).
OnlineReading: Available via subscription to O'Reilly.
```

--------------------------------

### wxWidgets Static Linking Configuration (Unix)

Source: https://wxwidgets.org/docs/tutorials/building-installers

This snippet demonstrates how to configure wxWidgets for static linking on Unix-like systems to avoid the complexities of distributing shared libraries. Static linking embeds wxGTK and GTK+ directly into the application, resulting in a larger executable but simplifying deployment.

```bash
./configure --disable-shared
```

--------------------------------

### Mac OS X Application Distribution

Source: https://wxwidgets.org/docs/tutorials/building-installers

This entry provides a link to Apple's developer resources for distributing Mac OS X applications, offering guidance on best practices for deployment on the platform.

```URL
https://developer.apple.com/macos/distribution/
```

--------------------------------

### wxWidgets Custom Dialogs

Source: https://wxwidgets.org/docs/book

Guides through creating custom dialogs, including deriving classes, designing data storage, coding controls and layout, data transfer, validation, event handling, UI updates, and using resource files (XRC).

```C++
// Example of a custom dialog class definition:
// class MyCustomDialog : public wxDialog {
// public:
//     MyCustomDialog(wxWindow* parent);
// private:
//     wxTextCtrl* nameCtrl;
//     wxTextCtrl* emailCtrl;
//     void OnOk(wxCommandEvent& event);
//     DECLARE_EVENT_TABLE()
// };
// 
// BEGIN_EVENT_TABLE(MyCustomDialog, wxDialog)
//     EVT_BUTTON(wxID_OK, MyCustomDialog::OnOk)
// END_EVENT_TABLE()
```

--------------------------------

### File Compression with UPX

Source: https://wxwidgets.org/docs/tutorials/building-installers

This snippet refers to the use of UPX, a file compressor, to reduce the size of executables. It highlights potential drawbacks such as increased RAM usage due to lack of memory sharing and debugger incompatibility.

```bash
upx your_application
```

--------------------------------

### Getting HWND of a wxWindow Object

Source: https://wxwidgets.org/docs/faq/windows

Illustrates how to retrieve the native Windows handle (HWND) from a wxWindow object, which is necessary for interfacing with Windows-specific APIs.

```cpp
HWND hwnd = static_cast<HWND>(myWindow->GetHWND());

```

--------------------------------

### Resolving wxWidgets Version Conflicts on macOS

Source: https://wxwidgets.org/docs/faq/osx

Guidance on handling conflicts between different installed versions of wxWidgets on macOS, particularly when an older system version interferes with development builds. Emphasizes using the full path to `wx-config`.

```bash
For most development work, this is not an issue. You can have many versions of wxWidgets on your computer at the same time without conflict. You will only encounter this problem if you try to install wxWidgets into /usr/local/bin.
Some versions of macOS install an older version of wxMac than the one you may be using for development. This can cause conflicts, such as link errors when building your applications. In this case, always ensure you are using the full path to `wx-config` in your project settings.
```

--------------------------------

### wxWidgets Quick Links

Source: https://wxwidgets.org/docs/tutorials/writing-online-help

A collection of quick links to essential wxWidgets resources, including tutorials, online documentation, community forums, bug reporting, the GitHub repository, and the development roadmap.

```en
Quick Links
  * [ Hello World in wxWidgets](https://docs.wxwidgets.org/latest/overview_helloworld.html "Hello World in wxWidgets")
  * [ Online Manual](https://docs.wxwidgets.org/3.2/ "Online Manual")
  * [ Community Wiki](https://wiki.wxwidgets.org/ "Community Wiki")
  * [ Report a Bug](https://github.com/wxWidgets/wxWidgets/issues/new "Report a Bug")
  * [ GitHub Repository](https://github.com/wxWidgets/wxWidgets "GitHub Repository")
  * [ Development Roadmap](https://wxwidgets.org/develop/roadmap/ "Development Roadmap")
```

--------------------------------

### Initialize and Display Help

Source: https://wxwidgets.org/docs/tutorials/writing-online-help

Demonstrates how to initialize a help controller, load a help file, and display its contents or a specific section. This is crucial for integrating help functionality into wxWidgets applications.

```cpp
helpController = new wxCHMHelpController;
helpController->Initialize("myfile");

helpController->LoadFile("myapp");
helpController->DisplayContents();

helpController->LoadFile("myapp");
helpController->DisplaySection("Diagram cards");

helpController->Quit();
delete helpController;
```

--------------------------------

### Intermediate wxWidgets Tutorial

Source: https://wxwidgets.org/docs/tutorials

A comprehensive tutorial covering intermediate wxWidgets topics such as menus, toolbars, layout, event handling, dialogs, controls, drag and drop, and device context drawing.

```C++
// In-depth tutorial covering menus, toolbars, layout, events, dialogs, controls, drag & drop, and drawing.
// ... actual code snippet would be here if available in the source text
```

--------------------------------

### wxWidgets Quick Links

Source: https://wxwidgets.org/docs/index

A curated list of frequently accessed links for wxWidgets users, covering essential topics like 'Hello World', online manuals, bug reporting, and the source code repository.

```APIDOC
Quick Links:
  - Hello World in wxWidgets: https://docs.wxwidgets.org/latest/overview_helloworld.html
  - Online Manual: https://docs.wxwidgets.org/3.2/
  - Community Wiki: https://wiki.wxwidgets.org/
  - Report a Bug: https://github.com/wxWidgets/wxWidgets/issues/new
  - GitHub Repository: https://github.com/wxWidgets/wxWidgets
  - Development Roadmap: https://wxwidgets.org/develop/roadmap/
```

--------------------------------

### wxStream Read Method Correction

Source: https://wxwidgets.org/docs/book/errata

Corrects a typo in a code example involving stream reading. The original code used `fileMsg.Read`, which should have been `file.Read`. This snippet shows the corrected method call.

```cpp
// Original: fileMsg.Read
// Corrected: file.Read
```

--------------------------------

### wxWidgets Quick Links

Source: https://wxwidgets.org/docs/faq

A collection of quick links to essential wxWidgets resources, including tutorials, documentation, and community platforms.

```wxWidgets
Hello World in wxWidgets
Online Manual
Community Wiki
Report a Bug
GitHub Repository
Development Roadmap
```

--------------------------------

### wxWidgets Introduction and Architecture

Source: https://wxwidgets.org/docs/book

Explains the purpose of wxWidgets, its history, community, licensing, and the architecture of its various ports.

```C++
// No specific code snippet available for this conceptual overview.
```

--------------------------------

### Porting from MFC

Source: https://wxwidgets.org/docs/book

Guidance on porting applications from MFC to wxWidgets, covering initialization, message maps, dialogs, documents/views, printing, and string handling.

```C++
MFC to wxWidgets Equivalents
Message Map Conversion
Resource Conversion
```

--------------------------------

### Resolving 'setup.h' Not Found Errors

Source: https://wxwidgets.org/docs/faq/windows

Explains how to configure include paths to resolve 'setup.h' not found errors during wxWidgets library builds. This typically involves adding the correct build output directory to the compiler's include path.

```cpp
// Example: Add to include path in your build system or IDE
// For Unicode Debug build: lib/vc_lib/mswud
// For Unicode Release build: lib/vc_lib/mswu

```

--------------------------------

### Building wxWidgets Applications

Source: https://wxwidgets.org/docs/book

Details on building applications using various compilers and IDEs across different platforms, including Microsoft Visual Studio, KDevelop, Xcode, and using makefiles and Bakefile.

```C++
wx-config
Bakefile
```

--------------------------------

### Building wxMac on macOS

Source: https://wxwidgets.org/docs/faq/osx

Steps to build the wxMac library on macOS using Xcode and the command line. This involves downloading Xcode, unpacking wxWidgets, compiling from the Terminal, and setting up an Xcode project.

```bash
First download and install the free Xcode IDE from Apple at <http://developer.apple.com>
Next download and unpack wxWidgets. Then follow the instructions in docs/osx/install.txt for compiling the libraries from a Terminal window. (In wxWidgets 2.8.x, this file is called docs/mac/install.txt.)
Try some of the samples and demos to see how well wxWidgets works on your Mac. Finally start your own Xcode project using the instructions in the wxWiki under [Guides & Tutorials](https://wiki.wxwidgets.org/Guides_%26_Tutorials)
```

--------------------------------

### wxWidgets Window Layout with Sizers

Source: https://wxwidgets.org/docs/book

Explains layout basics, introduces sizers, common sizer features, programming with sizers, dialog units, platform-adaptive layouts, and dynamic layouts.

```C++
// Example of using wxBoxSizer:
// wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
// sizer->Add(new wxButton(this, wxID_ANY, "Button 1"), 0, wxEXPAND | wxALL, 5);
// sizer->Add(new wxStaticText(this, wxID_ANY, "Label"), 0, wxALIGN_CENTER | wxALL, 5);
// this->SetSizer(sizer);
```

--------------------------------

### Corrected wxNotebook Page Addition

Source: https://wxwidgets.org/docs/book/errata

This correction updates the wxNotebook example by adding a `SetImageList` call, correcting the order of image list additions, and ensuring proper panel types and page addition parameters. It also fixes a missing comma in the last `AddPage` call.

```cpp
wxImageList *imageList = new wxImageList(16,16,true, 3);imageList->Add(wxIcon(copy_xpm));imageList->Add(wxIcon(cut_xpm));imageList->Add(wxIcon(paste_xpm));
notebook->SetImageList(imageList);

wxPanel *window1 = new wxPanel(notebook, wxID_ANY);
wxPanel *window2 = new wxPanel(notebook, wxID_ANY);
wxPanel *window3 = new wxPanel(notebook, wxID_ANY);

notebook->AddPage(window1, wxT("Tab One"), true,0);
notebook->AddPage(window2, wxT("Tab two"), false,1);
notebook->AddPage(window3, wxT("Tab three"), false,2);

```

--------------------------------

### wxWidgets Window Basics

Source: https://wxwidgets.org/docs/book

Explains core window features, common window classes (wxWindow, top-level, container), controls (static and non-static), menus, and control bars.

```C++
// Example of creating a wxWindow:
// wxWindow* parentWindow = new wxWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
// wxButton* button = new wxButton(parentWindow, wxID_OK, "Click Me");
```

--------------------------------

### Bitmap Preparation for Help Generation

Source: https://wxwidgets.org/docs/tutorials/writing-online-help

To ensure proper functioning of both HTML and WinHelp generation, it is recommended to prepare bitmaps in both GIF and BMP formats. These files should share the same root name. Additionally, an EPS image file is required for use with real LaTeX and dvips.

```en
Prepare any bitmaps in both GIF and BMP form (with the same root name) so HTML and WinHelp generation will work properly. An EPS image file is also required for use with real Latex and dvips.
```

--------------------------------

### Adding Application Icons in wxMac

Source: https://wxwidgets.org/docs/faq/osx

This guide explains the process of adding a custom application icon (.icns) to a wxMac application. It involves using macOS tools like icns editor, DeRez, and configuring CodeWarrior linker settings.

```cpp
// Include .r file with 'icns' resource with id (-16455)
// Linker:Output Flags/Finder Flags/Has Custom Icon
```

--------------------------------

### wxWidgets: Makefile Creation

Source: https://wxwidgets.org/docs/faq/common

Advises on creating a Unix makefile by adapting the `samples/minimal/makefile.unx` from the wxWidgets distribution, emphasizing the use of `wx-config`.

```makefile
# Example adaptation of makefile.unx

# Define compiler and flags
CXX = g++
CXXFLAGS = `wx-config --cxxflags` -Wall -Wextra

# Define linker flags
LDFLAGS = `wx-config --libs`

# Define source and object files
SRCS = main.cpp
OBJS = $(SRCS:.cpp=.o)

# Define the target executable
TARGET = myprogram

# Default target
all: $(TARGET)

$(TARGET): $(OBJS)
	$(CXX) $(OBJS) -o $(TARGET) $(LDFLAGS)

%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) $(TARGET)

```

--------------------------------

### Adding wxWidgets Class Documentation

Source: https://wxwidgets.org/docs/tutorials

Instructions for contributors on how to add documentation for wxWidgets classes to the official manual. It details the process and requirements for documentation contributions.

```APIDOC
Adding wxWidgets Class Documentation:
  - Purpose: To add documentation for a class to the official wxWidgets manual.
  - Target Audience: Developers wishing to contribute to the wxWidgets documentation.
  - Process: Follow the specified format and guidelines for documenting classes.
  - Location: Typically involves modifying files in the wxWidgets source repository's docs directory.
```

--------------------------------

### wxWidgets Standard Dialogs

Source: https://wxwidgets.org/docs/book

Covers informative dialogs (wxMessageBox, wxProgressDialog), file/directory dialogs (wxFileDialog), choice/selection dialogs (wxColourDialog, wxFontDialog), entry dialogs (wxTextEntryDialog, wxFindReplaceDialog), and printing dialogs (wxPageSetupDialog, wxPrintDialog).

```C++
// Example of showing a file dialog:
// wxFileDialog openFileDialog(this, "Open Text File", "", "", "Text files (*.txt)|*.txt", wxFD_OPEN | wxFD_FILE_MUST_EXIST);
// if (openFileDialog.ShowModal() == wxID_OK) {
//     wxString filePath = openFileDialog.GetPath();
//     // Process the selected file
// }
```

--------------------------------

### High DPI Support in wxWidgets

Source: https://wxwidgets.org/docs/faq/windows

Addresses blurry application appearance on High DPI displays. wxWidgets applications need to declare High DPI support. Refer to the official wxWidgets High DPI documentation and Microsoft's High DPI development guide for detailed information.

```markdown
See [High DPI Support in wxWidgets Overview](https://docs.wxwidgets.org/trunk/overview_high_dpi.html).
Read [Microsoft Windows High DPI Guide](https://docs.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows).
```

--------------------------------

### Submitting Patches to wxWidgets

Source: https://wxwidgets.org/docs/tutorials

This documentation explains the process of writing and submitting code patches to the wxWidgets project. It outlines the expected format and guidelines for contributions.

```APIDOC
How to Submit Patches:
  - Description: A description of how to write and submit patches to wxWidgets.
  - Guidelines: Follow project coding standards and provide clear commit messages.
  - Submission: Use the project's preferred method (e.g., GitHub pull requests).
```

--------------------------------

### wxWidgets Project Quick Links

Source: https://wxwidgets.org/docs/tutorials/using-mnemonics

A collection of essential links for navigating and contributing to the wxWidgets project, including tutorials, documentation, community resources, and development tools.

```text
* [ Hello World in wxWidgets](https://docs.wxwidgets.org/latest/overview_helloworld.html "Hello World in wxWidgets")
* [ Online Manual](https://docs.wxwidgets.org/3.2/ "Online Manual")
* [ Community Wiki](https://wiki.wxwidgets.org/ "Community Wiki")
* [ Report a Bug](https://github.com/wxWidgets/wxWidgets/issues/new "Report a Bug")
* [ GitHub Repository](https://github.com/wxWidgets/wxWidgets "GitHub Repository")
* [ Development Roadmap](https://wxwidgets.org/develop/roadmap/ "Development Roadmap")
```

--------------------------------

### wxWidgets Programming with Images

Source: https://wxwidgets.org/docs/book

Explains image classes (wxBitmap, wxIcon, wxCursor, wxImage), image lists, icon bundles, and customizing graphics with wxArtProvider.

```C++
// Example of loading and displaying a wxBitmap:
// wxBitmap bitmap("path/to/image.png", wxBITMAP_TYPE_PNG);
// wxStaticBitmap* staticBitmap = new wxStaticBitmap(this, wxID_ANY, bitmap);
// 
// // Example of using wxArtProvider:
// wxBitmap icon = wxArtProvider::GetBitmap(wxART_FOLDER, wxART_FRAME_ICON);
// wxStaticBitmap* folderIcon = new wxStaticBitmap(this, wxID_ANY, icon);
```

--------------------------------

### wxWidgets Distribution

Source: https://wxwidgets.org/docs/faq/general

wxWidgets can be downloaded from the official downloads page or obtained directly from the code repository.

```html
<a href="https://wxwidgets.org/downloads/">Download wxWidgets</a>
Check out sources directly from the <a href="https://wxwidgets.org/develop/code-repository/">code repository</a>.
```

--------------------------------

### wxWidgets Quick Links

Source: https://wxwidgets.org/docs/book/errata

A collection of essential links for wxWidgets users, providing access to tutorials, the official manual, community support, bug tracking, source code repository, and development plans.

```text
* [ Hello World in wxWidgets](https://docs.wxwidgets.org/latest/overview_helloworld.html "Hello World in wxWidgets")
* [ Online Manual](https://docs.wxwidgets.org/3.2/ "Online Manual")
* [ Community Wiki](https://wiki.wxwidgets.org/ "Community Wiki")
* [ Report a Bug](https://github.com/wxWidgets/wxWidgets/issues/new "Report a Bug")
* [ GitHub Repository](https://github.com/wxWidgets/wxWidgets "GitHub Repository")
* [ Development Roadmap](https://wxwidgets.org/develop/roadmap/ "Development Roadmap")
```

--------------------------------

### wxWidgets Development with Git

Source: https://wxwidgets.org/docs/faq/general

wxWidgets is developed and maintained using the Git version control system. This allows for efficient collaboration and updates. Instructions for building from Git are available in the README-GIT.md file.

```cpp
Development uses Git.
Source can be checked out from the code repository.
Build instructions are in README-GIT.md.
```

--------------------------------

### wxWidgets Other Resources

Source: https://wxwidgets.org/docs/index

A collection of supplementary resources for wxWidgets developers, including changelogs, platform support details, and community-contributed materials.

```APIDOC
Other Resources:
  - Changelog for the Latest Version: https://raw.githubusercontent.com/wxWidgets/wxWidgets/master/docs/changes.txt
  - Supported Platforms: https://wiki.wxwidgets.org/Supported_Platforms
  - Supported Classes by Platform: https://wiki.wxwidgets.org/Development:_Supported_Classes
  - Bahasa Indonesia Book on wxWidgets: https://github.com/nopri/publication/raw/master/id-wxwidgets.pdf (by Noprianto, GNU FDL licence)
  - wxGuide: http://wxguide.sf.net/
```

--------------------------------

### DialogBlocks Integration

Source: https://wxwidgets.org/docs/book

Introduction to DialogBlocks, its interface, creating projects, dialogs, frames, and application objects, along with debugging.

```C++
DialogBlocks
wxDialog
wxFrame
wxApp
```

--------------------------------

### wxWidgets Drawing and Printing

Source: https://wxwidgets.org/docs/book

Covers device context principles, drawing classes, buffered drawing, drawing tools, device context functions, the printing framework, and 3D graphics with wxGLCanvas.

```C++
// Example of using a wxDC for drawing:
// wxPaintDC dc(this);
// dc.DrawLine(10, 10, 100, 100);
// dc.DrawRectangle(50, 50, 80, 60);
```

--------------------------------

### wxWidgets Memory Management, Debugging, and Error Checking

Source: https://wxwidgets.org/docs/book

Provides guidance on creating/deleting objects, initialization, cleanup, detecting leaks, defensive programming, error reporting, RTTI, wxModule, dynamic libraries, exception handling, and debugging tips.

```C++
// Example of using wxMemoryDC for off-screen drawing:
// wxBitmap bitmap(100, 100);
// wxMemoryDC memDC(bitmap);
// memDC.DrawLine(0, 0, 100, 100);
// // Now bitmap contains the drawing
// 
// // Example of exception handling:
// try {
//     // Code that might throw an exception
// } catch (const wxException& e) {
//     // Handle exception
// }
```

--------------------------------

### Document/View Architecture

Source: https://wxwidgets.org/docs/book

Explains the document/view basics, creating frame, document, and view classes, using wxDocManager and wxDocTemplate, printing, and implementing undo/redo functionality.

```C++
wxDocument
wxView
wxDocManager
wxDocTemplate
wxFrame
wxWindow
```

--------------------------------

### Programming C++ GUIs with wxWidgets

Source: https://wxwidgets.org/docs/tutorials

An article detailing how to program C++ GUIs using the wxWidgets library. It highlights the ease of use and powerful classes provided by wxWidgets compared to platform-specific APIs.

```C++
// Example code demonstrating GUI programming with wxWidgets.
// Focuses on shortening programming time with powerful, simple classes.
// ... actual code snippet would be here if available in the source text
```

--------------------------------

### Using wxWidgets with OpenCV

Source: https://wxwidgets.org/docs/tutorials

A tutorial demonstrating how to integrate wxWidgets with the OpenCV library. It shows how to create a simple application that displays a camera's video stream within a wxWindow using OpenCV.

```C++
// Example code for integrating wxWidgets with OpenCV.
// Displays video stream from a camera in a wxWindow.
// Dependencies: wxWidgets, OpenCV
// ... actual code snippet would be here if available in the source text
```

--------------------------------

### wxWidgets Reference Manuals

Source: https://wxwidgets.org/docs/index

Provides access to the wxWidgets documentation, including the latest development version, stable releases, and older versions. These manuals detail the API and usage of the wxWidgets library.

```APIDOC
Reference Manuals:
  - 3.3 (Development) Manual: https://docs.wxwidgets.org/latest/
  - 3.2 (Stable) Manual: https://docs.wxwidgets.org/3.2/
  - 3.0 (Old Stable) Manual: https://docs.wxwidgets.org/3.0/
  - 2.8 (Ancient Stable) Manual: https://docs.wxwidgets.org/2.8/
```

--------------------------------

### wxWidgets Sizer Concepts

Source: https://wxwidgets.org/docs/tutorials

This tutorial explains the concepts behind wxWidgets sizers, which are used for layout management. It notes that the tutorial may not use the latest wxSizerFlags API but the core concepts remain relevant.

```C++
// Concepts related to wxWidgets sizers and layout management.
// Note: This tutorial does not use wxSizerFlags.
// ... actual code snippet would be here if available in the source text
```

--------------------------------

### MFC and wxWidgets Co-existence

Source: https://wxwidgets.org/docs/faq/windows

Discusses the possibility of integrating wxWidgets with existing MFC applications. While co-existence is demonstrated in samples, direct OLE-2 functionality enablement between MFC and wxWidgets might not be straightforward.

```markdown
There is a sample which demonstrates MFC and wxWidgets code co-existing in the same application. However, don’t expect to be able to enable wxWidgets windows with OLE-2 functionality using MFC.
```

--------------------------------

### wxWidgets Writing Multithreaded Applications

Source: https://wxwidgets.org/docs/book

Discusses when to use threads, using wxThread, thread creation/termination, synchronization objects (wxMutex, wxCriticalSection, wxCondition, wxSemaphore), deadlocks, and alternatives like wxTimer and idle time processing.

```C++
// Example of creating a wxThread:
// class MyThread : public wxThread {
// public:
//     MyThread() : wxThread(wxTHREAD_JOINABLE) {}
//     virtual ExitCode Entry();
// };
// 
// wxThread::ExitCode MyThread::Entry() {
//     // Thread's main work
//     return 0; // Exit code
// }
// 
// // In main thread:
// MyThread* thread = new MyThread();
// thread->Create();
// thread->Run();
// // thread->Wait(); // Optional: wait for thread to finish
```

--------------------------------

### wxWidgets Clipboard and Drag and Drop

Source: https://wxwidgets.org/docs/book

Covers data objects, data source/target duties, clipboard usage, implementing drag and drop sources and targets, and using wxDataObject and helpers.

```C++
// Example of setting data on the clipboard:
// wxClipboard& clipboard = wxGetGlobalClipboard();
// wxTextDataObject textData("Hello, Clipboard!");
// clipboard.Open();
// clipboard.SetData(&textData);
// clipboard.Close();
// 
// // Example of implementing a drop target:
// class MyDropTarget : public wxDropTarget {
// public:
//     MyDropTarget();
//     virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& data);
// };
// 
// MyDropTarget::MyDropTarget() : wxDropTarget(wxDF_TEXT) {}
// 
// bool MyDropTarget::OnDropText(wxCoord x, wxCoord y, const wxString& data) {
//     // Process dropped text data
//     return true;
// }
```

--------------------------------

### wxWidgets Follow Us

Source: https://wxwidgets.org/docs/index

Links to stay updated with wxWidgets news and development, including RSS feeds for news and the developer blog.

```APIDOC
Follow Us:
  - News RSS Feed: https://wxwidgets.org/atom.xml
  - Developer Blog: https://wxwidgets.org/blog/
```

--------------------------------

### wxWidgets Programming with wxSocket

Source: https://wxwidgets.org/docs/book

Focuses on using the wxSocket library for network programming, covering socket streams and related functionalities.

```C++
// Example of creating a wxSocketClient:
// wxSocketClient* client = new wxSocketClient();
// wxIPV4address addr;
// addr.Hostname("example.com");
// addr.Service(80);
// if (client->Connect(addr)) {
//     // Connected, now can send/receive data
//     client->Close();
// }
```

--------------------------------

### Ensuring Menu Hotkeys Work

Source: https://wxwidgets.org/docs/faq/windows

Offers solutions for non-functional menu hotkeys or shortcuts in wxWidgets applications. This often involves correctly handling keyboard events and ensuring proper menu item registration.

```cpp
// Ensure child windows call event.Skip() for unhandled EVT_CHAR events.
// Ensure submenus are appended to parent menus AFTER menu items are added.

```

--------------------------------

### wxWidgets Licensing

Source: https://wxwidgets.org/docs/faq/general

wxWidgets offers flexible licensing, allowing its use in both proprietary (commercial) and GPL-licensed projects without conflict. This section clarifies the terms.

```APIDOC
wxWidgets Licensing:

- **Proprietary Projects**: You can distribute proprietary binaries without distributing any source code.
- **GPL Projects**: wxWidgets does not conflict with GPL code you may be using or developing with it.
- **Conditions**: The conditions for using wxWidgets are the same for personal, academic, or commercial developers.
```

--------------------------------

### wxMac Standard Apple About Menu and Help Menu Support

Source: https://wxwidgets.org/docs/faq/osx

This section details how wxMac integrates with macOS standard menus. It explains the use of static variables within wxApp to manage the 'About' menu item and the 'Help' menu title and ID.

```objective-c
wxApp::s_macHelpMenuTitleName
wxApp::s_macAboutMenuItemID
```

--------------------------------

### wxWidgets Files and Streams

Source: https://wxwidgets.org/docs/book

Covers file handling classes like wxFile, wxFFile, wxTextFile, wxTempFile, wxDir, wxFileName, file functions, and various stream types (file, memory, string, socket, filter, zip, virtual file systems).

```C++
// Example of reading from a wxTextFile:
// wxTextFile file("my_file.txt");
// if (file.Open()) {
//     for (size_t i = 0; i < file.GetLineCount(); ++i) {
//         wxString line = file.GetLine(i);
//         // Process line
//     }
//     file.Close();
// }
// 
// // Example of using wxFileName:
// wxFileName fn("path/to/my_document.txt");
// wxString extension = fn.GetExt(); // "txt"
// wxString baseName = fn.GetName(); // "my_document"
```

--------------------------------

### Other wxWidgets Features

Source: https://wxwidgets.org/docs/book

Highlights additional features such as further window classes, ODBC, MIME types, multimedia, embedded web browsers, accessibility, OLE automation, and renderer classes.

```C++
wxODBC
wxHtmlWindow
wxAccessible
wxRenderer
```

--------------------------------

### wxWidgets: String Macro Usage

Source: https://wxwidgets.org/docs/faq/common

Provides pseudo-code for deciding when to use wxT(), _(), or no macro for string literals based on translation and Unicode requirements.

```cpp
if ( string should be translated )
    use _("string")
else if ( string should be in Unicode in Unicode build )
    use wxT("string")
else
    just use "string" normally

```

--------------------------------

### wxWidgets: Default Button Sizing Behavior

Source: https://wxwidgets.org/docs/faq/common

Demonstrates the default behavior where top-level windows resize their unique child to fill the client area, and the recommended solution using wxPanel.

```cpp
MyFrame::MyFrame() : wxFrame(NULL, wxID_ANY, "My Frame")
{
    auto button = new wxButton(this, wxID_ANY, "Hello, wxWidgets!",
                               wxPoint(10, 10), wxSize(80, 30));
}

```

```cpp
MyFrame::MyFrame() : wxFrame(NULL, wxID_ANY, "My Frame")
{
    auto panel = new wxPanel(this);
    auto button = new wxButton(panel, // Notice the change of parent.
                               wxID_ANY, "Hello, wxWidgets!",
                               wxPoint(10, 10), wxSize(80, 30));
}

```

--------------------------------

### wxWidgets Social Media and Feeds

Source: https://wxwidgets.org/docs/tutorials/writing-online-help

Links to follow wxWidgets for updates, including their News RSS Feed and Developer Blog.

```en
Follow Us
  * [ News RSS Feed](https://wxwidgets.org/atom.xml "News RSS Feed")
  * [ Developer Blog](https://wxwidgets.org/blog/ "Developer Blog")
```

--------------------------------

### Smart Preprocessing Errors in wxMac

Source: https://wxwidgets.org/docs/faq/osx

This snippet addresses a common warning during the smart preprocessing phase in wxMac development using Apple Developer Tools. It explains the cause of the warning and the fallback mechanism to basic preprocessing.

```cpp
cpp-precomp: warning: errors during smart preprocessing, retrying in basic mode
```

--------------------------------

### wxWidgets Follow Us

Source: https://wxwidgets.org/docs/faq

Links to follow wxWidgets for updates and news, including their RSS feed and developer blog.

```wxWidgets
News RSS Feed
Developer Blog
```

--------------------------------

### wxWidgets Platform Support and Features

Source: https://wxwidgets.org/docs/faq/general

wxWidgets aims for platform independence while allowing for platform-specific features. Some classes are unique to certain platforms but are wxWidgets-compatible. Generic, platform-independent code is also used for functionality missing on some platforms.

```cpp
Supports multiple platforms (see overview page).
Allows platform-specific classes (e.g., Windows metafiles).
Uses generic code for cross-platform functionality (e.g., wxTreeCtrl, wxListCtrl).
Not a 'lowest common denominator' approach.
```

--------------------------------

### wxWidgets Advanced Window Classes

Source: https://wxwidgets.org/docs/book

Details advanced controls like wxTreeCtrl, wxListCtrl, wxWizard, wxHtmlWindow, wxGrid, wxTaskBarIcon, and covers creating custom controls, defining events, and implementing validators.

```C++
// Example of creating a wxTreeCtrl:
// wxTreeCtrl* tree = new wxTreeCtrl(this, wxID_ANY);
// wxTreeItemId root = tree->AddRoot("Root Node");
// tree->AppendItem(root, "Child Node 1");
// tree->AppendItem(root, "Child Node 2");
// 
// // Example of creating a wxListCtrl:
// wxListCtrl* list = new wxListCtrl(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_REPORT);
// list->InsertColumn(0, "Column 1");
// list->InsertColumn(1, "Column 2");
// list->InsertItem(0, "Row 1, Col 1");
// list->SetItem(0, 1, "Row 1, Col 2");
```

--------------------------------

### wxWidgets X11 Compilation Requirements

Source: https://wxwidgets.org/docs/faq/x11

Details the necessary libraries for compiling wxWidgets with X11 support. For desktop use, X11 is sufficient. Embedded systems might use Tiny-X, with experimental support for Microwindows (Nano-X API).

```text
For desktop compilation, you only need X11 (not Xt, GTK+ or any other widget set). For embedded use, Tiny-X should work fine too. There is incomplete support for Microwindows (the Nano-X API).
```

--------------------------------

### Setting Focus for wxMac Applications

Source: https://wxwidgets.org/docs/faq/osx

This section clarifies why a wxMac application might not be able to set focus. It emphasizes the requirement to build macOS applications as bundles and points to sample makefiles and wiki resources for further details.

```cpp
# Building a MacOSX application bundle
https://wiki.wxwidgets.org/WxMac_Issues#Building_a_MacOSX_application_bundle
```

--------------------------------

### wxWidgets Motif Version Requirements

Source: https://wxwidgets.org/docs/faq/motif

Specifies the minimum required version of the Motif toolkit for use with wxWidgets and mentions a compatible free alternative.

```APIDOC
Motif Version Requirement:
  - Minimum version: 1.2 or above
  - Version 2.x is also compatible
  - Lesstif (free Motif clone) has been reported as working by some users.
  - Recommended: MetroLink Motif 1.2.4 (Linux version)
```

--------------------------------

### Application Manifest for Themed Controls

Source: https://wxwidgets.org/docs/faq/windows

Ensures wxWidgets controls use the modern Windows theme by including an application manifest. This is crucial for controls like buttons to not appear with the old "classic" look. The manifest is typically provided in `wx/msw/wx.rc` and should be included in your application's resource file.

```rc
#include "wx/msw/wx.rc"
```

--------------------------------

### wxWidgets X11 Missing/Partial Features

Source: https://wxwidgets.org/docs/faq/x11

Lists features and classes that are not yet implemented or have partial implementation in the wxWidgets X11 port. This includes specific controls and functionalities.

```text
The following classes and features are not yet implemented: wxSpinCtrl, wxSocket, wxToggleButton, clipboard classes, drag and drop classes, tooltips.
```

--------------------------------

### wxWidgets Writing International Applications

Source: https://wxwidgets.org/docs/book

Covers internationalization, translations, message catalogs, wxLocale, character encodings (Unicode), data conversion, help files, numbers, dates, and media for international applications.

```C++
// Example of initializing wxLocale:
// wxLocale locale(wxLANGUAGE_DEFAULT, wxLOCALE_CONVENT_ALL);
// if (!locale.IsOk()) {
//     // Handle initialization failure
// }
// 
// // Example of using _() for translations:
// wxString translated_text = _("Hello, World!");
```
Tokens:
Raw