repo_name
stringclasses 10
values | file_path
stringlengths 29
222
| content
stringlengths 24
926k
| extention
stringclasses 5
values |
|---|---|---|---|
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/helpwnd.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/helpwnd.h
// Purpose: wxHtmlHelpWindow
// Notes: Based on htmlhelp.cpp, implementing a monolithic
// HTML Help controller class, by Vaclav Slavik
// Author: Harm van der Heijden and Vaclav Slavik
// Copyright: (c) Harm van der Heijden and Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPWND_H_
#define _WX_HELPWND_H_
#include "wx/defs.h"
#if wxUSE_WXHTML_HELP
#include "wx/helpbase.h"
#include "wx/html/helpdata.h"
#include "wx/window.h"
#include "wx/frame.h"
#include "wx/config.h"
#include "wx/splitter.h"
#include "wx/notebook.h"
#include "wx/listbox.h"
#include "wx/choice.h"
#include "wx/combobox.h"
#include "wx/checkbox.h"
#include "wx/stattext.h"
#include "wx/hash.h"
#include "wx/html/htmlwin.h"
#include "wx/html/htmprint.h"
class WXDLLIMPEXP_FWD_CORE wxButton;
class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
class WXDLLIMPEXP_FWD_CORE wxTreeEvent;
class WXDLLIMPEXP_FWD_CORE wxTreeCtrl;
// style flags for the Help Frame
#define wxHF_TOOLBAR 0x0001
#define wxHF_CONTENTS 0x0002
#define wxHF_INDEX 0x0004
#define wxHF_SEARCH 0x0008
#define wxHF_BOOKMARKS 0x0010
#define wxHF_OPEN_FILES 0x0020
#define wxHF_PRINT 0x0040
#define wxHF_FLAT_TOOLBAR 0x0080
#define wxHF_MERGE_BOOKS 0x0100
#define wxHF_ICONS_BOOK 0x0200
#define wxHF_ICONS_BOOK_CHAPTER 0x0400
#define wxHF_ICONS_FOLDER 0x0000 // this is 0 since it is default
#define wxHF_DEFAULT_STYLE (wxHF_TOOLBAR | wxHF_CONTENTS | \
wxHF_INDEX | wxHF_SEARCH | \
wxHF_BOOKMARKS | wxHF_PRINT)
//compatibility:
#define wxHF_OPENFILES wxHF_OPEN_FILES
#define wxHF_FLATTOOLBAR wxHF_FLAT_TOOLBAR
#define wxHF_DEFAULTSTYLE wxHF_DEFAULT_STYLE
struct wxHtmlHelpFrameCfg
{
int x, y, w, h;
long sashpos;
bool navig_on;
};
struct wxHtmlHelpMergedIndexItem;
class wxHtmlHelpMergedIndex;
class WXDLLIMPEXP_FWD_CORE wxHelpControllerBase;
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpController;
/*!
* Help window
*/
class WXDLLIMPEXP_HTML wxHtmlHelpWindow : public wxWindow
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlHelpWindow);
public:
wxHtmlHelpWindow(wxHtmlHelpData* data = NULL) { Init(data); }
wxHtmlHelpWindow(wxWindow* parent, wxWindowID wxWindowID,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int style = wxTAB_TRAVERSAL|wxNO_BORDER,
int helpStyle = wxHF_DEFAULT_STYLE,
wxHtmlHelpData* data = NULL);
bool Create(wxWindow* parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int style = wxTAB_TRAVERSAL|wxNO_BORDER,
int helpStyle = wxHF_DEFAULT_STYLE);
virtual ~wxHtmlHelpWindow();
wxHtmlHelpData* GetData() { return m_Data; }
wxHtmlHelpController* GetController() const { return m_helpController; }
void SetController(wxHtmlHelpController* controller);
// Displays page x. If not found it will offect the user a choice of
// searching books.
// Looking for the page runs in these steps:
// 1. try to locate file named x (if x is for example "doc/howto.htm")
// 2. try to open starting page of book x
// 3. try to find x in contents (if x is for example "How To ...")
// 4. try to find x in index (if x is for example "How To ...")
bool Display(const wxString& x);
// Alternative version that works with numeric ID.
// (uses extension to MS format, <param name="ID" value=id>, see docs)
bool Display(int id);
// Displays help window and focuses contents.
bool DisplayContents();
// Displays help window and focuses index.
bool DisplayIndex();
// Searches for keyword. Returns true and display page if found, return
// false otherwise
// Syntax of keyword is Altavista-like:
// * words are separated by spaces
// (but "\"hello world\"" is only one world "hello world")
// * word may be pretended by + or -
// (+ : page must contain the word ; - : page can't contain the word)
// * if there is no + or - before the word, + is default
bool KeywordSearch(const wxString& keyword,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL);
#if wxUSE_CONFIG
void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString)
{
m_Config = config;
m_ConfigRoot = rootpath;
ReadCustomization(config, rootpath);
}
// Saves custom settings into cfg config. it will use the path 'path'
// if given, otherwise it will save info into currently selected path.
// saved values : things set by SetFonts, SetBorders.
void ReadCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
void WriteCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
#endif // wxUSE_CONFIG
// call this to let wxHtmlHelpWindow know page changed
void NotifyPageChanged();
// Refreshes Contents and Index tabs
void RefreshLists();
// Gets the HTML window
wxHtmlWindow* GetHtmlWindow() const { return m_HtmlWin; }
// Gets the splitter window
wxSplitterWindow* GetSplitterWindow() const { return m_Splitter; }
// Gets the toolbar
wxToolBar* GetToolBar() const { return m_toolBar; }
// Gets the configuration data
wxHtmlHelpFrameCfg& GetCfgData() { return m_Cfg; }
// Gets the tree control
wxTreeCtrl *GetTreeCtrl() const { return m_ContentsBox; }
protected:
void Init(wxHtmlHelpData* data = NULL);
// Adds items to m_Contents tree control
void CreateContents();
// Adds items to m_IndexList
void CreateIndex();
// Add books to search choice panel
void CreateSearch();
// Updates "merged index" structure that combines indexes of all books
// into better searchable structure
void UpdateMergedIndex();
// Add custom buttons to toolbar
virtual void AddToolbarButtons(wxToolBar *toolBar, int style);
// Displays options dialog (fonts etc.)
virtual void OptionsDialog();
void OnToolbar(wxCommandEvent& event);
void OnContentsSel(wxTreeEvent& event);
void OnIndexSel(wxCommandEvent& event);
void OnIndexFind(wxCommandEvent& event);
void OnIndexAll(wxCommandEvent& event);
void OnSearchSel(wxCommandEvent& event);
void OnSearch(wxCommandEvent& event);
void OnBookmarksSel(wxCommandEvent& event);
void OnSize(wxSizeEvent& event);
// Images:
enum {
IMG_Book = 0,
IMG_Folder,
IMG_Page
};
protected:
wxHtmlHelpData* m_Data;
bool m_DataCreated; // m_Data created by frame, or supplied?
wxString m_TitleFormat; // title of the help frame
// below are various pointers to GUI components
wxHtmlWindow *m_HtmlWin;
wxSplitterWindow *m_Splitter;
wxPanel *m_NavigPan;
wxNotebook *m_NavigNotebook;
wxTreeCtrl *m_ContentsBox;
wxTextCtrl *m_IndexText;
wxButton *m_IndexButton;
wxButton *m_IndexButtonAll;
wxListBox *m_IndexList;
wxTextCtrl *m_SearchText;
wxButton *m_SearchButton;
wxListBox *m_SearchList;
wxChoice *m_SearchChoice;
wxStaticText *m_IndexCountInfo;
wxCheckBox *m_SearchCaseSensitive;
wxCheckBox *m_SearchWholeWords;
wxToolBar* m_toolBar;
wxComboBox *m_Bookmarks;
wxArrayString m_BookmarksNames, m_BookmarksPages;
wxHtmlHelpFrameCfg m_Cfg;
#if wxUSE_CONFIG
wxConfigBase *m_Config;
wxString m_ConfigRoot;
#endif // wxUSE_CONFIG
// pagenumbers of controls in notebook (usually 0,1,2)
int m_ContentsPage;
int m_IndexPage;
int m_SearchPage;
// lists of available fonts (used in options dialog)
wxArrayString *m_NormalFonts, *m_FixedFonts;
int m_FontSize; // 0,1,2 = small,medium,big
wxString m_NormalFace, m_FixedFace;
bool m_UpdateContents;
#if wxUSE_PRINTING_ARCHITECTURE
wxHtmlEasyPrinting *m_Printer;
#endif
wxHashTable *m_PagesHash;
wxHtmlHelpController* m_helpController;
int m_hfStyle;
private:
void DoIndexFind();
void DoIndexAll();
void DisplayIndexItem(const wxHtmlHelpMergedIndexItem *it);
wxHtmlHelpMergedIndex *m_mergedIndex;
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxHtmlHelpWindow);
};
/*!
* Command IDs
*/
enum
{
//wxID_HTML_HELPFRAME = wxID_HIGHEST + 1,
wxID_HTML_PANEL = wxID_HIGHEST + 10,
wxID_HTML_BACK,
wxID_HTML_FORWARD,
wxID_HTML_UPNODE,
wxID_HTML_UP,
wxID_HTML_DOWN,
wxID_HTML_PRINT,
wxID_HTML_OPENFILE,
wxID_HTML_OPTIONS,
wxID_HTML_BOOKMARKSLIST,
wxID_HTML_BOOKMARKSADD,
wxID_HTML_BOOKMARKSREMOVE,
wxID_HTML_TREECTRL,
wxID_HTML_INDEXPAGE,
wxID_HTML_INDEXLIST,
wxID_HTML_INDEXTEXT,
wxID_HTML_INDEXBUTTON,
wxID_HTML_INDEXBUTTONALL,
wxID_HTML_NOTEBOOK,
wxID_HTML_SEARCHPAGE,
wxID_HTML_SEARCHTEXT,
wxID_HTML_SEARCHLIST,
wxID_HTML_SEARCHBUTTON,
wxID_HTML_SEARCHCHOICE,
wxID_HTML_COUNTINFO
};
#endif // wxUSE_WXHTML_HELP
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/htmldefs.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/htmldefs.h
// Purpose: constants for wxhtml library
// Author: Vaclav Slavik
// Copyright: (c) 1999 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HTMLDEFS_H_
#define _WX_HTMLDEFS_H_
#include "wx/defs.h"
#if wxUSE_HTML
//--------------------------------------------------------------------------------
// ALIGNMENTS
// Describes alignment of text etc. in containers
//--------------------------------------------------------------------------------
#define wxHTML_ALIGN_LEFT 0x0000
#define wxHTML_ALIGN_RIGHT 0x0002
#define wxHTML_ALIGN_JUSTIFY 0x0010
#define wxHTML_ALIGN_TOP 0x0004
#define wxHTML_ALIGN_BOTTOM 0x0008
#define wxHTML_ALIGN_CENTER 0x0001
//--------------------------------------------------------------------------------
// COLOR MODES
// Used by wxHtmlColourCell to determine clr of what is changing
//--------------------------------------------------------------------------------
#define wxHTML_CLR_FOREGROUND 0x0001
#define wxHTML_CLR_BACKGROUND 0x0002
#define wxHTML_CLR_TRANSPARENT_BACKGROUND 0x0004
//--------------------------------------------------------------------------------
// UNITS
// Used to specify units
//--------------------------------------------------------------------------------
#define wxHTML_UNITS_PIXELS 0x0001
#define wxHTML_UNITS_PERCENT 0x0002
//--------------------------------------------------------------------------------
// INDENTS
// Used to specify indetation relatives
//--------------------------------------------------------------------------------
#define wxHTML_INDENT_LEFT 0x0010
#define wxHTML_INDENT_RIGHT 0x0020
#define wxHTML_INDENT_TOP 0x0040
#define wxHTML_INDENT_BOTTOM 0x0080
#define wxHTML_INDENT_HORIZONTAL (wxHTML_INDENT_LEFT | wxHTML_INDENT_RIGHT)
#define wxHTML_INDENT_VERTICAL (wxHTML_INDENT_TOP | wxHTML_INDENT_BOTTOM)
#define wxHTML_INDENT_ALL (wxHTML_INDENT_VERTICAL | wxHTML_INDENT_HORIZONTAL)
//--------------------------------------------------------------------------------
// FIND CONDITIONS
// Identifiers of wxHtmlCell's Find() conditions
//--------------------------------------------------------------------------------
#define wxHTML_COND_ISANCHOR 1
// Finds the anchor of 'param' name (pointer to wxString).
#define wxHTML_COND_ISIMAGEMAP 2
// Finds imagemap of 'param' name (pointer to wxString).
// (used exclusively by m_image.cpp)
#define wxHTML_COND_USER 10000
// User-defined conditions should start from this number
//--------------------------------------------------------------------------------
// INTERNALS
// wxHTML internal constants
//--------------------------------------------------------------------------------
/* size of one scroll step of wxHtmlWindow in pixels */
#define wxHTML_SCROLL_STEP 16
/* size of temporary buffer used during parsing */
#define wxHTML_BUFLEN 1024
#endif // wxUSE_HTML
#endif // _WX_HTMLDEFS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/webkit.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/webkit.h
// Purpose: wxWebKitCtrl - embeddable web kit control
// Author: Jethro Grassie / Kevin Ollivier
// Modified by:
// Created: 2004-4-16
// Copyright: (c) Jethro Grassie / Kevin Ollivier
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WEBKIT_H
#define _WX_WEBKIT_H
#if wxUSE_WEBKIT
#if !defined(__WXMAC__)
#error "wxWebKitCtrl not implemented for this platform"
#endif
#include "wx/control.h"
// ----------------------------------------------------------------------------
// Web Kit Control
// ----------------------------------------------------------------------------
extern WXDLLIMPEXP_DATA_CORE(const char) wxWebKitCtrlNameStr[];
class WXDLLIMPEXP_CORE wxWebKitCtrl : public wxControl
{
public:
wxDECLARE_DYNAMIC_CLASS(wxWebKitCtrl);
wxWebKitCtrl() {}
wxWebKitCtrl(wxWindow *parent,
wxWindowID winID,
const wxString& strURL,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxWebKitCtrlNameStr)
{
Create(parent, winID, strURL, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID winID,
const wxString& strURL,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxWebKitCtrlNameStr);
virtual ~wxWebKitCtrl();
void LoadURL(const wxString &url);
bool CanGoBack();
bool CanGoForward();
bool GoBack();
bool GoForward();
void Reload();
void Stop();
bool CanGetPageSource();
wxString GetPageSource();
void SetPageSource(const wxString& source, const wxString& baseUrl = wxEmptyString);
wxString GetPageURL(){ return m_currentURL; }
void SetPageTitle(const wxString& title) { m_pageTitle = title; }
wxString GetPageTitle(){ return m_pageTitle; }
// since these worked in 2.6, add wrappers
void SetTitle(const wxString& title) { SetPageTitle(title); }
wxString GetTitle() { return GetPageTitle(); }
wxString GetSelection();
bool CanIncreaseTextSize();
void IncreaseTextSize();
bool CanDecreaseTextSize();
void DecreaseTextSize();
void Print(bool showPrompt = false);
void MakeEditable(bool enable = true);
bool IsEditable();
wxString RunScript(const wxString& javascript);
void SetScrollPos(int pos);
int GetScrollPos();
// don't hide base class virtuals
virtual void SetScrollPos( int orient, int pos, bool refresh = true ) wxOVERRIDE
{ return wxControl::SetScrollPos(orient, pos, refresh); }
virtual int GetScrollPos( int orient ) const wxOVERRIDE
{ return wxControl::GetScrollPos(orient); }
//we need to resize the webview when the control size changes
void OnSize(wxSizeEvent &event);
void OnMove(wxMoveEvent &event);
void OnMouseEvents(wxMouseEvent &event);
protected:
wxDECLARE_EVENT_TABLE();
void MacVisibilityChanged() wxOVERRIDE;
private:
wxWindow *m_parent;
wxWindowID m_windowID;
wxString m_currentURL;
wxString m_pageTitle;
OSXWebViewPtr m_webView;
WX_NSObject m_frameLoadMonitor;
WX_NSObject m_policyDelegate;
WX_NSObject m_UIDelegate;
// we may use this later to setup our own mouse events,
// so leave it in for now.
void* m_webKitCtrlEventHandler;
};
// ----------------------------------------------------------------------------
// Web Kit Events
// ----------------------------------------------------------------------------
enum {
wxWEBKIT_STATE_START = 1,
wxWEBKIT_STATE_NEGOTIATING = 2,
wxWEBKIT_STATE_REDIRECTING = 4,
wxWEBKIT_STATE_TRANSFERRING = 8,
wxWEBKIT_STATE_STOP = 16,
wxWEBKIT_STATE_FAILED = 32
};
enum {
wxWEBKIT_NAV_LINK_CLICKED = 1,
wxWEBKIT_NAV_BACK_NEXT = 2,
wxWEBKIT_NAV_FORM_SUBMITTED = 4,
wxWEBKIT_NAV_RELOAD = 8,
wxWEBKIT_NAV_FORM_RESUBMITTED = 16,
wxWEBKIT_NAV_OTHER = 32
};
class WXDLLIMPEXP_CORE wxWebKitBeforeLoadEvent : public wxCommandEvent
{
wxDECLARE_DYNAMIC_CLASS(wxWebKitBeforeLoadEvent);
public:
bool IsCancelled() { return m_cancelled; }
void Cancel(bool cancel = true) { m_cancelled = cancel; }
wxString GetURL() { return m_url; }
void SetURL(const wxString& url) { m_url = url; }
void SetNavigationType(int navType) { m_navType = navType; }
int GetNavigationType() { return m_navType; }
wxWebKitBeforeLoadEvent( wxWindow* win = NULL );
wxEvent *Clone(void) const { return new wxWebKitBeforeLoadEvent(*this); }
protected:
bool m_cancelled;
wxString m_url;
int m_navType;
};
class WXDLLIMPEXP_CORE wxWebKitStateChangedEvent : public wxCommandEvent
{
wxDECLARE_DYNAMIC_CLASS(wxWebKitStateChangedEvent);
public:
int GetState() { return m_state; }
void SetState(int state) { m_state = state; }
wxString GetURL() { return m_url; }
void SetURL(const wxString& url) { m_url = url; }
wxWebKitStateChangedEvent( wxWindow* win = NULL );
wxEvent *Clone(void) const { return new wxWebKitStateChangedEvent(*this); }
protected:
int m_state;
wxString m_url;
};
class WXDLLIMPEXP_CORE wxWebKitNewWindowEvent : public wxCommandEvent
{
wxDECLARE_DYNAMIC_CLASS(wxWebKitNewWindowEvent);
public:
wxString GetURL() const { return m_url; }
void SetURL(const wxString& url) { m_url = url; }
wxString GetTargetName() const { return m_targetName; }
void SetTargetName(const wxString& name) { m_targetName = name; }
wxWebKitNewWindowEvent( wxWindow* win = (wxWindow*)(NULL));
wxEvent *Clone(void) const { return new wxWebKitNewWindowEvent(*this); }
private:
wxString m_url;
wxString m_targetName;
};
typedef void (wxEvtHandler::*wxWebKitStateChangedEventFunction)(wxWebKitStateChangedEvent&);
typedef void (wxEvtHandler::*wxWebKitBeforeLoadEventFunction)(wxWebKitBeforeLoadEvent&);
typedef void (wxEvtHandler::*wxWebKitNewWindowEventFunction)(wxWebKitNewWindowEvent&);
#define wxWebKitStateChangedEventHandler( func ) \
wxEVENT_HANDLER_CAST( wxWebKitStateChangedEventFunction, func )
#define wxWebKitBeforeLoadEventHandler( func ) \
wxEVENT_HANDLER_CAST( wxWebKitBeforeLoadEventFunction, func )
#define wxWebKitNewWindowEventHandler( func ) \
wxEVENT_HANDLER_CAST( wxWebKitNewWindowEventFunction, func )
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_WEBKIT_STATE_CHANGED, wxWebKitStateChangedEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_WEBKIT_BEFORE_LOAD, wxWebKitBeforeLoadEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_WEBKIT_NEW_WINDOW, wxWebKitNewWindowEvent );
#define EVT_WEBKIT_STATE_CHANGED(func) \
wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_WEBKIT_STATE_CHANGED, \
wxID_ANY, \
wxID_ANY, \
wxWebKitStateChangedEventHandler( func ), \
NULL ),
#define EVT_WEBKIT_BEFORE_LOAD(func) \
wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_WEBKIT_BEFORE_LOAD, \
wxID_ANY, \
wxID_ANY, \
wxWebKitBeforeLoadEventHandler( func ), \
NULL ),
#define EVT_WEBKIT_NEW_WINDOW(func) \
wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_WEBKIT_NEW_WINDOW, \
wxID_ANY, \
wxID_ANY, \
wxWebKitNewWindowEventHandler( func ), \
NULL ),
#endif // wxUSE_WEBKIT
#endif
// _WX_WEBKIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/m_templ.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/m_templ.h
// Purpose: Modules template file
// Author: Vaclav Slavik
// Copyright: (c) Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*
DESCRIPTION:
This is set of macros for easier writing of tag handlers. How to use it?
See mod_fonts.cpp for example...
Attention! This is quite strange C++ bastard. Before using it,
I STRONGLY recommend reading and understanding these macros!!
*/
#ifndef _WX_M_TEMPL_H_
#define _WX_M_TEMPL_H_
#include "wx/defs.h"
#if wxUSE_HTML
#include "wx/html/winpars.h"
#define TAG_HANDLER_BEGIN(name,tags) \
class wxHTML_Handler_##name : public wxHtmlWinTagHandler \
{ \
public: \
wxString GetSupportedTags() wxOVERRIDE {return wxT(tags);}
#define TAG_HANDLER_VARS \
private:
#define TAG_HANDLER_CONSTR(name) \
public: \
wxHTML_Handler_##name () : wxHtmlWinTagHandler()
#define TAG_HANDLER_PROC(varib) \
public: \
bool HandleTag(const wxHtmlTag& varib) wxOVERRIDE
#define TAG_HANDLER_END(name) \
};
#define TAGS_MODULE_BEGIN(name) \
class wxHTML_Module##name : public wxHtmlTagsModule \
{ \
wxDECLARE_DYNAMIC_CLASS(wxHTML_Module##name ); \
public: \
void FillHandlersTable(wxHtmlWinParser *parser) wxOVERRIDE \
{
#define TAGS_MODULE_ADD(handler) \
parser->AddTagHandler(new wxHTML_Handler_##handler);
#define TAGS_MODULE_END(name) \
} \
}; \
wxIMPLEMENT_DYNAMIC_CLASS(wxHTML_Module##name , wxHtmlTagsModule)
#endif
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/helpdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/helpdlg.h
// Purpose: wxHtmlHelpDialog
// Notes: Based on htmlhelp.cpp, implementing a monolithic
// HTML Help controller class, by Vaclav Slavik
// Author: Harm van der Heijden, Vaclav Slavik, Julian Smart
// Copyright: (c) Harm van der Heijden, Vaclav Slavik, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPDLG_H_
#define _WX_HELPDLG_H_
#include "wx/defs.h"
#if wxUSE_WXHTML_HELP
#include "wx/html/helpdata.h"
#include "wx/window.h"
#include "wx/dialog.h"
#include "wx/frame.h"
#include "wx/config.h"
#include "wx/splitter.h"
#include "wx/notebook.h"
#include "wx/listbox.h"
#include "wx/choice.h"
#include "wx/combobox.h"
#include "wx/checkbox.h"
#include "wx/stattext.h"
#include "wx/html/htmlwin.h"
#include "wx/html/helpwnd.h"
#include "wx/html/htmprint.h"
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpController;
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpWindow;
class WXDLLIMPEXP_HTML wxHtmlHelpDialog : public wxDialog
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlHelpDialog);
public:
wxHtmlHelpDialog(wxHtmlHelpData* data = NULL) { Init(data); }
wxHtmlHelpDialog(wxWindow* parent, wxWindowID wxWindowID,
const wxString& title = wxEmptyString,
int style = wxHF_DEFAULT_STYLE, wxHtmlHelpData* data = NULL);
virtual ~wxHtmlHelpDialog();
bool Create(wxWindow* parent, wxWindowID id, const wxString& title = wxEmptyString,
int style = wxHF_DEFAULT_STYLE);
/// Returns the data associated with this dialog.
wxHtmlHelpData* GetData() { return m_Data; }
/// Returns the controller that created this dialog.
wxHtmlHelpController* GetController() const { return m_helpController; }
/// Sets the controller associated with this dialog.
void SetController(wxHtmlHelpController* controller) { m_helpController = controller; }
/// Returns the help window.
wxHtmlHelpWindow* GetHelpWindow() const { return m_HtmlHelpWin; }
// Sets format of title of the frame. Must contain exactly one "%s"
// (for title of displayed HTML page)
void SetTitleFormat(const wxString& format);
// Override to add custom buttons to the toolbar
virtual void AddToolbarButtons(wxToolBar* WXUNUSED(toolBar), int WXUNUSED(style)) {}
protected:
void Init(wxHtmlHelpData* data = NULL);
void OnCloseWindow(wxCloseEvent& event);
protected:
// Temporary pointer to pass to window
wxHtmlHelpData* m_Data;
wxString m_TitleFormat; // title of the help frame
wxHtmlHelpWindow *m_HtmlHelpWin;
wxHtmlHelpController* m_helpController;
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxHtmlHelpDialog);
};
#endif
// wxUSE_WXHTML_HELP
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/htmprint.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/htmprint.h
// Purpose: html printing classes
// Author: Vaclav Slavik
// Created: 25/09/99
// Copyright: (c) Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HTMPRINT_H_
#define _WX_HTMPRINT_H_
#include "wx/defs.h"
#if wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE
#include "wx/html/htmlcell.h"
#include "wx/html/winpars.h"
#include "wx/html/htmlfilt.h"
#include "wx/print.h"
#include "wx/printdlg.h"
#include "wx/vector.h"
#include <limits.h> // INT_MAX
//--------------------------------------------------------------------------------
// wxHtmlDCRenderer
// This class is capable of rendering HTML into specified
// portion of DC
//--------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlDCRenderer : public wxObject
{
public:
wxHtmlDCRenderer();
virtual ~wxHtmlDCRenderer();
// Following 3 methods *must* be called before any call to Render:
// Assign DC to this render
void SetDC(wxDC *dc, double pixel_scale = 1.0)
{ SetDC(dc, pixel_scale, pixel_scale); }
void SetDC(wxDC *dc, double pixel_scale, double font_scale);
// Sets size of output rectangle, in pixels. Note that you *can't* change
// width of the rectangle between calls to Render! (You can freely change height.)
void SetSize(int width, int height);
// Sets the text to be displayed.
// Basepath is base directory (html string would be stored there if it was in
// file). It is used to determine path for loading images, for example.
// isdir is false if basepath is filename, true if it is directory name
// (see wxFileSystem for detailed explanation)
void SetHtmlText(const wxString& html, const wxString& basepath = wxEmptyString, bool isdir = true);
// Sets the HTML cell that will be rendered: this is more efficient than
// using text as it allows to parse it only once. Note that the cell will
// be modified by this call.
void SetHtmlCell(wxHtmlContainerCell& cell);
// Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
void SetFonts(const wxString& normal_face, const wxString& fixed_face, const int *sizes = NULL);
// Sets font sizes to be relative to the given size or the system
// default size; use either specified or default font
void SetStandardFonts(int size = -1,
const wxString& normal_face = wxEmptyString,
const wxString& fixed_face = wxEmptyString);
// Finds the next page break after the specified (vertical) position.
// Returns wxNOT_FOUND if passed in position is the last page break.
int FindNextPageBreak(int pos) const;
// [x,y] is position of upper-left corner of printing rectangle (see SetSize)
// from is y-coordinate of the very first visible cell
// to is y-coordinate of the next following page break, if any
void Render(int x, int y, int from = 0, int to = INT_MAX);
// returns total width of the html document
int GetTotalWidth() const;
// returns total height of the html document
int GetTotalHeight() const;
private:
void DoSetHtmlCell(wxHtmlContainerCell* cell);
wxDC *m_DC;
wxFileSystem m_FS;
wxHtmlWinParser m_Parser;
wxHtmlContainerCell *m_Cells;
int m_Width, m_Height;
bool m_ownsCells;
wxDECLARE_NO_COPY_CLASS(wxHtmlDCRenderer);
};
enum {
wxPAGE_ODD,
wxPAGE_EVEN,
wxPAGE_ALL
};
//--------------------------------------------------------------------------------
// wxHtmlPrintout
// This class is derived from standard wxWidgets printout class
// and is used to print HTML documents.
//--------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlPrintout : public wxPrintout
{
public:
wxHtmlPrintout(const wxString& title = wxT("Printout"));
void SetHtmlText(const wxString& html, const wxString &basepath = wxEmptyString, bool isdir = true);
// prepares the class for printing this html document.
// Must be called before using the class, in fact just after constructor
//
// basepath is base directory (html string would be stored there if it was in
// file). It is used to determine path for loading images, for example.
// isdir is false if basepath is filename, true if it is directory name
// (see wxFileSystem for detailed explanation)
void SetHtmlFile(const wxString &htmlfile);
// same as SetHtmlText except that it takes regular file as the parameter
void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
// sets header/footer for the document. The argument is interpreted as HTML document.
// You can use macros in it:
// @PAGENUM@ is replaced by page number
// @PAGESCNT@ is replaced by total number of pages
//
// pg is one of wxPAGE_ODD, wxPAGE_EVEN and wx_PAGE_ALL constants.
// You can set different header/footer for odd and even pages
// Sets fonts to be used when displaying HTML page. (if size null then default sizes used).
void SetFonts(const wxString& normal_face, const wxString& fixed_face, const int *sizes = NULL);
// Sets font sizes to be relative to the given size or the system
// default size; use either specified or default font
void SetStandardFonts(int size = -1,
const wxString& normal_face = wxEmptyString,
const wxString& fixed_face = wxEmptyString);
void SetMargins(float top = 25.2f, float bottom = 25.2f, float left = 25.2f, float right = 25.2f,
float spaces = 5);
// sets margins in millimeters. Defaults to 1 inch for margins and 0.5cm for space
// between text and header and/or footer
void SetMargins(const wxPageSetupDialogData& pageSetupData);
// wxPrintout stuff:
bool OnPrintPage(int page) wxOVERRIDE;
bool HasPage(int page) wxOVERRIDE;
void GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo) wxOVERRIDE;
bool OnBeginDocument(int startPage, int endPage) wxOVERRIDE;
void OnPreparePrinting() wxOVERRIDE;
// Adds input filter
static void AddFilter(wxHtmlFilter *filter);
// Cleanup
static void CleanUpStatics();
private:
// this function is called by the base class OnPreparePrinting()
// implementation and by default checks whether the document fits into
// pageArea horizontally and warns the user if it does not and, if we're
// going to print and not just to preview the document, giving him the
// possibility to cancel printing
//
// you may override it to either suppress this check if truncation of the
// HTML being printed is acceptable or, on the contrary, add more checks to
// it, e.g. for the fit in the vertical direction if the document should
// always appear on a single page
//
// return true if printing should go ahead or false to cancel it (the
// return value is ignored when previewing)
virtual bool CheckFit(const wxSize& pageArea, const wxSize& docArea) const;
void RenderPage(wxDC *dc, int page);
// renders one page into dc
wxString TranslateHeader(const wxString& instr, int page);
// substitute @PAGENUM@ and @PAGESCNT@ by real values
void CountPages();
// fills m_PageBreaks, which indirectly gives the number of pages
private:
wxVector<int> m_PageBreaks;
wxString m_Document, m_BasePath;
bool m_BasePathIsDir;
wxString m_Headers[2], m_Footers[2];
int m_HeaderHeight, m_FooterHeight;
wxHtmlDCRenderer m_Renderer, m_RendererHdr;
float m_MarginTop, m_MarginBottom, m_MarginLeft, m_MarginRight, m_MarginSpace;
// list of HTML filters
static wxVector<wxHtmlFilter*> m_Filters;
wxDECLARE_NO_COPY_CLASS(wxHtmlPrintout);
};
//--------------------------------------------------------------------------------
// wxHtmlEasyPrinting
// This class provides very simple interface to printing
// architecture. It allows you to print HTML documents only
// with very few commands.
//
// Note : do not create this class on stack only.
// You should create an instance on app startup and
// use this instance for all printing. Why? The class
// stores page&printer settings in it.
//--------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlEasyPrinting : public wxObject
{
public:
wxHtmlEasyPrinting(const wxString& name = wxT("Printing"), wxWindow *parentWindow = NULL);
virtual ~wxHtmlEasyPrinting();
bool PreviewFile(const wxString &htmlfile);
bool PreviewText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
// Preview file / html-text for printing
// (and offers printing)
// basepath is base directory for opening subsequent files (e.g. from <img> tag)
bool PrintFile(const wxString &htmlfile);
bool PrintText(const wxString &htmltext, const wxString& basepath = wxEmptyString);
// Print file / html-text w/o preview
void PageSetup();
// pop up printer or page setup dialog
void SetHeader(const wxString& header, int pg = wxPAGE_ALL);
void SetFooter(const wxString& footer, int pg = wxPAGE_ALL);
// sets header/footer for the document. The argument is interpreted as HTML document.
// You can use macros in it:
// @PAGENUM@ is replaced by page number
// @PAGESCNT@ is replaced by total number of pages
//
// pg is one of wxPAGE_ODD, wxPAGE_EVEN and wx_PAGE_ALL constants.
// You can set different header/footer for odd and even pages
void SetFonts(const wxString& normal_face, const wxString& fixed_face, const int *sizes = 0);
// Sets fonts to be used when displaying HTML page. (if size null then default sizes used)
// Sets font sizes to be relative to the given size or the system
// default size; use either specified or default font
void SetStandardFonts(int size = -1,
const wxString& normal_face = wxEmptyString,
const wxString& fixed_face = wxEmptyString);
wxPrintData *GetPrintData();
wxPageSetupDialogData *GetPageSetupData() {return m_PageSetupData;}
// return page setting data objects.
// (You can set their parameters.)
wxWindow* GetParentWindow() const { return m_ParentWindow; }
// get the parent window
void SetParentWindow(wxWindow* window) { m_ParentWindow = window; }
// set the parent window
const wxString& GetName() const { return m_Name; }
// get the printout name
void SetName(const wxString& name) { m_Name = name; }
// set the printout name
// Controls showing the dialog when printing: by default, always shown.
enum PromptMode
{
Prompt_Never,
Prompt_Once,
Prompt_Always
};
void SetPromptMode(PromptMode promptMode) { m_promptMode = promptMode; }
protected:
virtual wxHtmlPrintout *CreatePrintout();
virtual bool DoPreview(wxHtmlPrintout *printout1, wxHtmlPrintout *printout2);
virtual bool DoPrint(wxHtmlPrintout *printout);
private:
wxPrintData *m_PrintData;
wxPageSetupDialogData *m_PageSetupData;
wxString m_Name;
int m_FontsSizesArr[7];
int *m_FontsSizes;
wxString m_FontFaceFixed, m_FontFaceNormal;
enum FontMode
{
FontMode_Explicit,
FontMode_Standard
};
FontMode m_fontMode;
wxString m_Headers[2], m_Footers[2];
wxWindow *m_ParentWindow;
PromptMode m_promptMode;
wxDECLARE_NO_COPY_CLASS(wxHtmlEasyPrinting);
};
#endif // wxUSE_HTML & wxUSE_PRINTING_ARCHITECTURE
#endif // _WX_HTMPRINT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/helpfrm.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/helpfrm.h
// Purpose: wxHtmlHelpFrame
// Notes: Based on htmlhelp.cpp, implementing a monolithic
// HTML Help controller class, by Vaclav Slavik
// Author: Harm van der Heijden and Vaclav Slavik
// Copyright: (c) Harm van der Heijden and Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPFRM_H_
#define _WX_HELPFRM_H_
#include "wx/defs.h"
#if wxUSE_WXHTML_HELP
#include "wx/helpbase.h"
#include "wx/html/helpdata.h"
#include "wx/window.h"
#include "wx/frame.h"
#include "wx/config.h"
#include "wx/splitter.h"
#include "wx/notebook.h"
#include "wx/listbox.h"
#include "wx/choice.h"
#include "wx/combobox.h"
#include "wx/checkbox.h"
#include "wx/stattext.h"
#include "wx/html/htmlwin.h"
#include "wx/html/helpwnd.h"
#include "wx/html/htmprint.h"
class WXDLLIMPEXP_FWD_CORE wxButton;
class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
class WXDLLIMPEXP_FWD_CORE wxTreeEvent;
class WXDLLIMPEXP_FWD_CORE wxTreeCtrl;
// style flags for the Help Frame
#define wxHF_TOOLBAR 0x0001
#define wxHF_CONTENTS 0x0002
#define wxHF_INDEX 0x0004
#define wxHF_SEARCH 0x0008
#define wxHF_BOOKMARKS 0x0010
#define wxHF_OPEN_FILES 0x0020
#define wxHF_PRINT 0x0040
#define wxHF_FLAT_TOOLBAR 0x0080
#define wxHF_MERGE_BOOKS 0x0100
#define wxHF_ICONS_BOOK 0x0200
#define wxHF_ICONS_BOOK_CHAPTER 0x0400
#define wxHF_ICONS_FOLDER 0x0000 // this is 0 since it is default
#define wxHF_DEFAULT_STYLE (wxHF_TOOLBAR | wxHF_CONTENTS | \
wxHF_INDEX | wxHF_SEARCH | \
wxHF_BOOKMARKS | wxHF_PRINT)
//compatibility:
#define wxHF_OPENFILES wxHF_OPEN_FILES
#define wxHF_FLATTOOLBAR wxHF_FLAT_TOOLBAR
#define wxHF_DEFAULTSTYLE wxHF_DEFAULT_STYLE
struct wxHtmlHelpMergedIndexItem;
class wxHtmlHelpMergedIndex;
class WXDLLIMPEXP_FWD_CORE wxHelpControllerBase;
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpController;
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpWindow;
class WXDLLIMPEXP_HTML wxHtmlHelpFrame : public wxFrame
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlHelpFrame);
public:
wxHtmlHelpFrame(wxHtmlHelpData* data = NULL) { Init(data); }
wxHtmlHelpFrame(wxWindow* parent, wxWindowID wxWindowID,
const wxString& title = wxEmptyString,
int style = wxHF_DEFAULT_STYLE, wxHtmlHelpData* data = NULL
#if wxUSE_CONFIG
, wxConfigBase *config=NULL, const wxString& rootpath = wxEmptyString
#endif // wxUSE_CONFIG
);
bool Create(wxWindow* parent, wxWindowID id, const wxString& title = wxEmptyString,
int style = wxHF_DEFAULT_STYLE
#if wxUSE_CONFIG
, wxConfigBase *config=NULL, const wxString& rootpath = wxEmptyString
#endif // wxUSE_CONFIG
);
virtual ~wxHtmlHelpFrame();
/// Returns the data associated with the window.
wxHtmlHelpData* GetData() { return m_Data; }
/// Returns the help controller associated with the window.
wxHtmlHelpController* GetController() const { return m_helpController; }
/// Sets the help controller associated with the window.
void SetController(wxHtmlHelpController* controller);
/// Returns the help window.
wxHtmlHelpWindow* GetHelpWindow() const { return m_HtmlHelpWin; }
// Sets format of title of the frame. Must contain exactly one "%s"
// (for title of displayed HTML page)
void SetTitleFormat(const wxString& format);
#if wxUSE_CONFIG
// For compatibility
void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString);
#endif // wxUSE_CONFIG
// Make the help controller's frame 'modal' if
// needed
void AddGrabIfNeeded();
// Override to add custom buttons to the toolbar
virtual void AddToolbarButtons(wxToolBar* WXUNUSED(toolBar), int WXUNUSED(style)) {}
void SetShouldPreventAppExit(bool enable);
// we don't want to prevent the app from closing just because a help window
// remains opened
virtual bool ShouldPreventAppExit() const wxOVERRIDE { return m_shouldPreventAppExit; }
protected:
void Init(wxHtmlHelpData* data = NULL);
void OnCloseWindow(wxCloseEvent& event);
void OnActivate(wxActivateEvent& event);
// Images:
enum {
IMG_Book = 0,
IMG_Folder,
IMG_Page
};
protected:
wxHtmlHelpData* m_Data;
bool m_DataCreated; // m_Data created by frame, or supplied?
wxString m_TitleFormat; // title of the help frame
wxHtmlHelpWindow *m_HtmlHelpWin;
wxHtmlHelpController* m_helpController;
bool m_shouldPreventAppExit;
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxHtmlHelpFrame);
};
#endif // wxUSE_WXHTML_HELP
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/htmlwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/htmlwin.h
// Purpose: wxHtmlWindow class for parsing & displaying HTML
// Author: Vaclav Slavik
// Copyright: (c) 1999 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HTMLWIN_H_
#define _WX_HTMLWIN_H_
#include "wx/defs.h"
#if wxUSE_HTML
#include "wx/window.h"
#include "wx/scrolwin.h"
#include "wx/config.h"
#include "wx/stopwatch.h"
#include "wx/html/winpars.h"
#include "wx/html/htmlcell.h"
#include "wx/filesys.h"
#include "wx/html/htmlfilt.h"
#include "wx/filename.h"
#include "wx/bitmap.h"
class wxHtmlProcessor;
class wxHtmlWinModule;
class wxHtmlHistoryArray;
class wxHtmlProcessorList;
class WXDLLIMPEXP_FWD_HTML wxHtmlWinAutoScrollTimer;
class WXDLLIMPEXP_FWD_HTML wxHtmlCellEvent;
class WXDLLIMPEXP_FWD_HTML wxHtmlLinkEvent;
class WXDLLIMPEXP_FWD_CORE wxStatusBar;
// wxHtmlWindow flags:
#define wxHW_SCROLLBAR_NEVER 0x0002
#define wxHW_SCROLLBAR_AUTO 0x0004
#define wxHW_NO_SELECTION 0x0008
#define wxHW_DEFAULT_STYLE wxHW_SCROLLBAR_AUTO
/// Enum for wxHtmlWindow::OnOpeningURL and wxHtmlWindowInterface::OnOpeningURL
enum wxHtmlOpeningStatus
{
/// Open the requested URL
wxHTML_OPEN,
/// Do not open the URL
wxHTML_BLOCK,
/// Redirect to another URL (returned from OnOpeningURL)
wxHTML_REDIRECT
};
/**
Abstract interface to a HTML rendering window (such as wxHtmlWindow or
wxHtmlListBox) that is passed to wxHtmlWinParser. It encapsulates all
communication from the parser to the window.
*/
class WXDLLIMPEXP_HTML wxHtmlWindowInterface
{
public:
/// Ctor
wxHtmlWindowInterface() {}
virtual ~wxHtmlWindowInterface() {}
/**
Called by the parser to set window's title to given text.
*/
virtual void SetHTMLWindowTitle(const wxString& title) = 0;
/**
Called when a link is clicked.
@param link information about the clicked link
*/
virtual void OnHTMLLinkClicked(const wxHtmlLinkInfo& link) = 0;
/**
Called when the parser needs to open another URL (e.g. an image).
@param type Type of the URL request (e.g. image)
@param url URL the parser wants to open
@param redirect If the return value is wxHTML_REDIRECT, then the
URL to redirect to will be stored in this variable
(the pointer must never be NULL)
@return indicator of how to treat the request
*/
virtual wxHtmlOpeningStatus OnHTMLOpeningURL(wxHtmlURLType type,
const wxString& url,
wxString *redirect) const = 0;
/**
Converts coordinates @a pos relative to given @a cell to
physical coordinates in the window.
*/
virtual wxPoint HTMLCoordsToWindow(wxHtmlCell *cell,
const wxPoint& pos) const = 0;
/// Returns the window used for rendering (may be NULL).
virtual wxWindow* GetHTMLWindow() = 0;
/// Returns background colour to use by default.
virtual wxColour GetHTMLBackgroundColour() const = 0;
/// Sets window's background to colour @a clr.
virtual void SetHTMLBackgroundColour(const wxColour& clr) = 0;
/// Sets window's background to given bitmap.
virtual void SetHTMLBackgroundImage(const wxBitmap& bmpBg) = 0;
/// Sets status bar text.
virtual void SetHTMLStatusText(const wxString& text) = 0;
/// Type of mouse cursor
enum HTMLCursor
{
/// Standard mouse cursor (typically an arrow)
HTMLCursor_Default,
/// Cursor shown over links
HTMLCursor_Link,
/// Cursor shown over selectable text
HTMLCursor_Text
};
/**
Returns mouse cursor of given @a type.
*/
virtual wxCursor GetHTMLCursor(HTMLCursor type) const = 0;
};
/**
Helper class that implements part of mouse handling for wxHtmlWindow and
wxHtmlListBox. Cursor changes and clicking on links are handled, text
selection is not.
*/
class WXDLLIMPEXP_HTML wxHtmlWindowMouseHelper
{
protected:
/**
Ctor.
@param iface Interface to the owner window.
*/
wxHtmlWindowMouseHelper(wxHtmlWindowInterface *iface);
/**
Virtual dtor.
It is not really needed in this case, but at least it prevents gcc from
complaining about its absence.
*/
virtual ~wxHtmlWindowMouseHelper() { }
/// Returns true if the mouse moved since the last call to HandleIdle
bool DidMouseMove() const { return m_tmpMouseMoved; }
/// Call this from EVT_MOTION event handler
void HandleMouseMoved();
/**
Call this from EVT_LEFT_UP handler (or, alternatively, EVT_LEFT_DOWN).
@param rootCell HTML cell inside which the click occurred. This doesn't
have to be the leaf cell, it can be e.g. toplevel
container, but the mouse must be inside the container's
area, otherwise the event would be ignored.
@param pos Mouse position in coordinates relative to @a cell
@param event The event that triggered the call
*/
bool HandleMouseClick(wxHtmlCell *rootCell,
const wxPoint& pos, const wxMouseEvent& event);
/**
Call this from OnInternalIdle of the HTML displaying window. Handles
mouse movements and must be used together with HandleMouseMoved.
@param rootCell HTML cell inside which the click occurred. This doesn't
have to be the leaf cell, it can be e.g. toplevel
container, but the mouse must be inside the container's
area, otherwise the event would be ignored.
@param pos Current mouse position in coordinates relative to
@a cell
*/
void HandleIdle(wxHtmlCell *rootCell, const wxPoint& pos);
/**
Called by HandleIdle when the mouse hovers over a cell. Default
behaviour is to do nothing.
@param cell the cell the mouse is over
@param x, y coordinates of mouse relative to the cell
*/
virtual void OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y);
/**
Called by HandleMouseClick when the user clicks on a cell.
Default behaviour is to call wxHtmlWindowInterface::OnLinkClicked()
if this cell corresponds to a hypertext link.
@param cell the cell the mouse is over
@param x, y coordinates of mouse relative to the cell
@param event The event that triggered the call
@return true if a link was clicked, false otherwise.
*/
virtual bool OnCellClicked(wxHtmlCell *cell,
wxCoord x, wxCoord y,
const wxMouseEvent& event);
protected:
// this flag indicates if the mouse moved (used by HandleIdle)
bool m_tmpMouseMoved;
// contains last link name
wxHtmlLinkInfo *m_tmpLastLink;
// contains the last (terminal) cell which contained the mouse
wxHtmlCell *m_tmpLastCell;
private:
wxHtmlWindowInterface *m_interface;
};
// ----------------------------------------------------------------------------
// wxHtmlWindow
// (This is probably the only class you will directly use.)
// Purpose of this class is to display HTML page (either local
// file or downloaded via HTTP protocol) in a window. Width of
// window is constant - given in constructor - virtual height
// is changed dynamically depending on page size. Once the
// window is created you can set its content by calling
// SetPage(text) or LoadPage(filename).
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlWindow : public wxScrolledWindow,
public wxHtmlWindowInterface,
public wxHtmlWindowMouseHelper
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlWindow);
friend class wxHtmlWinModule;
public:
wxHtmlWindow() : wxHtmlWindowMouseHelper(this) { Init(); }
wxHtmlWindow(wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHW_DEFAULT_STYLE,
const wxString& name = wxT("htmlWindow"))
: wxHtmlWindowMouseHelper(this)
{
Init();
Create(parent, id, pos, size, style, name);
}
virtual ~wxHtmlWindow();
bool Create(wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHW_SCROLLBAR_AUTO,
const wxString& name = wxT("htmlWindow"));
// Set HTML page and display it. !! source is HTML document itself,
// it is NOT address/filename of HTML document. If you want to
// specify document location, use LoadPage() istead
// Return value : false if an error occurred, true otherwise
virtual bool SetPage(const wxString& source);
// Append to current page
bool AppendToPage(const wxString& source);
// Load HTML page from given location. Location can be either
// a) /usr/wxGTK2/docs/html/wx.htm
// b) http://www.somewhere.uk/document.htm
// c) ftp://ftp.somesite.cz/pub/something.htm
// In case there is no prefix (http:,ftp:), the method
// will try to find it itself (1. local file, then http or ftp)
// After the page is loaded, the method calls SetPage() to display it.
// Note : you can also use path relative to previously loaded page
// Return value : same as SetPage
virtual bool LoadPage(const wxString& location);
// Loads HTML page from file
bool LoadFile(const wxFileName& filename);
// Returns full location of opened page
wxString GetOpenedPage() const {return m_OpenedPage;}
// Returns anchor within opened page
wxString GetOpenedAnchor() const {return m_OpenedAnchor;}
// Returns <TITLE> of opened page or empty string otherwise
wxString GetOpenedPageTitle() const {return m_OpenedPageTitle;}
// Sets frame in which page title will be displayed. Format is format of
// frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s
void SetRelatedFrame(wxFrame* frame, const wxString& format);
wxFrame* GetRelatedFrame() const {return m_RelatedFrame;}
#if wxUSE_STATUSBAR
// After(!) calling SetRelatedFrame, this sets statusbar slot where messages
// will be displayed. Default is -1 = no messages.
void SetRelatedStatusBar(int index);
void SetRelatedStatusBar(wxStatusBar*, int index = 0);
#endif // wxUSE_STATUSBAR
// Sets fonts to be used when displaying HTML page.
void SetFonts(const wxString& normal_face, const wxString& fixed_face,
const int *sizes = NULL);
// Sets font sizes to be relative to the given size or the system
// default size; use either specified or default font
void SetStandardFonts(int size = -1,
const wxString& normal_face = wxEmptyString,
const wxString& fixed_face = wxEmptyString);
// Sets space between text and window borders.
void SetBorders(int b) {m_Borders = b;}
// Sets the bitmap to use for background (currnetly it will be tiled,
// when/if we have CSS support we could add other possibilities...)
void SetBackgroundImage(const wxBitmap& bmpBg) { m_bmpBg = bmpBg; }
#if wxUSE_CONFIG
// Saves custom settings into cfg config. it will use the path 'path'
// if given, otherwise it will save info into currently selected path.
// saved values : things set by SetFonts, SetBorders.
virtual void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
// ...
virtual void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString);
#endif // wxUSE_CONFIG
// Goes to previous/next page (in browsing history)
// Returns true if successful, false otherwise
bool HistoryBack();
bool HistoryForward();
bool HistoryCanBack();
bool HistoryCanForward();
// Resets history
void HistoryClear();
// Returns pointer to conteiners/cells structure.
// It should be used ONLY when printing
wxHtmlContainerCell* GetInternalRepresentation() const {return m_Cell;}
// Adds input filter
static void AddFilter(wxHtmlFilter *filter);
// Returns a pointer to the parser.
wxHtmlWinParser *GetParser() const { return m_Parser; }
// Adds HTML processor to this instance of wxHtmlWindow:
void AddProcessor(wxHtmlProcessor *processor);
// Adds HTML processor to wxHtmlWindow class as whole:
static void AddGlobalProcessor(wxHtmlProcessor *processor);
// -- Callbacks --
// Sets the title of the window
// (depending on the information passed to SetRelatedFrame() method)
virtual void OnSetTitle(const wxString& title);
// Called when user clicked on hypertext link. Default behaviour is to
// call LoadPage(loc)
virtual void OnLinkClicked(const wxHtmlLinkInfo& link);
// Called when wxHtmlWindow wants to fetch data from an URL (e.g. when
// loading a page or loading an image). The data are downloaded if and only if
// OnOpeningURL returns true. If OnOpeningURL returns wxHTML_REDIRECT,
// it must set *redirect to the new URL
virtual wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType WXUNUSED(type),
const wxString& WXUNUSED(url),
wxString *WXUNUSED(redirect)) const
{ return wxHTML_OPEN; }
#if wxUSE_CLIPBOARD
// Helper functions to select parts of page:
void SelectWord(const wxPoint& pos);
void SelectLine(const wxPoint& pos);
void SelectAll();
// Convert selection to text:
wxString SelectionToText() { return DoSelectionToText(m_selection); }
// Converts current page to text:
wxString ToText();
#endif // wxUSE_CLIPBOARD
virtual void OnInternalIdle() wxOVERRIDE;
/// Returns standard HTML cursor as used by wxHtmlWindow
static wxCursor GetDefaultHTMLCursor(HTMLCursor type);
static void SetDefaultHTMLCursor(HTMLCursor type, const wxCursor& cursor);
protected:
void Init();
// Scrolls to anchor of this name. (Anchor is #news
// or #features etc. it is part of address sometimes:
// http://www.ms.mff.cuni.cz/~vsla8348/wxhtml/index.html#news)
// Return value : true if anchor exists, false otherwise
bool ScrollToAnchor(const wxString& anchor);
// Prepares layout (= fill m_PosX, m_PosY for fragments) based on
// actual size of window. This method also setup scrollbars
void CreateLayout();
void OnPaint(wxPaintEvent& event);
void OnEraseBackground(wxEraseEvent& event);
void OnSize(wxSizeEvent& event);
void OnMouseMove(wxMouseEvent& event);
void OnMouseDown(wxMouseEvent& event);
void OnMouseUp(wxMouseEvent& event);
#if wxUSE_CLIPBOARD
void OnKeyUp(wxKeyEvent& event);
void OnDoubleClick(wxMouseEvent& event);
void OnCopy(wxCommandEvent& event);
void OnClipboardEvent(wxClipboardTextEvent& event);
void OnMouseEnter(wxMouseEvent& event);
void OnMouseLeave(wxMouseEvent& event);
void OnMouseCaptureLost(wxMouseCaptureLostEvent& event);
#endif // wxUSE_CLIPBOARD
// Returns new filter (will be stored into m_DefaultFilter variable)
virtual wxHtmlFilter *GetDefaultFilter() {return new wxHtmlFilterPlainText;}
// cleans static variables
static void CleanUpStatics();
// Returns true if text selection is enabled (wxClipboard must be available
// and wxHW_NO_SELECTION not used)
bool IsSelectionEnabled() const;
enum ClipboardType
{
Primary,
Secondary
};
// Copies selection to clipboard if the clipboard support is available
//
// returns true if anything was copied to clipboard, false otherwise
bool CopySelection(ClipboardType t = Secondary);
#if wxUSE_CLIPBOARD
// Automatic scrolling during selection:
void StopAutoScrolling();
#endif // wxUSE_CLIPBOARD
wxString DoSelectionToText(wxHtmlSelection *sel);
public:
// wxHtmlWindowInterface methods:
virtual void SetHTMLWindowTitle(const wxString& title) wxOVERRIDE;
virtual void OnHTMLLinkClicked(const wxHtmlLinkInfo& link) wxOVERRIDE;
virtual wxHtmlOpeningStatus OnHTMLOpeningURL(wxHtmlURLType type,
const wxString& url,
wxString *redirect) const wxOVERRIDE;
virtual wxPoint HTMLCoordsToWindow(wxHtmlCell *cell,
const wxPoint& pos) const wxOVERRIDE;
virtual wxWindow* GetHTMLWindow() wxOVERRIDE;
virtual wxColour GetHTMLBackgroundColour() const wxOVERRIDE;
virtual void SetHTMLBackgroundColour(const wxColour& clr) wxOVERRIDE;
virtual void SetHTMLBackgroundImage(const wxBitmap& bmpBg) wxOVERRIDE;
virtual void SetHTMLStatusText(const wxString& text) wxOVERRIDE;
virtual wxCursor GetHTMLCursor(HTMLCursor type) const wxOVERRIDE;
// implementation of SetPage()
bool DoSetPage(const wxString& source);
protected:
// This is pointer to the first cell in parsed data. (Note: the first cell
// is usually top one = all other cells are sub-cells of this one)
wxHtmlContainerCell *m_Cell;
// parser which is used to parse HTML input.
// Each wxHtmlWindow has its own parser because sharing one global
// parser would be problematic (because of reentrancy)
wxHtmlWinParser *m_Parser;
// contains name of actually opened page or empty string if no page opened
wxString m_OpenedPage;
// contains name of current anchor within m_OpenedPage
wxString m_OpenedAnchor;
// contains title of actually opened page or empty string if no <TITLE> tag
wxString m_OpenedPageTitle;
// class for opening files (file system)
wxFileSystem* m_FS;
// frame in which page title should be displayed & number of its statusbar
// reserved for usage with this html window
wxFrame *m_RelatedFrame;
#if wxUSE_STATUSBAR
int m_RelatedStatusBarIndex;
wxStatusBar* m_RelatedStatusBar;
#endif // wxUSE_STATUSBAR
wxString m_TitleFormat;
// borders (free space between text and window borders)
// defaults to 10 pixels.
int m_Borders;
// current text selection or NULL
wxHtmlSelection *m_selection;
// true if the user is dragging mouse to select text
bool m_makingSelection;
#if wxUSE_CLIPBOARD
// time of the last doubleclick event, used to detect tripleclicks
// (tripleclicks are used to select whole line):
wxMilliClock_t m_lastDoubleClick;
// helper class to automatically scroll the window if the user is selecting
// text and the mouse leaves wxHtmlWindow:
wxHtmlWinAutoScrollTimer *m_timerAutoScroll;
#endif // wxUSE_CLIPBOARD
private:
// erase the window background using m_bmpBg or just solid colour if we
// don't have any background image
void DoEraseBackground(wxDC& dc);
// window content for double buffered rendering, may be invalid until it is
// really initialized in OnPaint()
wxBitmap m_backBuffer;
// background image, may be invalid
wxBitmap m_bmpBg;
// variables used when user is selecting text
wxPoint m_tmpSelFromPos;
wxHtmlCell *m_tmpSelFromCell;
// if >0 contents of the window is not redrawn
// (in order to avoid ugly blinking)
int m_tmpCanDrawLocks;
// list of HTML filters
static wxList m_Filters;
// this filter is used when no filter is able to read some file
static wxHtmlFilter *m_DefaultFilter;
// html processors array:
wxHtmlProcessorList *m_Processors;
static wxHtmlProcessorList *m_GlobalProcessors;
// browser history
wxHtmlHistoryArray *m_History;
int m_HistoryPos;
// if this FLAG is false, items are not added to history
bool m_HistoryOn;
// Flag used to communicate between OnPaint() and OnEraseBackground(), see
// the comments near its use.
bool m_isBgReallyErased;
// standard mouse cursors
static wxCursor *ms_cursorLink;
static wxCursor *ms_cursorText;
static wxCursor *ms_cursorDefault;
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxHtmlWindow);
};
class WXDLLIMPEXP_FWD_HTML wxHtmlCellEvent;
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_HTML, wxEVT_HTML_CELL_CLICKED, wxHtmlCellEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_HTML, wxEVT_HTML_CELL_HOVER, wxHtmlCellEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_HTML, wxEVT_HTML_LINK_CLICKED, wxHtmlLinkEvent );
/*!
* Html cell window event
*/
class WXDLLIMPEXP_HTML wxHtmlCellEvent : public wxCommandEvent
{
public:
wxHtmlCellEvent() {}
wxHtmlCellEvent(wxEventType commandType, int id,
wxHtmlCell *cell, const wxPoint &pt,
const wxMouseEvent &ev)
: wxCommandEvent(commandType, id)
{
m_cell = cell;
m_pt = pt;
m_mouseEvent = ev;
m_bLinkWasClicked = false;
}
wxHtmlCell* GetCell() const { return m_cell; }
wxPoint GetPoint() const { return m_pt; }
wxMouseEvent GetMouseEvent() const { return m_mouseEvent; }
void SetLinkClicked(bool linkclicked) { m_bLinkWasClicked=linkclicked; }
bool GetLinkClicked() const { return m_bLinkWasClicked; }
// default copy ctor, assignment operator and dtor are ok
virtual wxEvent *Clone() const wxOVERRIDE { return new wxHtmlCellEvent(*this); }
private:
wxHtmlCell *m_cell;
wxMouseEvent m_mouseEvent;
wxPoint m_pt;
bool m_bLinkWasClicked;
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxHtmlCellEvent);
};
/*!
* Html link event
*/
class WXDLLIMPEXP_HTML wxHtmlLinkEvent : public wxCommandEvent
{
public:
wxHtmlLinkEvent() {}
wxHtmlLinkEvent(int id, const wxHtmlLinkInfo &linkinfo)
: wxCommandEvent(wxEVT_HTML_LINK_CLICKED, id)
, m_linkInfo(linkinfo)
{
}
const wxHtmlLinkInfo &GetLinkInfo() const { return m_linkInfo; }
// default copy ctor, assignment operator and dtor are ok
virtual wxEvent *Clone() const wxOVERRIDE { return new wxHtmlLinkEvent(*this); }
private:
wxHtmlLinkInfo m_linkInfo;
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxHtmlLinkEvent);
};
typedef void (wxEvtHandler::*wxHtmlCellEventFunction)(wxHtmlCellEvent&);
typedef void (wxEvtHandler::*wxHtmlLinkEventFunction)(wxHtmlLinkEvent&);
#define wxHtmlCellEventHandler(func) \
wxEVENT_HANDLER_CAST(wxHtmlCellEventFunction, func)
#define wxHtmlLinkEventHandler(func) \
wxEVENT_HANDLER_CAST(wxHtmlLinkEventFunction, func)
#define EVT_HTML_CELL_CLICKED(id, fn) \
wx__DECLARE_EVT1(wxEVT_HTML_CELL_CLICKED, id, wxHtmlCellEventHandler(fn))
#define EVT_HTML_CELL_HOVER(id, fn) \
wx__DECLARE_EVT1(wxEVT_HTML_CELL_HOVER, id, wxHtmlCellEventHandler(fn))
#define EVT_HTML_LINK_CLICKED(id, fn) \
wx__DECLARE_EVT1(wxEVT_HTML_LINK_CLICKED, id, wxHtmlLinkEventHandler(fn))
// old wxEVT_COMMAND_* constants
#define wxEVT_COMMAND_HTML_CELL_CLICKED wxEVT_HTML_CELL_CLICKED
#define wxEVT_COMMAND_HTML_CELL_HOVER wxEVT_HTML_CELL_HOVER
#define wxEVT_COMMAND_HTML_LINK_CLICKED wxEVT_HTML_LINK_CLICKED
#endif // wxUSE_HTML
#endif // _WX_HTMLWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/helpctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/helpctrl.h
// Purpose: wxHtmlHelpController
// Notes: Based on htmlhelp.cpp, implementing a monolithic
// HTML Help controller class, by Vaclav Slavik
// Author: Harm van der Heijden and Vaclav Slavik
// Copyright: (c) Harm van der Heijden and Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPCTRL_H_
#define _WX_HELPCTRL_H_
#include "wx/defs.h"
#if wxUSE_WXHTML_HELP
#include "wx/helpbase.h"
#include "wx/html/helpfrm.h"
#define wxID_HTML_HELPFRAME (wxID_HIGHEST + 1)
// This style indicates that the window is
// embedded in the application and must not be
// destroyed by the help controller.
#define wxHF_EMBEDDED 0x00008000
// Create a dialog for the help window.
#define wxHF_DIALOG 0x00010000
// Create a frame for the help window.
#define wxHF_FRAME 0x00020000
// Make the dialog modal when displaying help.
#define wxHF_MODAL 0x00040000
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpDialog;
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpWindow;
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpFrame;
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpDialog;
class WXDLLIMPEXP_HTML wxHtmlHelpController : public wxHelpControllerBase // wxEvtHandler
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlHelpController);
public:
wxHtmlHelpController(int style = wxHF_DEFAULT_STYLE, wxWindow* parentWindow = NULL);
wxHtmlHelpController(wxWindow* parentWindow, int style = wxHF_DEFAULT_STYLE);
virtual ~wxHtmlHelpController();
void SetShouldPreventAppExit(bool enable);
void SetTitleFormat(const wxString& format);
void SetTempDir(const wxString& path) { m_helpData.SetTempDir(path); }
bool AddBook(const wxString& book_url, bool show_wait_msg = false);
bool AddBook(const wxFileName& book_file, bool show_wait_msg = false);
bool Display(const wxString& x);
bool Display(int id);
bool DisplayContents() wxOVERRIDE;
bool DisplayIndex();
bool KeywordSearch(const wxString& keyword,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE;
wxHtmlHelpWindow* GetHelpWindow() { return m_helpWindow; }
void SetHelpWindow(wxHtmlHelpWindow* helpWindow);
wxHtmlHelpFrame* GetFrame() { return m_helpFrame; }
wxHtmlHelpDialog* GetDialog() { return m_helpDialog; }
#if wxUSE_CONFIG
void UseConfig(wxConfigBase *config, const wxString& rootpath = wxEmptyString);
// Assigns config object to the Ctrl. This config is then
// used in subsequent calls to Read/WriteCustomization of both help
// Ctrl and it's wxHtmlWindow
virtual void ReadCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
virtual void WriteCustomization(wxConfigBase *cfg, const wxString& path = wxEmptyString);
#endif // wxUSE_CONFIG
//// Backward compatibility with wxHelpController API
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize(file); }
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual void SetViewer(const wxString& WXUNUSED(viewer), long WXUNUSED(flags) = 0) wxOVERRIDE {}
virtual bool LoadFile(const wxString& file = wxT("")) wxOVERRIDE;
virtual bool DisplaySection(int sectionNo) wxOVERRIDE;
virtual bool DisplaySection(const wxString& section) wxOVERRIDE { return Display(section); }
virtual bool DisplayBlock(long blockNo) wxOVERRIDE { return DisplaySection(blockNo); }
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos) wxOVERRIDE;
virtual void SetFrameParameters(const wxString& titleFormat,
const wxSize& size,
const wxPoint& pos = wxDefaultPosition,
bool newFrameEachTime = false) wxOVERRIDE;
/// Obtains the latest settings used by the help frame and the help
/// frame.
virtual wxFrame *GetFrameParameters(wxSize *size = NULL,
wxPoint *pos = NULL,
bool *newFrameEachTime = NULL) wxOVERRIDE;
// Get direct access to help data:
wxHtmlHelpData *GetHelpData() { return &m_helpData; }
virtual bool Quit() wxOVERRIDE ;
virtual void OnQuit() wxOVERRIDE {}
void OnCloseFrame(wxCloseEvent& evt);
// Make the help controller's frame 'modal' if
// needed
void MakeModalIfNeeded();
// Find the top-most parent window
wxWindow* FindTopLevelWindow();
protected:
void Init(int style);
virtual wxWindow* CreateHelpWindow();
virtual wxHtmlHelpFrame* CreateHelpFrame(wxHtmlHelpData *data);
virtual wxHtmlHelpDialog* CreateHelpDialog(wxHtmlHelpData *data);
virtual void DestroyHelpWindow();
wxHtmlHelpData m_helpData;
wxHtmlHelpWindow* m_helpWindow;
#if wxUSE_CONFIG
wxConfigBase * m_Config;
wxString m_ConfigRoot;
#endif // wxUSE_CONFIG
wxString m_titleFormat;
int m_FrameStyle;
wxHtmlHelpFrame* m_helpFrame;
wxHtmlHelpDialog* m_helpDialog;
bool m_shouldPreventAppExit;
wxDECLARE_NO_COPY_CLASS(wxHtmlHelpController);
};
/*
* wxHtmlModalHelp
* A convenience class particularly for use on wxMac,
* where you can only show modal dialogs from a modal
* dialog.
*
* Use like this:
*
* wxHtmlModalHelp help(parent, filename, topic);
*
* If topic is empty, the help contents is displayed.
*/
class WXDLLIMPEXP_HTML wxHtmlModalHelp
{
public:
wxHtmlModalHelp(wxWindow* parent, const wxString& helpFile, const wxString& topic = wxEmptyString,
int style = wxHF_DEFAULT_STYLE | wxHF_DIALOG | wxHF_MODAL);
};
#endif // wxUSE_WXHTML_HELP
#endif // _WX_HELPCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/htmlcell.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/htmlcell.h
// Purpose: wxHtmlCell class is used by wxHtmlWindow/wxHtmlWinParser
// as a basic visual element of HTML page
// Author: Vaclav Slavik
// Copyright: (c) 1999-2003 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HTMLCELL_H_
#define _WX_HTMLCELL_H_
#include "wx/defs.h"
#if wxUSE_HTML
#include "wx/html/htmltag.h"
#include "wx/html/htmldefs.h"
#include "wx/window.h"
#include "wx/brush.h"
class WXDLLIMPEXP_FWD_HTML wxHtmlWindowInterface;
class WXDLLIMPEXP_FWD_HTML wxHtmlLinkInfo;
class WXDLLIMPEXP_FWD_HTML wxHtmlCell;
class WXDLLIMPEXP_FWD_HTML wxHtmlContainerCell;
// wxHtmlSelection is data holder with information about text selection.
// Selection is defined by two positions (beginning and end of the selection)
// and two leaf(!) cells at these positions.
class WXDLLIMPEXP_HTML wxHtmlSelection
{
public:
wxHtmlSelection()
: m_fromPos(wxDefaultPosition), m_toPos(wxDefaultPosition),
m_fromCharacterPos(-1), m_toCharacterPos(-1),
m_fromCell(NULL), m_toCell(NULL) {}
// this version is used for the user selection defined with the mouse
void Set(const wxPoint& fromPos, const wxHtmlCell *fromCell,
const wxPoint& toPos, const wxHtmlCell *toCell);
void Set(const wxHtmlCell *fromCell, const wxHtmlCell *toCell);
const wxHtmlCell *GetFromCell() const { return m_fromCell; }
const wxHtmlCell *GetToCell() const { return m_toCell; }
// these values are in absolute coordinates:
const wxPoint& GetFromPos() const { return m_fromPos; }
const wxPoint& GetToPos() const { return m_toPos; }
// these are From/ToCell's private data
void ClearFromToCharacterPos() { m_toCharacterPos = m_fromCharacterPos = -1; }
bool AreFromToCharacterPosSet() const { return m_toCharacterPos != -1 && m_fromCharacterPos != -1; }
void SetFromCharacterPos (wxCoord pos) { m_fromCharacterPos = pos; }
void SetToCharacterPos (wxCoord pos) { m_toCharacterPos = pos; }
wxCoord GetFromCharacterPos () const { return m_fromCharacterPos; }
wxCoord GetToCharacterPos () const { return m_toCharacterPos; }
bool IsEmpty() const
{ return m_fromPos == wxDefaultPosition &&
m_toPos == wxDefaultPosition; }
private:
wxPoint m_fromPos, m_toPos;
wxCoord m_fromCharacterPos, m_toCharacterPos;
const wxHtmlCell *m_fromCell, *m_toCell;
};
enum wxHtmlSelectionState
{
wxHTML_SEL_OUT, // currently rendered cell is outside the selection
wxHTML_SEL_IN, // ... is inside selection
wxHTML_SEL_CHANGING // ... is the cell on which selection state changes
};
// Selection state is passed to wxHtmlCell::Draw so that it can render itself
// differently e.g. when inside text selection or outside it.
class WXDLLIMPEXP_HTML wxHtmlRenderingState
{
public:
wxHtmlRenderingState() : m_selState(wxHTML_SEL_OUT) { m_bgMode = wxBRUSHSTYLE_SOLID; }
void SetSelectionState(wxHtmlSelectionState s) { m_selState = s; }
wxHtmlSelectionState GetSelectionState() const { return m_selState; }
void SetFgColour(const wxColour& c) { m_fgColour = c; }
const wxColour& GetFgColour() const { return m_fgColour; }
void SetBgColour(const wxColour& c) { m_bgColour = c; }
const wxColour& GetBgColour() const { return m_bgColour; }
void SetBgMode(int m) { m_bgMode = m; }
int GetBgMode() const { return m_bgMode; }
private:
wxHtmlSelectionState m_selState;
wxColour m_fgColour, m_bgColour;
int m_bgMode;
};
// HTML rendering customization. This class is used when rendering wxHtmlCells
// as a callback:
class WXDLLIMPEXP_HTML wxHtmlRenderingStyle
{
public:
virtual ~wxHtmlRenderingStyle() {}
virtual wxColour GetSelectedTextColour(const wxColour& clr) = 0;
virtual wxColour GetSelectedTextBgColour(const wxColour& clr) = 0;
};
// Standard style:
class WXDLLIMPEXP_HTML wxDefaultHtmlRenderingStyle : public wxHtmlRenderingStyle
{
public:
virtual wxColour GetSelectedTextColour(const wxColour& clr) wxOVERRIDE;
virtual wxColour GetSelectedTextBgColour(const wxColour& clr) wxOVERRIDE;
};
// Information given to cells when drawing them. Contains rendering state,
// selection information and rendering style object that can be used to
// customize the output.
class WXDLLIMPEXP_HTML wxHtmlRenderingInfo
{
public:
wxHtmlRenderingInfo()
: m_selection(NULL),
m_style(NULL),
m_prevUnderlined(false)
{
}
void SetSelection(wxHtmlSelection *s) { m_selection = s; }
wxHtmlSelection *GetSelection() const { return m_selection; }
void SetStyle(wxHtmlRenderingStyle *style) { m_style = style; }
wxHtmlRenderingStyle& GetStyle() { return *m_style; }
void SetCurrentUnderlined(bool u) { m_prevUnderlined = u; }
bool WasPreviousUnderlined() const { return m_prevUnderlined; }
wxHtmlRenderingState& GetState() { return m_state; }
protected:
wxHtmlSelection *m_selection;
wxHtmlRenderingStyle *m_style;
wxHtmlRenderingState m_state;
bool m_prevUnderlined;
};
// Flags for wxHtmlCell::FindCellByPos
enum
{
wxHTML_FIND_EXACT = 1,
wxHTML_FIND_NEAREST_BEFORE = 2,
wxHTML_FIND_NEAREST_AFTER = 4
};
// Superscript/subscript/normal script mode of a cell
enum wxHtmlScriptMode
{
wxHTML_SCRIPT_NORMAL,
wxHTML_SCRIPT_SUB,
wxHTML_SCRIPT_SUP
};
// ---------------------------------------------------------------------------
// wxHtmlCell
// Internal data structure. It represents fragments of parsed
// HTML page - a word, picture, table, horizontal line and so
// on. It is used by wxHtmlWindow to represent HTML page in
// memory.
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlCell : public wxObject
{
public:
wxHtmlCell();
virtual ~wxHtmlCell();
void SetParent(wxHtmlContainerCell *p) {m_Parent = p;}
wxHtmlContainerCell *GetParent() const {return m_Parent;}
int GetPosX() const {return m_PosX;}
int GetPosY() const {return m_PosY;}
int GetWidth() const {return m_Width;}
// Returns the maximum possible length of the cell.
// Call Layout at least once before using GetMaxTotalWidth()
virtual int GetMaxTotalWidth() const { return m_Width; }
int GetHeight() const {return m_Height;}
int GetDescent() const {return m_Descent;}
void SetScriptMode(wxHtmlScriptMode mode, long previousBase);
wxHtmlScriptMode GetScriptMode() const { return m_ScriptMode; }
long GetScriptBaseline() { return m_ScriptBaseline; }
// Formatting cells are not visible on the screen, they only alter
// renderer's state.
bool IsFormattingCell() const { return m_Width == 0 && m_Height == 0; }
const wxString& GetId() const { return m_id; }
void SetId(const wxString& id) { m_id = id; }
// returns the link associated with this cell. The position is position
// within the cell so it varies from 0 to m_Width, from 0 to m_Height
virtual wxHtmlLinkInfo* GetLink(int WXUNUSED(x) = 0,
int WXUNUSED(y) = 0) const
{ return m_Link; }
// Returns cursor to be used when mouse is over the cell, can be
// overridden by the derived classes to use a different cursor whenever the
// mouse is over this cell.
virtual wxCursor GetMouseCursor(wxHtmlWindowInterface *window) const;
// Returns cursor to be used when mouse is over the given point, can be
// overridden if the cursor should change depending on where exactly inside
// the cell the mouse is.
virtual wxCursor GetMouseCursorAt(wxHtmlWindowInterface *window,
const wxPoint& relPos) const;
// return next cell among parent's cells
wxHtmlCell *GetNext() const {return m_Next;}
// returns first child cell (if there are any, i.e. if this is container):
virtual wxHtmlCell* GetFirstChild() const { return NULL; }
// members writing methods
virtual void SetPos(int x, int y) {m_PosX = x; m_PosY = y;}
void SetLink(const wxHtmlLinkInfo& link);
void SetNext(wxHtmlCell *cell) {m_Next = cell;}
// 1. adjust cell's width according to the fact that maximal possible width
// is w. (this has sense when working with horizontal lines, tables
// etc.)
// 2. prepare layout (=fill-in m_PosX, m_PosY (and sometime m_Height)
// members) = place items to fit window, according to the width w
virtual void Layout(int w);
// renders the cell
virtual void Draw(wxDC& WXUNUSED(dc),
int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(view_y1), int WXUNUSED(view_y2),
wxHtmlRenderingInfo& WXUNUSED(info)) {}
// proceed drawing actions in case the cell is not visible (scrolled out of
// screen). This is needed to change fonts, colors and so on.
virtual void DrawInvisible(wxDC& WXUNUSED(dc),
int WXUNUSED(x), int WXUNUSED(y),
wxHtmlRenderingInfo& WXUNUSED(info)) {}
// This method returns pointer to the FIRST cell for that
// the condition
// is true. It first checks if the condition is true for this
// cell and then calls m_Next->Find(). (Note: it checks
// all subcells if the cell is container)
// Condition is unique condition identifier (see htmldefs.h)
// (user-defined condition IDs should start from 10000)
// and param is optional parameter
// Example : m_Cell->Find(wxHTML_COND_ISANCHOR, "news");
// returns pointer to anchor news
virtual const wxHtmlCell* Find(int condition, const void* param) const;
// This function is called when mouse button is clicked over the cell.
// Returns true if a link is clicked, false otherwise.
//
// 'window' is pointer to wxHtmlWindowInterface of the window which
// generated the event.
// HINT: if this handling is not enough for you you should use
// wxHtmlWidgetCell
virtual bool ProcessMouseClick(wxHtmlWindowInterface *window,
const wxPoint& pos,
const wxMouseEvent& event);
// This method is called when paginating HTML, e.g. when printing.
//
// On input, pagebreak contains y-coordinate of page break (i.e. the
// horizontal line that should not be crossed by words, images etc.)
// relative to the parent cell on entry and may be modified to request a
// page break at a position before it if this cell cannot be divided into
// two pieces (each one on its own page).
//
// Note that page break must still happen on the current page, i.e. the
// returned value must be strictly greater than "*pagebreak - pageHeight"
// and less or equal to "*pagebreak" for the value of pagebreak on input.
//
// Returned value : true if pagebreak was modified, false otherwise
virtual bool AdjustPagebreak(int *pagebreak, int pageHeight) const;
// Sets cell's behaviour on pagebreaks (see AdjustPagebreak). Default
// is true - the cell can be split on two pages
// If there is no way to fit a cell in the current page size, the cell
// is always split, ignoring this setting.
void SetCanLiveOnPagebreak(bool can) { m_CanLiveOnPagebreak = can; }
// Can the line be broken before this cell?
virtual bool IsLinebreakAllowed() const
{ return !IsFormattingCell(); }
// Returns true for simple == terminal cells, i.e. not composite ones.
// This if for internal usage only and may disappear in future versions!
virtual bool IsTerminalCell() const { return true; }
// Find a cell inside this cell positioned at the given coordinates
// (relative to this's positions). Returns NULL if no such cell exists.
// The flag can be used to specify whether to look for terminal or
// nonterminal cells or both. In either case, returned cell is deepest
// cell in cells tree that contains [x,y].
virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y,
unsigned flags = wxHTML_FIND_EXACT) const;
// Returns absolute position of the cell on HTML canvas.
// If rootCell is provided, then it's considered to be the root of the
// hierarchy and the returned value is relative to it.
wxPoint GetAbsPos(wxHtmlCell *rootCell = NULL) const;
// Returns root cell of the hierarchy (i.e. grand-grand-...-parent that
// doesn't have a parent itself)
wxHtmlCell *GetRootCell() const;
// Returns first (last) terminal cell inside this cell. It may return NULL,
// but it is rare -- only if there are no terminals in the tree.
virtual wxHtmlCell *GetFirstTerminal() const
{ return wxConstCast(this, wxHtmlCell); }
virtual wxHtmlCell *GetLastTerminal() const
{ return wxConstCast(this, wxHtmlCell); }
// Returns cell's depth, i.e. how far under the root cell it is
// (if it is the root, depth is 0)
unsigned GetDepth() const;
// Returns true if the cell appears before 'cell' in natural order of
// cells (= as they are read). If cell A is (grand)parent of cell B,
// then both A.IsBefore(B) and B.IsBefore(A) always return true.
bool IsBefore(wxHtmlCell *cell) const;
// Converts the cell into text representation. If sel != NULL then
// only part of the cell inside the selection is converted.
virtual wxString ConvertToText(wxHtmlSelection *WXUNUSED(sel)) const
{ return wxEmptyString; }
protected:
// pointer to the next cell
wxHtmlCell *m_Next;
// pointer to parent cell
wxHtmlContainerCell *m_Parent;
// dimensions of fragment (m_Descent is used to position text & images)
int m_Width, m_Height, m_Descent;
// position where the fragment is drawn:
int m_PosX, m_PosY;
// superscript/subscript/normal:
wxHtmlScriptMode m_ScriptMode;
long m_ScriptBaseline;
// destination address if this fragment is hypertext link, NULL otherwise
wxHtmlLinkInfo *m_Link;
// true if this cell can be placed on pagebreak, false otherwise
bool m_CanLiveOnPagebreak;
// unique identifier of the cell, generated from "id" property of tags
wxString m_id;
wxDECLARE_ABSTRACT_CLASS(wxHtmlCell);
wxDECLARE_NO_COPY_CLASS(wxHtmlCell);
};
// ----------------------------------------------------------------------------
// Inherited cells:
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxHtmlWordCell
// Single word in input stream.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlWordCell : public wxHtmlCell
{
public:
wxHtmlWordCell(const wxString& word, const wxDC& dc);
void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info) wxOVERRIDE;
virtual wxCursor GetMouseCursor(wxHtmlWindowInterface *window) const wxOVERRIDE;
virtual wxString ConvertToText(wxHtmlSelection *sel) const wxOVERRIDE;
bool IsLinebreakAllowed() const wxOVERRIDE { return m_allowLinebreak; }
void SetPreviousWord(wxHtmlWordCell *cell);
protected:
virtual wxString GetAllAsText() const
{ return m_Word; }
virtual wxString GetPartAsText(int begin, int end) const
{ return m_Word.Mid(begin, end - begin); }
void SetSelectionPrivPos(const wxDC& dc, wxHtmlSelection *s) const;
void Split(const wxDC& dc,
const wxPoint& selFrom, const wxPoint& selTo,
unsigned& pos1, unsigned& pos2) const;
wxString m_Word;
bool m_allowLinebreak;
wxDECLARE_ABSTRACT_CLASS(wxHtmlWordCell);
wxDECLARE_NO_COPY_CLASS(wxHtmlWordCell);
};
// wxHtmlWordCell specialization for storing text fragments with embedded
// '\t's; these differ from normal words in that the displayed text is
// different from the text copied to clipboard
class WXDLLIMPEXP_HTML wxHtmlWordWithTabsCell : public wxHtmlWordCell
{
public:
wxHtmlWordWithTabsCell(const wxString& word,
const wxString& wordOrig,
size_t linepos,
const wxDC& dc)
: wxHtmlWordCell(word, dc),
m_wordOrig(wordOrig),
m_linepos(linepos)
{}
protected:
virtual wxString GetAllAsText() const wxOVERRIDE;
virtual wxString GetPartAsText(int begin, int end) const wxOVERRIDE;
wxString m_wordOrig;
size_t m_linepos;
};
// Container contains other cells, thus forming tree structure of rendering
// elements. Basic code of layout algorithm is contained in this class.
class WXDLLIMPEXP_HTML wxHtmlContainerCell : public wxHtmlCell
{
public:
explicit wxHtmlContainerCell(wxHtmlContainerCell *parent);
virtual ~wxHtmlContainerCell();
virtual void Layout(int w) wxOVERRIDE;
virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info) wxOVERRIDE;
virtual void DrawInvisible(wxDC& dc, int x, int y,
wxHtmlRenderingInfo& info) wxOVERRIDE;
virtual bool AdjustPagebreak(int *pagebreak, int pageHeight) const wxOVERRIDE;
// insert cell at the end of m_Cells list
void InsertCell(wxHtmlCell *cell);
// Detach a child cell. After calling this method, it's the caller
// responsibility to destroy this cell (possibly by calling InsertCell()
// with it to attach it elsewhere).
void Detach(wxHtmlCell *cell);
// sets horizontal/vertical alignment
void SetAlignHor(int al) {m_AlignHor = al; m_LastLayout = -1;}
int GetAlignHor() const {return m_AlignHor;}
void SetAlignVer(int al) {m_AlignVer = al; m_LastLayout = -1;}
int GetAlignVer() const {return m_AlignVer;}
// sets left-border indentation. units is one of wxHTML_UNITS_* constants
// what is combination of wxHTML_INDENT_*
void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS);
// returns the indentation. ind is one of wxHTML_INDENT_* constants
int GetIndent(int ind) const;
// returns type of value returned by GetIndent(ind)
int GetIndentUnits(int ind) const;
// sets alignment info based on given tag's params
void SetAlign(const wxHtmlTag& tag);
// sets floating width adjustment
// (examples : 32 percent of parent container,
// -15 pixels percent (this means 100 % - 15 pixels)
void SetWidthFloat(int w, int units) {m_WidthFloat = w; m_WidthFloatUnits = units; m_LastLayout = -1;}
void SetWidthFloat(const wxHtmlTag& tag, double pixel_scale = 1.0);
// sets minimal height of this container.
void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP) {m_MinHeight = h; m_MinHeightAlign = align; m_LastLayout = -1;}
void SetBackgroundColour(const wxColour& clr) {m_BkColour = clr;}
// returns background colour (of wxNullColour if none set), so that widgets can
// adapt to it:
wxColour GetBackgroundColour();
void SetBorder(const wxColour& clr1, const wxColour& clr2, int border = 1) {m_Border = border; m_BorderColour1 = clr1; m_BorderColour2 = clr2;}
virtual wxHtmlLinkInfo* GetLink(int x = 0, int y = 0) const wxOVERRIDE;
virtual const wxHtmlCell* Find(int condition, const void* param) const wxOVERRIDE;
virtual bool ProcessMouseClick(wxHtmlWindowInterface *window,
const wxPoint& pos,
const wxMouseEvent& event) wxOVERRIDE;
virtual wxHtmlCell* GetFirstChild() const wxOVERRIDE { return m_Cells; }
// returns last child cell:
wxHtmlCell* GetLastChild() const { return m_LastCell; }
// see comment in wxHtmlCell about this method
virtual bool IsTerminalCell() const wxOVERRIDE { return false; }
virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y,
unsigned flags = wxHTML_FIND_EXACT) const wxOVERRIDE;
virtual wxHtmlCell *GetFirstTerminal() const wxOVERRIDE;
virtual wxHtmlCell *GetLastTerminal() const wxOVERRIDE;
// Removes indentation on top or bottom of the container (i.e. above or
// below first/last terminal cell). For internal use only.
virtual void RemoveExtraSpacing(bool top, bool bottom);
// Returns the maximum possible length of the container.
// Call Layout at least once before using GetMaxTotalWidth()
virtual int GetMaxTotalWidth() const wxOVERRIDE { return m_MaxTotalWidth; }
protected:
void UpdateRenderingStatePre(wxHtmlRenderingInfo& info,
wxHtmlCell *cell) const;
void UpdateRenderingStatePost(wxHtmlRenderingInfo& info,
wxHtmlCell *cell) const;
protected:
int m_IndentLeft, m_IndentRight, m_IndentTop, m_IndentBottom;
// indentation of subcells. There is always m_Indent pixels
// big space between given border of the container and the subcells
// it m_Indent < 0 it is in PERCENTS, otherwise it is in pixels
int m_MinHeight, m_MinHeightAlign;
// minimal height.
wxHtmlCell *m_Cells, *m_LastCell;
// internal cells, m_Cells points to the first of them, m_LastCell to the last one.
// (LastCell is needed only to speed-up InsertCell)
int m_AlignHor, m_AlignVer;
// alignment horizontal and vertical (left, center, right)
int m_WidthFloat, m_WidthFloatUnits;
// width float is used in adjustWidth
wxColour m_BkColour;
// background color of this container
int m_Border;
// border size. Draw only if m_Border > 0
wxColour m_BorderColour1, m_BorderColour2;
// borders color of this container
int m_LastLayout;
// if != -1 then call to Layout may be no-op
// if previous call to Layout has same argument
int m_MaxTotalWidth;
// Maximum possible length if ignoring line wrap
wxDECLARE_ABSTRACT_CLASS(wxHtmlContainerCell);
wxDECLARE_NO_COPY_CLASS(wxHtmlContainerCell);
};
// ---------------------------------------------------------------------------
// wxHtmlColourCell
// Color changer.
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlColourCell : public wxHtmlCell
{
public:
wxHtmlColourCell(const wxColour& clr, int flags = wxHTML_CLR_FOREGROUND) : wxHtmlCell() {m_Colour = clr; m_Flags = flags;}
virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info) wxOVERRIDE;
virtual void DrawInvisible(wxDC& dc, int x, int y,
wxHtmlRenderingInfo& info) wxOVERRIDE;
protected:
wxColour m_Colour;
unsigned m_Flags;
wxDECLARE_ABSTRACT_CLASS(wxHtmlColourCell);
wxDECLARE_NO_COPY_CLASS(wxHtmlColourCell);
};
//--------------------------------------------------------------------------------
// wxHtmlFontCell
// Sets actual font used for text rendering
//--------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlFontCell : public wxHtmlCell
{
public:
wxHtmlFontCell(wxFont *font) : wxHtmlCell() { m_Font = (*font); }
virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info) wxOVERRIDE;
virtual void DrawInvisible(wxDC& dc, int x, int y,
wxHtmlRenderingInfo& info) wxOVERRIDE;
protected:
wxFont m_Font;
wxDECLARE_ABSTRACT_CLASS(wxHtmlFontCell);
wxDECLARE_NO_COPY_CLASS(wxHtmlFontCell);
};
//--------------------------------------------------------------------------------
// wxHtmlwidgetCell
// This cell is connected with wxWindow object
// You can use it to insert windows into HTML page
// (buttons, input boxes etc.)
//--------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlWidgetCell : public wxHtmlCell
{
public:
// !!! wnd must have correct parent!
// if w != 0 then the m_Wnd has 'floating' width - it adjust
// it's width according to parent container's width
// (w is percent of parent's width)
wxHtmlWidgetCell(wxWindow *wnd, int w = 0);
virtual ~wxHtmlWidgetCell() { m_Wnd->Destroy(); }
virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
wxHtmlRenderingInfo& info) wxOVERRIDE;
virtual void DrawInvisible(wxDC& dc, int x, int y,
wxHtmlRenderingInfo& info) wxOVERRIDE;
virtual void Layout(int w) wxOVERRIDE;
protected:
wxWindow* m_Wnd;
int m_WidthFloat;
// width float is used in adjustWidth (it is in percents)
wxDECLARE_ABSTRACT_CLASS(wxHtmlWidgetCell);
wxDECLARE_NO_COPY_CLASS(wxHtmlWidgetCell);
};
//--------------------------------------------------------------------------------
// wxHtmlLinkInfo
// Internal data structure. It represents hypertext link
//--------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlLinkInfo : public wxObject
{
public:
wxHtmlLinkInfo()
{ m_Event = NULL; m_Cell = NULL; }
wxHtmlLinkInfo(const wxString& href, const wxString& target = wxString())
: m_Href(href)
, m_Target(target)
{ m_Event = NULL; m_Cell = NULL; }
void SetEvent(const wxMouseEvent *e) { m_Event = e; }
void SetHtmlCell(const wxHtmlCell *e) { m_Cell = e; }
wxString GetHref() const { return m_Href; }
wxString GetTarget() const { return m_Target; }
const wxMouseEvent* GetEvent() const { return m_Event; }
const wxHtmlCell* GetHtmlCell() const { return m_Cell; }
private:
wxString m_Href, m_Target;
const wxMouseEvent *m_Event;
const wxHtmlCell *m_Cell;
};
// ----------------------------------------------------------------------------
// wxHtmlTerminalCellsInterator
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlTerminalCellsInterator
{
public:
wxHtmlTerminalCellsInterator(const wxHtmlCell *from, const wxHtmlCell *to)
: m_to(to), m_pos(from) {}
operator bool() const { return m_pos != NULL; }
const wxHtmlCell* operator++();
const wxHtmlCell* operator->() const { return m_pos; }
const wxHtmlCell* operator*() const { return m_pos; }
private:
const wxHtmlCell *m_to, *m_pos;
};
#endif // wxUSE_HTML
#endif // _WX_HTMLCELL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/htmlpars.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/htmlpars.h
// Purpose: wxHtmlParser class (generic parser)
// Author: Vaclav Slavik
// Copyright: (c) 1999 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HTMLPARS_H_
#define _WX_HTMLPARS_H_
#include "wx/defs.h"
#if wxUSE_HTML
#include "wx/html/htmltag.h"
#include "wx/filesys.h"
#include "wx/hashmap.h"
#include "wx/hashset.h"
#include "wx/vector.h"
#include "wx/fontenc.h"
class WXDLLIMPEXP_FWD_BASE wxMBConv;
class WXDLLIMPEXP_FWD_HTML wxHtmlParser;
class WXDLLIMPEXP_FWD_HTML wxHtmlTagHandler;
class WXDLLIMPEXP_FWD_HTML wxHtmlEntitiesParser;
class wxHtmlTextPieces;
class wxHtmlParserState;
WX_DECLARE_HASH_SET_WITH_DECL_PTR(wxHtmlTagHandler*,
wxPointerHash, wxPointerEqual,
wxHtmlTagHandlersSet,
class WXDLLIMPEXP_HTML);
WX_DECLARE_STRING_HASH_MAP_WITH_DECL(wxHtmlTagHandler*,
wxHtmlTagHandlersHash,
class WXDLLIMPEXP_HTML);
enum wxHtmlURLType
{
wxHTML_URL_PAGE,
wxHTML_URL_IMAGE,
wxHTML_URL_OTHER
};
// This class handles generic parsing of HTML document : it scans
// the document and divides it into blocks of tags (where one block
// consists of starting and ending tag and of text between these
// 2 tags.
class WXDLLIMPEXP_HTML wxHtmlParser : public wxObject
{
wxDECLARE_ABSTRACT_CLASS(wxHtmlParser);
public:
wxHtmlParser();
virtual ~wxHtmlParser();
// Sets the class which will be used for opening files
void SetFS(wxFileSystem *fs) { m_FS = fs; }
wxFileSystem* GetFS() const { return m_FS; }
// Opens file if the parser is allowed to open given URL (may be forbidden
// for security reasons)
virtual wxFSFile *OpenURL(wxHtmlURLType type, const wxString& url) const;
// You can simply call this method when you need parsed output.
// This method does these things:
// 1. call InitParser(source);
// 2. call DoParsing();
// 3. call GetProduct(); (its return value is then returned)
// 4. call DoneParser();
wxObject* Parse(const wxString& source);
// Sets the source. This must be called before running Parse() method.
virtual void InitParser(const wxString& source);
// This must be called after Parse().
virtual void DoneParser();
// May be called during parsing to immediately return from Parse().
virtual void StopParsing() { m_stopParsing = true; }
// Parses the m_Source from begin_pos to end_pos-1.
// (in noparams version it parses whole m_Source)
void DoParsing(const wxString::const_iterator& begin_pos,
const wxString::const_iterator& end_pos);
void DoParsing();
// Returns pointer to the tag at parser's current position
wxHtmlTag *GetCurrentTag() const { return m_CurTag; }
// Returns product of parsing
// Returned value is result of parsing of the part. The type of this result
// depends on internal representation in derived parser
// (see wxHtmlWinParser for details).
virtual wxObject* GetProduct() = 0;
// adds handler to the list & hash table of handlers.
virtual void AddTagHandler(wxHtmlTagHandler *handler);
// Forces the handler to handle additional tags (not returned by GetSupportedTags).
// The handler should already be in use by this parser.
// Example: you want to parse following pseudo-html structure:
// <myitems>
// <it name="one" value="1">
// <it name="two" value="2">
// </myitems>
// <it> This last it has different meaning, we don't want it to be parsed by myitems handler!
// handler can handle only 'myitems' (e.g. its GetSupportedTags returns "MYITEMS")
// you can call PushTagHandler(handler, "IT") when you find <myitems>
// and call PopTagHandler() when you find </myitems>
void PushTagHandler(wxHtmlTagHandler *handler, const wxString& tags);
// Restores state before last call to PushTagHandler
void PopTagHandler();
const wxString* GetSource() {return m_Source;}
void SetSource(const wxString& src);
// Sets HTML source and remembers current parser's state so that it can
// later be restored. This is useful for on-line modifications of
// HTML source (for example, <pre> handler replaces spaces with
// and newlines with <br>)
virtual void SetSourceAndSaveState(const wxString& src);
// Restores parser's state from stack or returns false if the stack is
// empty
virtual bool RestoreState();
// Returns HTML source inside the element (i.e. between the starting
// and ending tag)
wxString GetInnerSource(const wxHtmlTag& tag);
// Parses HTML string 'markup' and extracts charset info from <meta> tag
// if present. Returns empty string if the tag is missing.
// For wxHTML's internal use.
static wxString ExtractCharsetInformation(const wxString& markup);
// Returns entity parser object, used to substitute HTML &entities;
wxHtmlEntitiesParser *GetEntitiesParser() const { return m_entitiesParser; }
// Returns true if the tag starting at the given position is a comment tag
//
// p should point to '<' character and is modified to point to the closing
// '>' of the end comment tag if this is indeed a comment
static bool
SkipCommentTag(wxString::const_iterator& p, wxString::const_iterator end);
protected:
// DOM structure
void CreateDOMTree();
void DestroyDOMTree();
void CreateDOMSubTree(wxHtmlTag *cur,
const wxString::const_iterator& begin_pos,
const wxString::const_iterator& end_pos,
wxHtmlTagsCache *cache);
// Adds text to the output.
// This is called from Parse() and must be overridden in derived classes.
// txt is not guaranteed to be only one word. It is largest continuous part
// of text (= not broken by tags)
virtual void AddText(const wxString& txt) = 0;
// Adds tag and proceeds it. Parse() may (and usually is) called from this method.
// This is called from Parse() and may be overridden.
// Default behaviour is that it looks for proper handler in m_Handlers. The tag is
// ignored if no hander is found.
// Derived class is *responsible* for filling in m_Handlers table.
virtual void AddTag(const wxHtmlTag& tag);
protected:
// DOM tree:
wxHtmlTag *m_CurTag;
wxHtmlTag *m_Tags;
wxHtmlTextPieces *m_TextPieces;
size_t m_CurTextPiece;
const wxString *m_Source;
wxHtmlParserState *m_SavedStates;
// handlers that handle particular tags. The table is accessed by
// key = tag's name.
// This attribute MUST be filled by derived class otherwise it would
// be empty and no tags would be recognized
// (see wxHtmlWinParser for details about filling it)
// m_HandlersHash is for random access based on knowledge of tag name (BR, P, etc.)
// it may (and often does) contain more references to one object
// m_HandlersList is list of all handlers and it is guaranteed to contain
// only one reference to each handler instance.
wxHtmlTagHandlersSet m_HandlersSet;
wxHtmlTagHandlersHash m_HandlersHash;
wxDECLARE_NO_COPY_CLASS(wxHtmlParser);
// class for opening files (file system)
wxFileSystem *m_FS;
// handlers stack used by PushTagHandler and PopTagHandler
wxVector<wxHtmlTagHandlersHash*> m_HandlersStack;
// entity parse
wxHtmlEntitiesParser *m_entitiesParser;
// flag indicating that the parser should stop
bool m_stopParsing;
};
// This class (and derived classes) cooperates with wxHtmlParser.
// Each recognized tag is passed to handler which is capable
// of handling it. Each tag is handled in 3 steps:
// 1. Handler will modifies state of parser
// (using its public methods)
// 2. Parser parses source between starting and ending tag
// 3. Handler restores original state of the parser
class WXDLLIMPEXP_HTML wxHtmlTagHandler : public wxObject
{
wxDECLARE_ABSTRACT_CLASS(wxHtmlTagHandler);
public:
wxHtmlTagHandler() : wxObject () { m_Parser = NULL; }
// Sets the parser.
// NOTE : each _instance_ of handler is guaranteed to be called
// only by one parser. This means you don't have to care about
// reentrancy.
virtual void SetParser(wxHtmlParser *parser)
{ m_Parser = parser; }
// Get the parser associated with this tag handler.
wxHtmlParser* GetParser() const { return m_Parser; }
// Returns list of supported tags. The list is in uppercase and
// tags are delimited by ','.
// Example : "I,B,FONT,P"
// is capable of handling italic, bold, font and paragraph tags
virtual wxString GetSupportedTags() = 0;
// This is hadling core method. It does all the Steps 1-3.
// To process step 2, you can call ParseInner()
// returned value : true if it called ParseInner(),
// false etherwise
virtual bool HandleTag(const wxHtmlTag& tag) = 0;
protected:
// parses input between beginning and ending tag.
// m_Parser must be set.
void ParseInner(const wxHtmlTag& tag)
{ m_Parser->DoParsing(tag.GetBeginIter(), tag.GetEndIter1()); }
// Parses given source as if it was tag's inner code (see
// wxHtmlParser::GetInnerSource). Unlike ParseInner(), this method lets
// you specify the source code to parse. This is useful when you need to
// modify the inner text before parsing.
void ParseInnerSource(const wxString& source);
wxHtmlParser *m_Parser;
wxDECLARE_NO_COPY_CLASS(wxHtmlTagHandler);
};
// This class is used to parse HTML entities in strings. It can handle
// both named entities and &#xxxx entries where xxxx is Unicode code.
class WXDLLIMPEXP_HTML wxHtmlEntitiesParser : public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlEntitiesParser);
public:
wxHtmlEntitiesParser();
virtual ~wxHtmlEntitiesParser();
// Sets encoding of output string.
// Has no effect if wxUSE_UNICODE==1
#if wxUSE_UNICODE
void SetEncoding(wxFontEncoding WXUNUSED(encoding)) {}
#else
void SetEncoding(wxFontEncoding encoding);
#endif
// Parses entities in input and replaces them with respective characters
// (with respect to output encoding)
wxString Parse(const wxString& input) const;
// Returns character for given entity or 0 if the enity is unknown
wxChar GetEntityChar(const wxString& entity) const;
// Returns character that represents given Unicode code
#if wxUSE_UNICODE
wxChar GetCharForCode(unsigned code) const { return (wxChar)code; }
#else
wxChar GetCharForCode(unsigned code) const;
#endif
protected:
#if !wxUSE_UNICODE
wxMBConv *m_conv;
wxFontEncoding m_encoding;
#endif
wxDECLARE_NO_COPY_CLASS(wxHtmlEntitiesParser);
};
#endif
#endif // _WX_HTMLPARS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/htmlproc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/htmlprep.h
// Purpose: HTML processor
// Author: Vaclav Slavik
// Copyright: (c) 2001 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HTMLPREP_H_
#define _WX_HTMLPREP_H_
#include "wx/defs.h"
#if wxUSE_HTML
#include "wx/string.h"
// Priority of preprocessor in the chain. The higher, the earlier it is used
enum
{
wxHTML_PRIORITY_DONTCARE = 128, // if the order doesn't matter, use this
// priority
wxHTML_PRIORITY_SYSTEM = 256 // >=256 is only for wxHTML's internals
};
// Classes derived from this class serve as simple text processors for
// wxHtmlWindow. wxHtmlWindow runs HTML markup through all registered
// processors before displaying it, thus allowing for on-the-fly
// modifications of the markup.
class WXDLLIMPEXP_HTML wxHtmlProcessor : public wxObject
{
wxDECLARE_ABSTRACT_CLASS(wxHtmlProcessor);
public:
wxHtmlProcessor() : wxObject(), m_enabled(true) {}
virtual ~wxHtmlProcessor() {}
// Process input text and return processed result
virtual wxString Process(const wxString& text) const = 0;
// Return priority value of this processor. The higher, the sooner
// is the processor applied to the text.
virtual int GetPriority() const { return wxHTML_PRIORITY_DONTCARE; }
// Enable/disable the processor. wxHtmlWindow won't use a disabled
// processor even if it is in its processors queue.
virtual void Enable(bool enable = true) { m_enabled = enable; }
bool IsEnabled() const { return m_enabled; }
protected:
bool m_enabled;
};
#endif // wxUSE_HTML
#endif // _WX_HTMLPROC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/html/helpdata.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/html/helpdata.h
// Purpose: wxHtmlHelpData
// Notes: Based on htmlhelp.cpp, implementing a monolithic
// HTML Help controller class, by Vaclav Slavik
// Author: Harm van der Heijden and Vaclav Slavik
// Copyright: (c) Harm van der Heijden and Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPDATA_H_
#define _WX_HELPDATA_H_
#include "wx/defs.h"
#if wxUSE_HTML
#include "wx/object.h"
#include "wx/string.h"
#include "wx/filesys.h"
#include "wx/dynarray.h"
#include "wx/font.h"
class WXDLLIMPEXP_FWD_HTML wxHtmlHelpData;
//--------------------------------------------------------------------------------
// helper classes & structs
//--------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlBookRecord
{
public:
wxHtmlBookRecord(const wxString& bookfile, const wxString& basepath,
const wxString& title, const wxString& start)
{
m_BookFile = bookfile;
m_BasePath = basepath;
m_Title = title;
m_Start = start;
// for debugging, give the contents index obvious default values
m_ContentsStart = m_ContentsEnd = -1;
}
wxString GetBookFile() const { return m_BookFile; }
wxString GetTitle() const { return m_Title; }
wxString GetStart() const { return m_Start; }
wxString GetBasePath() const { return m_BasePath; }
/* SetContentsRange: store in the bookrecord where in the index/contents lists the
* book's records are stored. This to facilitate searching in a specific book.
* This code will have to be revised when loading/removing books becomes dynamic.
* (as opposed to appending only)
* Note that storing index range is pointless, because the index is alphab. sorted. */
void SetContentsRange(int start, int end) { m_ContentsStart = start; m_ContentsEnd = end; }
int GetContentsStart() const { return m_ContentsStart; }
int GetContentsEnd() const { return m_ContentsEnd; }
void SetTitle(const wxString& title) { m_Title = title; }
void SetBasePath(const wxString& path) { m_BasePath = path; }
void SetStart(const wxString& start) { m_Start = start; }
// returns full filename of page (which is part of the book),
// i.e. with book's basePath prepended. If page is already absolute
// path, basePath is _not_ prepended.
wxString GetFullPath(const wxString &page) const;
protected:
wxString m_BookFile;
wxString m_BasePath;
wxString m_Title;
wxString m_Start;
int m_ContentsStart;
int m_ContentsEnd;
};
WX_DECLARE_USER_EXPORTED_OBJARRAY(wxHtmlBookRecord, wxHtmlBookRecArray,
WXDLLIMPEXP_HTML);
struct WXDLLIMPEXP_HTML wxHtmlHelpDataItem
{
wxHtmlHelpDataItem() : level(0), parent(NULL), id(wxID_ANY), book(NULL) {}
int level;
wxHtmlHelpDataItem *parent;
int id;
wxString name;
wxString page;
wxHtmlBookRecord *book;
// returns full filename of m_Page, i.e. with book's basePath prepended
wxString GetFullPath() const { return book->GetFullPath(page); }
// returns item indented with spaces if it has level>1:
wxString GetIndentedName() const;
};
WX_DECLARE_USER_EXPORTED_OBJARRAY(wxHtmlHelpDataItem, wxHtmlHelpDataItems,
WXDLLIMPEXP_HTML);
//------------------------------------------------------------------------------
// wxHtmlSearchEngine
// This class takes input streams and scans them for occurrence
// of keyword(s)
//------------------------------------------------------------------------------
class WXDLLIMPEXP_HTML wxHtmlSearchEngine : public wxObject
{
public:
wxHtmlSearchEngine() : wxObject() {}
virtual ~wxHtmlSearchEngine() {}
// Sets the keyword we will be searching for
virtual void LookFor(const wxString& keyword, bool case_sensitive, bool whole_words_only);
// Scans the stream for the keyword.
// Returns true if the stream contains keyword, fALSE otherwise
virtual bool Scan(const wxFSFile& file);
private:
wxString m_Keyword;
bool m_CaseSensitive;
bool m_WholeWords;
wxDECLARE_NO_COPY_CLASS(wxHtmlSearchEngine);
};
// State information of a search action. I'd have preferred to make this a
// nested class inside wxHtmlHelpData, but that's against coding standards :-(
// Never construct this class yourself, obtain a copy from
// wxHtmlHelpData::PrepareKeywordSearch(const wxString& key)
class WXDLLIMPEXP_HTML wxHtmlSearchStatus
{
public:
// constructor; supply wxHtmlHelpData ptr, the keyword and (optionally) the
// title of the book to search. By default, all books are searched.
wxHtmlSearchStatus(wxHtmlHelpData* base, const wxString& keyword,
bool case_sensitive, bool whole_words_only,
const wxString& book = wxEmptyString);
bool Search(); // do the next iteration
bool IsActive() { return m_Active; }
int GetCurIndex() { return m_CurIndex; }
int GetMaxIndex() { return m_MaxIndex; }
const wxString& GetName() { return m_Name; }
const wxHtmlHelpDataItem *GetCurItem() const { return m_CurItem; }
private:
wxHtmlHelpData* m_Data;
wxHtmlSearchEngine m_Engine;
wxString m_Keyword, m_Name;
wxString m_LastPage;
wxHtmlHelpDataItem* m_CurItem;
bool m_Active; // search is not finished
int m_CurIndex; // where we are now
int m_MaxIndex; // number of files we search
// For progress bar: 100*curindex/maxindex = % complete
wxDECLARE_NO_COPY_CLASS(wxHtmlSearchStatus);
};
class WXDLLIMPEXP_HTML wxHtmlHelpData : public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlHelpData);
friend class wxHtmlSearchStatus;
public:
wxHtmlHelpData();
virtual ~wxHtmlHelpData();
// Sets directory where temporary files are stored.
// These temp files are index & contents file in binary (much faster to read)
// form. These files are NOT deleted on program's exit.
void SetTempDir(const wxString& path);
// Adds new book. 'book' is location of .htb file (stands for "html book").
// See documentation for details on its format.
// Returns success.
bool AddBook(const wxString& book);
bool AddBookParam(const wxFSFile& bookfile,
wxFontEncoding encoding,
const wxString& title, const wxString& contfile,
const wxString& indexfile = wxEmptyString,
const wxString& deftopic = wxEmptyString,
const wxString& path = wxEmptyString);
// Some accessing stuff:
// returns URL of page on basis of (file)name
wxString FindPageByName(const wxString& page);
// returns URL of page on basis of MS id
wxString FindPageById(int id);
const wxHtmlBookRecArray& GetBookRecArray() const { return m_bookRecords; }
const wxHtmlHelpDataItems& GetContentsArray() const { return m_contents; }
const wxHtmlHelpDataItems& GetIndexArray() const { return m_index; }
protected:
wxString m_tempPath;
// each book has one record in this array:
wxHtmlBookRecArray m_bookRecords;
wxHtmlHelpDataItems m_contents; // list of all available books and pages
wxHtmlHelpDataItems m_index; // list of index itesm
protected:
// Imports .hhp files (MS HTML Help Workshop)
bool LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys,
const wxString& indexfile, const wxString& contentsfile);
// Reads binary book
bool LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f);
// Writes binary book
bool SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f);
wxDECLARE_NO_COPY_CLASS(wxHtmlHelpData);
};
#endif
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/dcclient.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/dcclient.h
// Purpose: wxWindowDCImpl, wxClientDCImpl and wxPaintDCImpl
// Author: Vaclav Slavik
// Created: 2006-08-10
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_DCCLIENT_H_
#define _WX_DFB_DCCLIENT_H_
#include "wx/dfb/dc.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
//-----------------------------------------------------------------------------
// wxWindowDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDCImpl : public wxDFBDCImpl
{
public:
wxWindowDCImpl(wxDC *owner) : wxDFBDCImpl(owner), m_shouldFlip(false) { }
wxWindowDCImpl(wxDC *owner, wxWindow *win);
virtual ~wxWindowDCImpl();
protected:
// initializes the DC for painting on given window; if rect!=NULL, then
// for painting only on the given region of the window
void InitForWin(wxWindow *win, const wxRect *rect);
private:
wxRect m_winRect; // rectangle of the window being painted
bool m_shouldFlip; // flip the surface when done?
friend class wxOverlayImpl; // for m_shouldFlip;
wxDECLARE_DYNAMIC_CLASS(wxWindowDCImpl);
wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
//-----------------------------------------------------------------------------
// wxClientDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
{
public:
wxClientDCImpl(wxDC *owner) : wxWindowDCImpl(owner) { }
wxClientDCImpl(wxDC *owner, wxWindow *win);
wxDECLARE_DYNAMIC_CLASS(wxClientDCImpl);
wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
//-----------------------------------------------------------------------------
// wxPaintDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
{
public:
wxPaintDCImpl(wxDC *owner) : wxClientDCImpl(owner) { }
wxPaintDCImpl(wxDC *owner, wxWindow *win) : wxClientDCImpl(owner, win) { }
wxDECLARE_DYNAMIC_CLASS(wxPaintDCImpl);
wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
#endif // _WX_DFB_DCCLIENT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/font.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/font.h
// Author: Vaclav Slavik
// Purpose: wxFont declaration
// Created: 2006-08-08
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_FONT_H_
#define _WX_DFB_FONT_H_
#include "wx/dfb/dfbptr.h"
wxDFB_DECLARE_INTERFACE(IDirectFBFont);
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFont : public wxFontBase
{
public:
wxFont() {}
wxFont(const wxFontInfo& info)
{
Create(info.GetPointSize(),
info.GetFamily(),
info.GetStyle(),
info.GetWeight(),
info.IsUnderlined(),
info.GetFaceName(),
info.GetEncoding());
if ( info.IsUsingSizeInPixels() )
SetPixelSize(info.GetPixelSize());
}
wxFont(const wxNativeFontInfo& info) { Create(info); }
wxFont(const wxString& nativeFontInfoString);
wxFont(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(size, family, style, weight, underlined, face, encoding);
}
wxFont(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(10, family, style, weight, underlined, face, encoding);
SetPixelSize(pixelSize);
}
bool Create(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
bool Create(const wxNativeFontInfo& fontinfo);
// implement base class pure virtuals
virtual float GetFractionalPointSize() const;
virtual wxFontStyle GetStyle() const;
virtual int GetNumericWeight() const;
virtual wxString GetFaceName() const;
virtual bool GetUnderlined() const;
virtual wxFontEncoding GetEncoding() const;
virtual bool IsFixedWidth() const;
virtual const wxNativeFontInfo *GetNativeFontInfo() const;
virtual void SetFractionalPointSize(float pointSize);
virtual void SetFamily(wxFontFamily family);
virtual void SetStyle(wxFontStyle style);
virtual void SetNumericWeight(int weight);
virtual bool SetFaceName(const wxString& faceName);
virtual void SetUnderlined(bool underlined);
virtual void SetEncoding(wxFontEncoding encoding);
wxDECLARE_COMMON_FONT_METHODS();
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants")
wxFont(int size,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(size, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight, underlined, face, encoding);
}
// implementation from now on:
wxIDirectFBFontPtr GetDirectFBFont(bool antialiased) const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual wxFontFamily DoGetFamily() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxFont);
};
#endif // _WX_DFB_FONT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/nonownedwnd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/nonownedwnd.h
// Purpose: declares wxNonOwnedWindow class
// Author: Vaclav Slavik
// Modified by:
// Created: 2006-12-24
// Copyright: (c) 2006 TT-Solutions
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_NONOWNEDWND_H_
#define _WX_DFB_NONOWNEDWND_H_
#include "wx/window.h"
#include "wx/dfb/dfbptr.h"
wxDFB_DECLARE_INTERFACE(IDirectFBWindow);
class wxDfbQueuedPaintRequests;
struct wxDFBWindowEvent;
class wxDFBEventsHandler;
//-----------------------------------------------------------------------------
// wxNonOwnedWindow
//-----------------------------------------------------------------------------
// This class represents "non-owned" window. A window is owned by another
// window if it has a parent and is positioned within the parent. For example,
// wxFrame is non-owned, because even though it can have a parent, it's
// location is independent of it. This class is for internal use only, it's
// the base class for wxTopLevelWindow and wxPopupWindow.
class WXDLLIMPEXP_CORE wxNonOwnedWindow : public wxNonOwnedWindowBase
{
public:
// construction
wxNonOwnedWindow() { Init(); }
wxNonOwnedWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
virtual ~wxNonOwnedWindow();
// implement base class pure virtuals
virtual bool Show(bool show = true);
virtual void Update();
virtual void Raise();
virtual void Lower();
// implementation from now on
// --------------------------
void OnInternalIdle();
wxIDirectFBWindowPtr GetDirectFBWindow() const { return m_dfbwin; }
// Returns true if some invalidated area of the TLW is currently being
// painted
bool IsPainting() const { return m_isPainting; }
protected:
// common part of all ctors
void Init();
virtual wxIDirectFBSurfacePtr ObtainDfbSurface() const;
// overridden wxWindow methods
virtual void DoGetPosition(int *x, int *y) const;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual void DoRefreshRect(const wxRect& rect);
// sets DirectFB keyboard focus to this toplevel window (note that DFB
// focus is different from wx: only shown TLWs can have it and not any
// wxWindows as in wx
void SetDfbFocus();
// overridden in wxTopLevelWindowDFB, there's no common handling for wxTLW
// and wxPopupWindow to be done here
virtual void HandleFocusEvent(const wxDFBWindowEvent& WXUNUSED(event_)) {}
private:
// do queued painting in idle time
void HandleQueuedPaintRequests();
// DirectFB events handling
static void HandleDFBWindowEvent(const wxDFBWindowEvent& event_);
protected:
// did we sent wxSizeEvent at least once?
bool m_sizeSet:1;
// window's opacity (0: transparent, 255: opaque)
wxByte m_opacity;
// interface to the underlying DirectFB window
wxIDirectFBWindowPtr m_dfbwin;
private:
// invalidated areas of the TLW that need repainting
wxDfbQueuedPaintRequests *m_toPaint;
// are we currently painting some area of this TLW?
bool m_isPainting;
friend class wxDFBEventsHandler; // for HandleDFBWindowEvent
friend class wxWindowDFB; // for SetDfbFocus
};
#endif // _WX_DFB_NONOWNEDWND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/app.h
// Purpose: wxApp class
// Author: Vaclav Slavik
// Created: 2006-08-10
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_APP_H_
#define _WX_DFB_APP_H_
#include "wx/dfb/dfbptr.h"
#include "wx/vidmode.h"
wxDFB_DECLARE_INTERFACE(IDirectFB);
//-----------------------------------------------------------------------------
// wxApp
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxApp: public wxAppBase
{
public:
wxApp();
~wxApp();
// override base class (pure) virtuals
virtual bool Initialize(int& argc, wxChar **argv);
virtual void CleanUp();
virtual void WakeUpIdle();
virtual wxVideoMode GetDisplayMode() const;
virtual bool SetDisplayMode(const wxVideoMode& mode);
private:
wxVideoMode m_videoMode;
wxDECLARE_DYNAMIC_CLASS(wxApp);
};
#endif // _WX_DFB_APP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/dcmemory.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/dcmemory.h
// Purpose: wxMemoryDC class declaration
// Created: 2006-08-10
// Author: Vaclav Slavik
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_DCMEMORY_H_
#define _WX_DFB_DCMEMORY_H_
#include "wx/dfb/dc.h"
#include "wx/bitmap.h"
class WXDLLIMPEXP_CORE wxMemoryDCImpl : public wxDFBDCImpl
{
public:
wxMemoryDCImpl(wxMemoryDC *owner);
wxMemoryDCImpl(wxMemoryDC *owner, wxBitmap& bitmap);
wxMemoryDCImpl(wxMemoryDC *owner, wxDC *dc); // create compatible DC
// override wxMemoryDC-specific base class virtual methods
virtual const wxBitmap& GetSelectedBitmap() const { return m_bmp; }
virtual wxBitmap& GetSelectedBitmap() { return m_bmp; }
virtual void DoSelect(const wxBitmap& bitmap);
private:
void Init();
wxBitmap m_bmp;
wxDECLARE_DYNAMIC_CLASS(wxMemoryDCImpl);
};
#endif // _WX_DFB_DCMEMORY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/toplevel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/toplevel.h
// Purpose: Top level window, abstraction of wxFrame and wxDialog
// Author: Vaclav Slavik
// Created: 2006-08-10
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_TOPLEVEL_H_
#define _WX_DFB_TOPLEVEL_H_
//-----------------------------------------------------------------------------
// wxTopLevelWindowDFB
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindowDFB : public wxTopLevelWindowBase
{
public:
// construction
wxTopLevelWindowDFB() { Init(); }
wxTopLevelWindowDFB(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
// implement base class pure virtuals
virtual void Maximize(bool maximize = true);
virtual bool IsMaximized() const;
virtual void Iconize(bool iconize = true);
virtual bool IsIconized() const;
virtual void Restore();
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL);
virtual bool IsFullScreen() const { return m_fsIsShowing; }
virtual bool CanSetTransparent() { return true; }
virtual bool SetTransparent(wxByte alpha);
virtual void SetTitle(const wxString &title) { m_title = title; }
virtual wxString GetTitle() const { return m_title; }
protected:
// common part of all ctors
void Init();
virtual void HandleFocusEvent(const wxDFBWindowEvent& event_);
protected:
wxString m_title;
bool m_fsIsShowing:1; /* full screen */
long m_fsSaveStyle;
long m_fsSaveFlag;
wxRect m_fsSaveFrame;
// is the frame currently maximized?
bool m_isMaximized:1;
wxRect m_savedFrame;
};
#endif // _WX_DFB_TOPLEVEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/wrapdfb.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/wrapdfb.h
// Purpose: wx wrappers for DirectFB interfaces
// Author: Vaclav Slavik
// Created: 2006-08-23
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_WRAPDFB_H_
#define _WX_DFB_WRAPDFB_H_
#include "wx/dfb/dfbptr.h"
#include "wx/gdicmn.h"
#include "wx/vidmode.h"
#include <directfb.h>
#include <directfb_version.h>
// DFB < 1.0 didn't have u8 type, only __u8
#if DIRECTFB_MAJOR_VERSION == 0
typedef __u8 u8;
#endif
wxDFB_DECLARE_INTERFACE(IDirectFB);
wxDFB_DECLARE_INTERFACE(IDirectFBDisplayLayer);
wxDFB_DECLARE_INTERFACE(IDirectFBFont);
wxDFB_DECLARE_INTERFACE(IDirectFBWindow);
wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
wxDFB_DECLARE_INTERFACE(IDirectFBPalette);
wxDFB_DECLARE_INTERFACE(IDirectFBEventBuffer);
/**
Checks the @a code of a DirectFB call and returns true if it was
successful and false if it failed, logging the errors as appropriate
(asserts for programming errors, wxLogError for runtime failures).
*/
bool wxDfbCheckReturn(DFBResult code);
//-----------------------------------------------------------------------------
// wxDfbEvent
//-----------------------------------------------------------------------------
/**
The struct defined by this macro is a thin wrapper around DFB*Event type.
It is needed because DFB*Event are typedefs and so we can't forward declare
them, but we need to pass them to methods declared in public headers where
<directfb.h> cannot be included. So this struct just holds the event value,
it's sole purpose is that it can be forward declared.
*/
#define WXDFB_DEFINE_EVENT_WRAPPER(T) \
struct wx##T \
{ \
wx##T() {} \
wx##T(const T& event) : m_event(event) {} \
\
operator T&() { return m_event; } \
operator const T&() const { return m_event; } \
T* operator&() { return &m_event; } \
\
DFBEventClass GetClass() const { return m_event.clazz; } \
\
private: \
T m_event; \
};
WXDFB_DEFINE_EVENT_WRAPPER(DFBEvent)
WXDFB_DEFINE_EVENT_WRAPPER(DFBWindowEvent)
//-----------------------------------------------------------------------------
// wxDfbWrapper<T>
//-----------------------------------------------------------------------------
/// Base class for wxDfbWrapper<T>
class wxDfbWrapperBase
{
public:
/// Increases reference count of the object
void AddRef()
{
m_refCnt++;
}
/// Decreases reference count and if it reaches zero, deletes the object
void Release()
{
if ( --m_refCnt == 0 )
delete this;
}
/// Returns result code of the last call
DFBResult GetLastResult() const { return m_lastResult; }
protected:
wxDfbWrapperBase() : m_refCnt(1), m_lastResult(DFB_OK) {}
/// Dtor may only be called from Release()
virtual ~wxDfbWrapperBase() {}
/**
Checks the @a result of a DirectFB call and returns true if it was
successful and false if it failed. Also stores result of the call
so that it can be obtained by calling GetLastResult().
*/
bool Check(DFBResult result)
{
m_lastResult = result;
return wxDfbCheckReturn(result);
}
protected:
/// Reference count
unsigned m_refCnt;
/// Result of the last DirectFB call
DFBResult m_lastResult;
};
/**
This template is base class for friendly C++ wrapper around DirectFB
interface T.
The wrapper provides same API as DirectFB, with a few exceptions:
- methods return true/false instead of error code
- methods that return or create another interface return pointer to the
interface (or NULL on failure) instead of storing it in the last
argument
- interface arguments use wxFooPtr type instead of raw DirectFB pointer
- methods taking flags use int type instead of an enum when the flags
can be or-combination of enum elements (this is workaround for
C++-unfriendly DirectFB API)
*/
template<typename T>
class wxDfbWrapper : public wxDfbWrapperBase
{
public:
/// "Raw" DirectFB interface type
typedef T DirectFBIface;
/// Returns raw DirectFB pointer
T *GetRaw() const { return m_ptr; }
protected:
/// To be called from ctor. Takes ownership of raw object.
void Init(T *ptr) { m_ptr = ptr; }
/// Dtor may only be used from Release
~wxDfbWrapper()
{
if ( m_ptr )
m_ptr->Release(m_ptr);
}
protected:
// pointer to DirectFB object
T *m_ptr;
};
//-----------------------------------------------------------------------------
// wxIDirectFBFont
//-----------------------------------------------------------------------------
struct wxIDirectFBFont : public wxDfbWrapper<IDirectFBFont>
{
wxIDirectFBFont(IDirectFBFont *s) { Init(s); }
bool GetStringWidth(const char *text, int bytes, int *w)
{ return Check(m_ptr->GetStringWidth(m_ptr, text, bytes, w)); }
bool GetStringExtents(const char *text, int bytes,
DFBRectangle *logicalRect, DFBRectangle *inkRect)
{
return Check(m_ptr->GetStringExtents(m_ptr, text, bytes,
logicalRect, inkRect));
}
bool GetHeight(int *h)
{ return Check(m_ptr->GetHeight(m_ptr, h)); }
bool GetDescender(int *descender)
{ return Check(m_ptr->GetDescender(m_ptr, descender)); }
};
//-----------------------------------------------------------------------------
// wxIDirectFBPalette
//-----------------------------------------------------------------------------
struct wxIDirectFBPalette : public wxDfbWrapper<IDirectFBPalette>
{
wxIDirectFBPalette(IDirectFBPalette *s) { Init(s); }
};
//-----------------------------------------------------------------------------
// wxIDirectFBSurface
//-----------------------------------------------------------------------------
struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
{
wxIDirectFBSurface(IDirectFBSurface *s) { Init(s); }
bool GetSize(int *w, int *h)
{ return Check(m_ptr->GetSize(m_ptr, w, h)); }
bool GetCapabilities(DFBSurfaceCapabilities *caps)
{ return Check(m_ptr->GetCapabilities(m_ptr, caps)); }
bool GetPixelFormat(DFBSurfacePixelFormat *caps)
{ return Check(m_ptr->GetPixelFormat(m_ptr, caps)); }
// convenience version of GetPixelFormat, returns DSPF_UNKNOWN if fails
DFBSurfacePixelFormat GetPixelFormat();
bool SetClip(const DFBRegion *clip)
{ return Check(m_ptr->SetClip(m_ptr, clip)); }
bool SetColor(u8 r, u8 g, u8 b, u8 a)
{ return Check(m_ptr->SetColor(m_ptr, r, g, b, a)); }
bool Clear(u8 r, u8 g, u8 b, u8 a)
{ return Check(m_ptr->Clear(m_ptr, r, g, b, a)); }
bool DrawLine(int x1, int y1, int x2, int y2)
{ return Check(m_ptr->DrawLine(m_ptr, x1, y1, x2, y2)); }
bool DrawRectangle(int x, int y, int w, int h)
{ return Check(m_ptr->DrawRectangle(m_ptr, x, y, w, h)); }
bool FillRectangle(int x, int y, int w, int h)
{ return Check(m_ptr->FillRectangle(m_ptr, x, y, w, h)); }
bool SetFont(const wxIDirectFBFontPtr& font)
{ return Check(m_ptr->SetFont(m_ptr, font->GetRaw())); }
bool DrawString(const char *text, int bytes, int x, int y, int flags)
{
return Check(m_ptr->DrawString(m_ptr, text, bytes, x, y,
(DFBSurfaceTextFlags)flags));
}
/**
Updates the front buffer from the back buffer. If @a region is not
NULL, only given rectangle is updated.
*/
bool FlipToFront(const DFBRegion *region = NULL);
wxIDirectFBSurfacePtr GetSubSurface(const DFBRectangle *rect)
{
IDirectFBSurface *s;
if ( Check(m_ptr->GetSubSurface(m_ptr, rect, &s)) )
return new wxIDirectFBSurface(s);
else
return NULL;
}
wxIDirectFBPalettePtr GetPalette()
{
IDirectFBPalette *s;
if ( Check(m_ptr->GetPalette(m_ptr, &s)) )
return new wxIDirectFBPalette(s);
else
return NULL;
}
bool SetPalette(const wxIDirectFBPalettePtr& pal)
{ return Check(m_ptr->SetPalette(m_ptr, pal->GetRaw())); }
bool SetBlittingFlags(int flags)
{
return Check(
m_ptr->SetBlittingFlags(m_ptr, (DFBSurfaceBlittingFlags)flags));
}
bool Blit(const wxIDirectFBSurfacePtr& source,
const DFBRectangle *source_rect,
int x, int y)
{ return Blit(source->GetRaw(), source_rect, x, y); }
bool Blit(IDirectFBSurface *source,
const DFBRectangle *source_rect,
int x, int y)
{ return Check(m_ptr->Blit(m_ptr, source, source_rect, x, y)); }
bool StretchBlit(const wxIDirectFBSurfacePtr& source,
const DFBRectangle *source_rect,
const DFBRectangle *dest_rect)
{
return Check(m_ptr->StretchBlit(m_ptr, source->GetRaw(),
source_rect, dest_rect));
}
/// Returns bit depth used by the surface or -1 on error
int GetDepth();
/**
Creates a new surface by cloning this one. New surface will have same
capabilities, pixel format and pixel data as the existing one.
@see CreateCompatible
*/
wxIDirectFBSurfacePtr Clone();
/// Flags for CreateCompatible()
enum CreateCompatibleFlags
{
/// Don't create double-buffered surface
CreateCompatible_NoBackBuffer = 1
};
/**
Creates a surface compatible with this one, i.e. surface with the same
capabilities and pixel format, but with different and size.
@param size Size of the surface to create. If wxDefaultSize, use the
size of this surface.
@param flags Or-combination of CreateCompatibleFlags values
*/
wxIDirectFBSurfacePtr CreateCompatible(const wxSize& size = wxDefaultSize,
int flags = 0);
bool Lock(DFBSurfaceLockFlags flags, void **ret_ptr, int *ret_pitch)
{ return Check(m_ptr->Lock(m_ptr, flags, ret_ptr, ret_pitch)); }
bool Unlock()
{ return Check(m_ptr->Unlock(m_ptr)); }
/// Helper struct for safe locking & unlocking of surfaces
struct Locked
{
Locked(const wxIDirectFBSurfacePtr& surface, DFBSurfaceLockFlags flags)
: m_surface(surface)
{
if ( !surface->Lock(flags, &ptr, &pitch) )
ptr = NULL;
}
~Locked()
{
if ( ptr )
m_surface->Unlock();
}
void *ptr;
int pitch;
private:
wxIDirectFBSurfacePtr m_surface;
};
private:
// this is private because we want user code to use FlipToFront()
bool Flip(const DFBRegion *region, int flags);
};
//-----------------------------------------------------------------------------
// wxIDirectFBEventBuffer
//-----------------------------------------------------------------------------
struct wxIDirectFBEventBuffer : public wxDfbWrapper<IDirectFBEventBuffer>
{
wxIDirectFBEventBuffer(IDirectFBEventBuffer *s) { Init(s); }
bool CreateFileDescriptor(int *ret_fd)
{
return Check(m_ptr->CreateFileDescriptor(m_ptr, ret_fd));
}
};
//-----------------------------------------------------------------------------
// wxIDirectFBWindow
//-----------------------------------------------------------------------------
struct wxIDirectFBWindow : public wxDfbWrapper<IDirectFBWindow>
{
wxIDirectFBWindow(IDirectFBWindow *s) { Init(s); }
bool GetID(DFBWindowID *id)
{ return Check(m_ptr->GetID(m_ptr, id)); }
bool GetPosition(int *x, int *y)
{ return Check(m_ptr->GetPosition(m_ptr, x, y)); }
bool GetSize(int *w, int *h)
{ return Check(m_ptr->GetSize(m_ptr, w, h)); }
bool MoveTo(int x, int y)
{ return Check(m_ptr->MoveTo(m_ptr, x, y)); }
bool Resize(int w, int h)
{ return Check(m_ptr->Resize(m_ptr, w, h)); }
bool SetOpacity(u8 opacity)
{ return Check(m_ptr->SetOpacity(m_ptr, opacity)); }
bool SetStackingClass(DFBWindowStackingClass klass)
{ return Check(m_ptr->SetStackingClass(m_ptr, klass)); }
bool RaiseToTop()
{ return Check(m_ptr->RaiseToTop(m_ptr)); }
bool LowerToBottom()
{ return Check(m_ptr->LowerToBottom(m_ptr)); }
wxIDirectFBSurfacePtr GetSurface()
{
IDirectFBSurface *s;
if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
return new wxIDirectFBSurface(s);
else
return NULL;
}
bool AttachEventBuffer(const wxIDirectFBEventBufferPtr& buffer)
{ return Check(m_ptr->AttachEventBuffer(m_ptr, buffer->GetRaw())); }
bool RequestFocus()
{ return Check(m_ptr->RequestFocus(m_ptr)); }
bool Destroy()
{ return Check(m_ptr->Destroy(m_ptr)); }
};
//-----------------------------------------------------------------------------
// wxIDirectFBDisplayLayer
//-----------------------------------------------------------------------------
struct wxIDirectFBDisplayLayer : public wxDfbWrapper<IDirectFBDisplayLayer>
{
wxIDirectFBDisplayLayer(IDirectFBDisplayLayer *s) { Init(s); }
wxIDirectFBWindowPtr CreateWindow(const DFBWindowDescription *desc)
{
IDirectFBWindow *w;
if ( Check(m_ptr->CreateWindow(m_ptr, desc, &w)) )
return new wxIDirectFBWindow(w);
else
return NULL;
}
bool GetConfiguration(DFBDisplayLayerConfig *config)
{ return Check(m_ptr->GetConfiguration(m_ptr, config)); }
wxVideoMode GetVideoMode();
bool GetCursorPosition(int *x, int *y)
{ return Check(m_ptr->GetCursorPosition(m_ptr, x, y)); }
bool WarpCursor(int x, int y)
{ return Check(m_ptr->WarpCursor(m_ptr, x, y)); }
};
//-----------------------------------------------------------------------------
// wxIDirectFB
//-----------------------------------------------------------------------------
struct wxIDirectFB : public wxDfbWrapper<IDirectFB>
{
/**
Returns pointer to DirectFB singleton object, it never returns NULL
after wxApp was initialized. The object is cached, so calling this
method is cheap.
*/
static wxIDirectFBPtr Get()
{
if ( !ms_ptr ) CreateDirectFB();
return ms_ptr;
}
bool SetVideoMode(int w, int h, int bpp)
{ return Check(m_ptr->SetVideoMode(m_ptr, w, h, bpp)); }
wxIDirectFBSurfacePtr CreateSurface(const DFBSurfaceDescription *desc)
{
IDirectFBSurface *s;
if ( Check(m_ptr->CreateSurface(m_ptr, desc, &s)) )
return new wxIDirectFBSurface(s);
else
return NULL;
}
wxIDirectFBEventBufferPtr CreateEventBuffer()
{
IDirectFBEventBuffer *b;
if ( Check(m_ptr->CreateEventBuffer(m_ptr, &b)) )
return new wxIDirectFBEventBuffer(b);
else
return NULL;
}
wxIDirectFBFontPtr CreateFont(const char *filename,
const DFBFontDescription *desc)
{
IDirectFBFont *f;
if ( Check(m_ptr->CreateFont(m_ptr, filename, desc, &f)) )
return new wxIDirectFBFont(f);
else
return NULL;
}
wxIDirectFBDisplayLayerPtr
GetDisplayLayer(DFBDisplayLayerID id = DLID_PRIMARY)
{
IDirectFBDisplayLayer *l;
if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )
return new wxIDirectFBDisplayLayer(l);
else
return NULL;
}
/// Returns primary surface
wxIDirectFBSurfacePtr GetPrimarySurface();
private:
wxIDirectFB(IDirectFB *ptr) { Init(ptr); }
// creates ms_ptr instance
static void CreateDirectFB();
static void CleanUp();
friend class wxApp; // calls CleanUp
// pointer to the singleton IDirectFB object
static wxIDirectFBPtr ms_ptr;
};
#endif // _WX_DFB_WRAPDFB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/region.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/region.h
// Purpose: wxRegion class
// Author: Vaclav Slavik
// Created: 2006-08-08
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_REGION_H_
#define _WX_DFB_REGION_H_
class WXDLLIMPEXP_CORE wxRegion : public wxRegionBase
{
public:
wxRegion();
wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
wxRegion(const wxRect& rect);
wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
wxRegion(const wxBitmap& bmp)
{
Union(bmp);
}
wxRegion(const wxBitmap& bmp,
const wxColour& transColour, int tolerance = 0)
{
Union(bmp, transColour, tolerance);
}
virtual ~wxRegion();
// wxRegionBase methods
virtual void Clear();
virtual bool IsEmpty() const;
// NB: implementation detail of DirectFB, should be removed if full
// (i.e. not rect-only version is implemented) so that all code that
// assumes region==rect breaks
wxRect AsRect() const { return GetBox(); }
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const;
virtual wxRegionContain DoContainsRect(const wxRect& rect) const;
virtual bool DoOffset(wxCoord x, wxCoord y);
virtual bool DoUnionWithRect(const wxRect& rect);
virtual bool DoUnionWithRegion(const wxRegion& region);
virtual bool DoIntersect(const wxRegion& region);
virtual bool DoSubtract(const wxRegion& region);
virtual bool DoXor(const wxRegion& region);
friend class WXDLLIMPEXP_FWD_CORE wxRegionIterator;
wxDECLARE_DYNAMIC_CLASS(wxRegion);
};
class WXDLLIMPEXP_CORE wxRegionIterator : public wxObject
{
public:
wxRegionIterator() {}
wxRegionIterator(const wxRegion& region) { Reset(region); }
void Reset() { m_rect = wxRect(); }
void Reset(const wxRegion& region);
bool HaveRects() const { return !m_rect.IsEmpty(); }
operator bool() const { return HaveRects(); }
wxRegionIterator& operator++();
wxRegionIterator operator++(int);
wxCoord GetX() const { return m_rect.GetX(); }
wxCoord GetY() const { return m_rect.GetY(); }
wxCoord GetW() const { return m_rect.GetWidth(); }
wxCoord GetWidth() const { return GetW(); }
wxCoord GetH() const { return m_rect.GetHeight(); }
wxCoord GetHeight() const { return GetH(); }
wxRect GetRect() const { return m_rect; }
private:
wxRect m_rect;
wxDECLARE_DYNAMIC_CLASS(wxRegionIterator);
};
#endif // _WX_DFB_REGION_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/evtloop.h
// Purpose: declares wxEventLoop class
// Author: Vaclav Slavik
// Created: 2006-08-16
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_EVTLOOP_H_
#define _WX_DFB_EVTLOOP_H_
#include "wx/dfb/dfbptr.h"
#include "wx/unix/evtloop.h"
wxDFB_DECLARE_INTERFACE(IDirectFBEventBuffer);
// ----------------------------------------------------------------------------
// wxEventLoop
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxConsoleEventLoop
{
public:
wxGUIEventLoop();
// returns DirectFB event buffer used by wx
static wxIDirectFBEventBufferPtr GetDirectFBEventBuffer();
protected:
virtual void DoYieldFor(long eventsToProcess);
private:
static void InitBuffer();
static void CleanUp();
friend class wxApp; // calls CleanUp()
private:
static wxIDirectFBEventBufferPtr ms_buffer;
static int ms_bufferFd;
wxDECLARE_NO_COPY_CLASS(wxGUIEventLoop);
};
#endif // _WX_DFB_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/private.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/private.h
// Purpose: private helpers for wxDFB implementation
// Author: Vaclav Slavik
// Created: 2006-08-09
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_PRIVATE_H_
#define _WX_DFB_PRIVATE_H_
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/dfb/wrapdfb.h"
#include <directfb_version.h>
//-----------------------------------------------------------------------------
// misc helpers
//-----------------------------------------------------------------------------
/// Convert DirectFB timestamp to wxEvent one:
#define wxDFB_EVENT_TIMESTAMP(event) \
((event).timestamp.tv_sec * 1000 + (event).timestamp.tv_usec / 1000)
/**
Check if DirectFB library version is at least @a major.@a minor.@a release.
@see wxCHECK_VERSION
*/
#define wxCHECK_DFB_VERSION(major,minor,release) \
(DIRECTFB_MAJOR_VERSION > (major) || \
(DIRECTFB_MAJOR_VERSION == (major) && \
DIRECTFB_MINOR_VERSION > (minor)) || \
(DIRECTFB_MAJOR_VERSION == (major) && \
DIRECTFB_MINOR_VERSION == (minor) && \
DIRECTFB_MICRO_VERSION >= (release)))
#endif // _WX_DFB_PRIVATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/bitmap.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/bitmap.h
// Purpose: wxBitmap class
// Author: Vaclav Slavik
// Created: 2006-08-04
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_BITMAP_H_
#define _WX_DFB_BITMAP_H_
#include "wx/dfb/dfbptr.h"
class WXDLLIMPEXP_FWD_CORE wxPixelDataBase;
wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
//-----------------------------------------------------------------------------
// wxBitmap
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmap : public wxBitmapBase
{
public:
wxBitmap() {}
wxBitmap(const wxIDirectFBSurfacePtr& surface) { Create(surface); }
wxBitmap(int width, int height, int depth = -1) { Create(width, height, depth); }
wxBitmap(const wxSize& sz, int depth = -1) { Create(sz, depth); }
wxBitmap(const char bits[], int width, int height, int depth = 1);
wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
wxBitmap(const char* const* bits);
#if wxUSE_IMAGE
wxBitmap(const wxImage& image, int depth = -1, double WXUNUSED(scale) = 1.0);
#endif
bool Create(const wxIDirectFBSurfacePtr& surface);
bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
bool Create(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH)
{ return Create(sz.GetWidth(), sz.GetHeight(), depth); }
bool Create(int width, int height, const wxDC& WXUNUSED(dc))
{ return Create(width,height); }
virtual int GetHeight() const;
virtual int GetWidth() const;
virtual int GetDepth() const;
#if wxUSE_IMAGE
virtual wxImage ConvertToImage() const;
#endif
virtual wxMask *GetMask() const;
virtual void SetMask(wxMask *mask);
virtual wxBitmap GetSubBitmap(const wxRect& rect) const;
virtual bool SaveFile(const wxString &name, wxBitmapType type,
const wxPalette *palette = NULL) const;
virtual bool LoadFile(const wxString &name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
#if wxUSE_PALETTE
virtual wxPalette *GetPalette() const;
virtual void SetPalette(const wxPalette& palette);
#endif
// copies the contents and mask of the given (colour) icon to the bitmap
virtual bool CopyFromIcon(const wxIcon& icon);
static void InitStandardHandlers();
// raw bitmap access support functions
void *GetRawData(wxPixelDataBase& data, int bpp);
void UngetRawData(wxPixelDataBase& data);
bool HasAlpha() const;
// implementation:
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED(virtual void SetHeight(int height));
wxDEPRECATED(virtual void SetWidth(int width));
wxDEPRECATED(virtual void SetDepth(int depth));
#endif
// get underlying native representation:
wxIDirectFBSurfacePtr GetDirectFBSurface() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
bool CreateWithFormat(int width, int height, int dfbFormat);
wxDECLARE_DYNAMIC_CLASS(wxBitmap);
};
#endif // _WX_DFB_BITMAP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/dfbptr.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/dfbptr.h
// Purpose: wxDfbPtr<T> for holding objects declared in wrapdfb.h
// Author: Vaclav Slavik
// Created: 2006-08-09
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_DFBPTR_H_
#define _WX_DFB_DFBPTR_H_
//-----------------------------------------------------------------------------
// wxDFB_DECLARE_INTERFACE
//-----------------------------------------------------------------------------
/**
Forward declares wx wrapper around DirectFB interface @a name.
Also declares wx##name##Ptr typedef for wxDfbPtr<wx##name> pointer.
@param name name of the DirectFB interface
*/
#define wxDFB_DECLARE_INTERFACE(name) \
class wx##name; \
typedef wxDfbPtr<wx##name> wx##name##Ptr;
//-----------------------------------------------------------------------------
// wxDfbPtr<T>
//-----------------------------------------------------------------------------
class wxDfbWrapperBase;
class WXDLLIMPEXP_CORE wxDfbPtrBase
{
protected:
static void DoAddRef(wxDfbWrapperBase *ptr);
static void DoRelease(wxDfbWrapperBase *ptr);
};
/**
This template implements smart pointer for keeping pointers to DirectFB
wrappers (i.e. wxIFoo classes derived from wxDfbWrapper<T>). Interface's
reference count is increased on copying and the interface is released when
the pointer is deleted.
*/
template<typename T>
class wxDfbPtr : private wxDfbPtrBase
{
public:
/**
Creates the pointer from raw pointer to the wrapper.
Takes ownership of @a ptr, i.e. AddRef() is @em not called on it.
*/
wxDfbPtr(T *ptr = NULL) : m_ptr(ptr) {}
/// Copy ctor
wxDfbPtr(const wxDfbPtr& ptr) { InitFrom(ptr); }
/// Dtor. Releases the interface
~wxDfbPtr() { Reset(); }
/// Resets the pointer to NULL, decreasing reference count of the interface.
void Reset()
{
if ( m_ptr )
{
this->DoRelease((wxDfbWrapperBase*)m_ptr);
m_ptr = NULL;
}
}
/// Cast to the wrapper pointer
operator T*() const { return m_ptr; }
// standard operators:
wxDfbPtr& operator=(T *ptr)
{
Reset();
m_ptr = ptr;
return *this;
}
wxDfbPtr& operator=(const wxDfbPtr& ptr)
{
Reset();
InitFrom(ptr);
return *this;
}
T& operator*() const { return *m_ptr; }
T* operator->() const { return m_ptr; }
private:
void InitFrom(const wxDfbPtr& ptr)
{
m_ptr = ptr.m_ptr;
if ( m_ptr )
this->DoAddRef((wxDfbWrapperBase*)m_ptr);
}
private:
T *m_ptr;
};
#endif // _WX_DFB_DFBPTR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/pen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/pen.h
// Purpose: wxPen class declaration
// Author: Vaclav Slavik
// Created: 2006-08-04
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_PEN_H_
#define _WX_DFB_PEN_H_
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxPen;
//-----------------------------------------------------------------------------
// wxPen
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPen: public wxPenBase
{
public:
wxPen() {}
wxPen(const wxColour &colour, int width = 1, wxPenStyle style = wxPENSTYLE_SOLID);
wxPen(const wxBitmap& stipple, int width);
wxPen(const wxPenInfo& info);
bool operator==(const wxPen& pen) const;
bool operator!=(const wxPen& pen) const { return !(*this == pen); }
void SetColour(const wxColour &colour);
void SetColour(unsigned char red, unsigned char green, unsigned char blue);
void SetCap(wxPenCap capStyle);
void SetJoin(wxPenJoin joinStyle);
void SetStyle(wxPenStyle style);
void SetWidth(int width);
void SetDashes(int number_of_dashes, const wxDash *dash);
void SetStipple(const wxBitmap& stipple);
wxColour GetColour() const;
wxPenCap GetCap() const;
wxPenJoin GetJoin() const;
wxPenStyle GetStyle() const;
int GetWidth() const;
int GetDashes(wxDash **ptr) const;
int GetDashCount() const;
wxDash* GetDash() const;
wxBitmap *GetStipple() const;
wxDEPRECATED_MSG("use wxPENSTYLE_XXX constants")
wxPen(const wxColour& col, int width, int style);
wxDEPRECATED_MSG("use wxPENSTYLE_XXX constants")
void SetStyle(int style) { SetStyle((wxPenStyle)style); }
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
wxDECLARE_DYNAMIC_CLASS(wxPen);
};
#endif // _WX_DFB_PEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/cursor.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/cursor.h
// Purpose: wxCursor declaration
// Author: Vaclav Slavik
// Created: 2006-08-08
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_CURSOR_H_
#define _WX_DFB_CURSOR_H_
class WXDLLIMPEXP_FWD_CORE wxBitmap;
//-----------------------------------------------------------------------------
// wxCursor
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxCursor : public wxCursorBase
{
public:
wxCursor() {}
wxCursor(wxStockCursor id) { InitFromStock(id); }
#if WXWIN_COMPATIBILITY_2_8
wxCursor(int id) { InitFromStock((wxStockCursor)id); }
#endif
wxCursor(const wxString& name,
wxBitmapType type = wxCURSOR_DEFAULT_TYPE,
int hotSpotX = 0, int hotSpotY = 0);
// implementation
wxBitmap GetBitmap() const;
protected:
void InitFromStock(wxStockCursor);
// ref counting code
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
wxDECLARE_DYNAMIC_CLASS(wxCursor);
};
#endif // _WX_DFB_CURSOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/popupwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/popupwin.h
// Purpose: wxPopupWindow class for wxDFB
// Author: Vaclav Slavik
// Created: 2006-12-24
// Copyright: (c) 2006 TT-Solutions
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_POPUPWIN_H_
#define _WX_DFB_POPUPWIN_H_
// ----------------------------------------------------------------------------
// wxPopupWindow
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPopupWindow : public wxPopupWindowBase
{
public:
wxPopupWindow() {}
wxPopupWindow(wxWindow *parent, int flags = wxBORDER_NONE)
{ Create(parent, flags); }
bool Create(wxWindow *parent, int flags = wxBORDER_NONE)
{
if ( !wxPopupWindowBase::Create(parent) )
return false;
return wxNonOwnedWindow::Create
(
parent,
-1,
// DFB windows must have valid pos & size:
wxPoint(0, 0), wxSize(1, 1),
(flags & wxBORDER_MASK) | wxPOPUP_WINDOW
);
}
wxDECLARE_DYNAMIC_CLASS(wxPopupWindow);
};
#endif // _WX_DFB_POPUPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/brush.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/brush.h
// Purpose: wxBrush class declaration
// Author: Vaclav Slavik
// Created: 2006-08-04
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_BRUSH_H_
#define _WX_DFB_BRUSH_H_
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdiobj.h"
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxBrush;
//-----------------------------------------------------------------------------
// wxBrush
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBrush : public wxBrushBase
{
public:
wxBrush() {}
wxBrush(const wxColour &colour, wxBrushStyle style = wxBRUSHSTYLE_SOLID);
wxBrush(const wxBitmap &stippleBitmap);
bool operator==(const wxBrush& brush) const;
bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
wxBrushStyle GetStyle() const;
wxColour GetColour() const;
wxBitmap *GetStipple() const;
void SetColour(const wxColour& col);
void SetColour(unsigned char r, unsigned char g, unsigned char b);
void SetStyle(wxBrushStyle style);
void SetStipple(const wxBitmap& stipple);
wxDEPRECATED_MSG("use wxBRUSHSTYLE_XXX constants")
wxBrush(const wxColour& col, int style);
wxDEPRECATED_MSG("use wxBRUSHSTYLE_XXX constants")
void SetStyle(int style) { SetStyle((wxBrushStyle)style); }
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
wxDECLARE_DYNAMIC_CLASS(wxBrush);
};
#endif // _WX_DFB_BRUSH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/dcscreen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/dcscreen.h
// Purpose: wxScreenDCImpl declaration
// Author: Vaclav Slavik
// Created: 2006-08-10
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_DCSCREEN_H_
#define _WX_DFB_DCSCREEN_H_
#include "wx/dfb/dc.h"
class WXDLLIMPEXP_CORE wxScreenDCImpl : public wxDFBDCImpl
{
public:
wxScreenDCImpl(wxScreenDC *owner);
wxDECLARE_DYNAMIC_CLASS(wxScreenDCImpl);
};
#endif // _WX_DFB_DCSCREEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/window.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/window.h
// Purpose: wxWindow class
// Author: Vaclav Slavik
// Created: 2006-08-10
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_WINDOW_H_
#define _WX_DFB_WINDOW_H_
// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
#include "wx/dfb/dfbptr.h"
wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
struct wxDFBWindowEvent;
class WXDLLIMPEXP_FWD_CORE wxFont;
class WXDLLIMPEXP_FWD_CORE wxNonOwnedWindow;
class wxOverlayImpl;
class wxDfbOverlaysList;
// ---------------------------------------------------------------------------
// wxWindow
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDFB : public wxWindowBase
{
public:
wxWindowDFB() { Init(); }
wxWindowDFB(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
virtual ~wxWindowDFB();
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
// implement base class (pure) virtual methods
// -------------------------------------------
virtual void SetLabel( const wxString &WXUNUSED(label) ) {}
virtual wxString GetLabel() const { return wxEmptyString; }
virtual void Raise();
virtual void Lower();
virtual bool Show(bool show = true);
virtual void SetFocus();
virtual bool Reparent(wxWindowBase *newParent);
virtual void WarpPointer(int x, int y);
virtual void Refresh(bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL);
virtual void Update();
virtual bool SetCursor(const wxCursor &cursor);
virtual bool SetFont(const wxFont &font) { m_font = font; return true; }
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget(wxDropTarget *dropTarget);
// Accept files for dragging
virtual void DragAcceptFiles(bool accept);
#endif // wxUSE_DRAG_AND_DROP
virtual WXWidget GetHandle() const { return this; }
// implementation from now on
// --------------------------
// Returns DirectFB surface used for rendering of this window
wxIDirectFBSurfacePtr GetDfbSurface();
// returns toplevel window the window belongs to
wxNonOwnedWindow *GetTLW() const { return m_tlw; }
virtual bool IsDoubleBuffered() const { return true; }
protected:
// implement the base class pure virtuals
virtual void DoGetTextExtent(const wxString& string,
int *x, int *y,
int *descent = NULL,
int *externalLeading = NULL,
const wxFont *theFont = NULL) const;
virtual void DoClientToScreen(int *x, int *y) const;
virtual void DoScreenToClient(int *x, int *y) const;
virtual void DoGetPosition(int *x, int *y) const;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetClientSize(int *width, int *height) const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoSetClientSize(int width, int height);
virtual void DoCaptureMouse();
virtual void DoReleaseMouse();
virtual void DoThaw();
// move the window to the specified location and resize it: this is called
// from both DoSetSize() and DoSetClientSize() and would usually just call
// ::MoveWindow() except for composite controls which will want to arrange
// themselves inside the given rectangle
virtual void DoMoveWindow(int x, int y, int width, int height);
// return DFB surface used to render this window (will be assigned to
// m_surface if the window is visible)
virtual wxIDirectFBSurfacePtr ObtainDfbSurface() const;
// this method must be called when window's position, size or visibility
// changes; it resets m_surface so that ObtainDfbSurface has to be called
// next time GetDfbSurface is called
void InvalidateDfbSurface();
// called by parent to render (part of) the window
void PaintWindow(const wxRect& rect);
// paint window's overlays (if any) on top of window's surface
void PaintOverlays(const wxRect& rect);
// refreshes the entire window (including non-client areas)
void DoRefreshWindow();
// refreshes given rectangle of the window (in window, _not_ client coords)
virtual void DoRefreshRect(const wxRect& rect);
// refreshes given rectangle; unlike RefreshRect(), the argument is in
// window, not client, coords and unlike DoRefreshRect() and like Refresh(),
// does nothing if the window is hidden or frozen
void RefreshWindowRect(const wxRect& rect);
// add/remove overlay for this window
void AddOverlay(wxOverlayImpl *overlay);
void RemoveOverlay(wxOverlayImpl *overlay);
// DirectFB events handling
void HandleKeyEvent(const wxDFBWindowEvent& event_);
private:
// common part of all ctors
void Init();
// counterpart to SetFocus
void DFBKillFocus();
protected:
// toplevel window (i.e. DirectFB window) this window belongs to
wxNonOwnedWindow *m_tlw;
private:
// subsurface of TLW's surface covered by this window
wxIDirectFBSurfacePtr m_surface;
// position of the window (relative to the parent, not used by wxTLW, so
// don't access it directly)
wxRect m_rect;
// overlays for this window (or NULL if it doesn't have any)
wxDfbOverlaysList *m_overlays;
friend class wxNonOwnedWindow; // for HandleXXXEvent
friend class wxOverlayImpl; // for Add/RemoveOverlay
friend class wxWindowDCImpl; // for PaintOverlays
wxDECLARE_DYNAMIC_CLASS(wxWindowDFB);
wxDECLARE_NO_COPY_CLASS(wxWindowDFB);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_DFB_WINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/dc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/dc.h
// Purpose: wxDC class
// Author: Vaclav Slavik
// Created: 2006-08-07
// Copyright: (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_DC_H_
#define _WX_DFB_DC_H_
#include "wx/defs.h"
#include "wx/region.h"
#include "wx/dc.h"
#include "wx/dfb/dfbptr.h"
wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
//-----------------------------------------------------------------------------
// wxDFBDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDFBDCImpl : public wxDCImpl
{
public:
// ctors
wxDFBDCImpl(wxDC *owner) : wxDCImpl(owner) { m_surface = NULL; }
wxDFBDCImpl(wxDC *owner, const wxIDirectFBSurfacePtr& surface)
: wxDCImpl(owner)
{
DFBInit(surface);
}
bool IsOk() const { return m_surface != NULL; }
// implement base class pure virtuals
// ----------------------------------
virtual void Clear();
virtual bool StartDoc(const wxString& message);
virtual void EndDoc();
virtual void StartPage();
virtual void EndPage();
virtual void SetFont(const wxFont& font);
virtual void SetPen(const wxPen& pen);
virtual void SetBrush(const wxBrush& brush);
virtual void SetBackground(const wxBrush& brush);
virtual void SetBackgroundMode(int mode);
#if wxUSE_PALETTE
virtual void SetPalette(const wxPalette& palette);
#endif
virtual void SetLogicalFunction(wxRasterOperationMode function);
virtual void DestroyClippingRegion();
virtual wxCoord GetCharHeight() const;
virtual wxCoord GetCharWidth() const;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *x, wxCoord *y,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
const wxFont *theFont = NULL) const;
virtual bool CanDrawBitmap() const { return true; }
virtual bool CanGetTextExtent() const { return true; }
virtual int GetDepth() const;
virtual wxSize GetPPI() const;
// Returns the surface (and increases its ref count)
wxIDirectFBSurfacePtr GetDirectFBSurface() const { return m_surface; }
protected:
// implementation
wxCoord XDEV2LOG(wxCoord x) const { return DeviceToLogicalX(x); }
wxCoord XDEV2LOGREL(wxCoord x) const { return DeviceToLogicalXRel(x); }
wxCoord YDEV2LOG(wxCoord y) const { return DeviceToLogicalY(y); }
wxCoord YDEV2LOGREL(wxCoord y) const { return DeviceToLogicalYRel(y); }
wxCoord XLOG2DEV(wxCoord x) const { return LogicalToDeviceX(x); }
wxCoord XLOG2DEVREL(wxCoord x) const { return LogicalToDeviceXRel(x); }
wxCoord YLOG2DEV(wxCoord y) const { return LogicalToDeviceY(y); }
wxCoord YLOG2DEVREL(wxCoord y) const { return LogicalToDeviceYRel(y); }
// initializes the DC from a surface, must be called if default ctor
// was used
void DFBInit(const wxIDirectFBSurfacePtr& surface);
virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
wxFloodFillStyle style = wxFLOOD_SURFACE);
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const;
virtual void DoDrawPoint(wxCoord x, wxCoord y);
virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
virtual void DoDrawArc(wxCoord x1, wxCoord y1,
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc);
virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
double sa, double ea);
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
wxCoord width, wxCoord height,
double radius);
virtual void DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoCrossHair(wxCoord x, wxCoord y);
virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask = false);
virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y);
virtual void DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y,
double angle);
virtual bool DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
wxDC *source, wxCoord xsrc, wxCoord ysrc,
wxRasterOperationMode rop = wxCOPY, bool useMask = false,
wxCoord xsrcMask = -1, wxCoord ysrcMask = -1);
virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoSetDeviceClippingRegion(const wxRegion& region);
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetSizeMM(int* width, int* height) const;
virtual void DoDrawLines(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset);
virtual void DoDrawPolygon(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
// implementation from now on:
protected:
wxIDirectFBFontPtr GetCurrentFont() const;
private:
// Unified implementation of DrawIcon, DrawBitmap and Blit:
void DoDrawSubBitmap(const wxBitmap &bmp,
wxCoord x, wxCoord y, wxCoord w, wxCoord h,
wxCoord destx, wxCoord desty, int rop, bool useMask);
bool DoBlitFromSurface(const wxIDirectFBSurfacePtr& src,
wxCoord srcx, wxCoord srcy,
wxCoord w, wxCoord h,
wxCoord dstx, wxCoord dsty);
// selects colour into surface's state
void SelectColour(const wxColour& clr);
protected:
wxIDirectFBSurfacePtr m_surface;
friend class WXDLLIMPEXP_FWD_CORE wxOverlayImpl; // for Init
wxDECLARE_ABSTRACT_CLASS(wxDFBDCImpl);
};
#endif // _WX_DFB_DC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/chkconf.h | /*
* Name: wx/dfb/chkconf.h
* Author: Vaclav Slavik
* Purpose: Compiler-specific configuration checking
* Created: 2006-08-10
* Copyright: (c) 2006 REA Elektronik GmbH
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_DFB_CHKCONF_H_
#define _WX_DFB_CHKCONF_H_
#ifndef __WXUNIVERSAL__
# error "wxDirectFB cannot be built without wxUniversal"
#endif
#if !wxUSE_CONFIG
# error "wxFileConfig is required by wxDFB port"
#endif
#if wxUSE_SOCKETS && !wxUSE_CONSOLE_EVENTLOOP
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxSocket requires wxSelectDispatcher in wxDFB"
# else
# undef wxUSE_CONSOLE_EVENTLOOP
# define wxUSE_CONSOLE_EVENTLOOP 1
# endif
#endif
#if wxUSE_DATAOBJ
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxDataObject not supported in wxDFB"
# else
# undef wxUSE_DATAOBJ
# define wxUSE_DATAOBJ 0
# endif
#endif
#endif /* _WX_DFB_CHKCONF_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/private/fontmgr.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/private/fontmgr.h
// Purpose: font management for wxDFB
// Author: Vaclav Slavik
// Created: 2006-11-18
// Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
// (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_PRIVATE_FONTMGR_H_
#define _WX_DFB_PRIVATE_FONTMGR_H_
#include "wx/dfb/wrapdfb.h"
class wxFileConfig;
class wxFontInstance : public wxFontInstanceBase
{
public:
wxFontInstance(float ptSize, bool aa, const wxString& filename);
wxIDirectFBFontPtr GetDirectFBFont() const { return m_font; }
private:
wxIDirectFBFontPtr m_font;
};
class wxFontFace : public wxFontFaceBase
{
public:
wxFontFace(const wxString& filename) : m_fileName(filename) {}
protected:
wxFontInstance *CreateFontInstance(float ptSize, bool aa);
private:
wxString m_fileName;
};
class wxFontBundle : public wxFontBundleBase
{
public:
wxFontBundle(const wxString& name,
const wxString& fileRegular,
const wxString& fileBold,
const wxString& fileItalic,
const wxString& fileBoldItalic,
bool isFixed);
/// Returns name of the family
virtual wxString GetName() const { return m_name; }
virtual bool IsFixed() const { return m_isFixed; }
private:
wxString m_name;
bool m_isFixed;
};
class wxFontsManager : public wxFontsManagerBase
{
public:
wxFontsManager() { AddAllFonts(); }
virtual wxString GetDefaultFacename(wxFontFamily family) const
{
return m_defaultFacenames[family];
}
private:
// adds all fonts using AddBundle()
void AddAllFonts();
void AddFontsFromDir(const wxString& indexFile);
void AddFont(const wxString& dir, const wxString& name, wxFileConfig& cfg);
void SetDefaultFonts(wxFileConfig& cfg);
private:
// default facenames
wxString m_defaultFacenames[wxFONTFAMILY_MAX];
};
#endif // _WX_DFB_PRIVATE_FONTMGR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dfb/private/overlay.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dfb/private/overlay.h
// Purpose: wxOverlayImpl declaration
// Author: Vaclav Slavik
// Created: 2006-10-20
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DFB_PRIVATE_OVERLAY_H_
#define _WX_DFB_PRIVATE_OVERLAY_H_
#include "wx/dfb/dfbptr.h"
#include "wx/gdicmn.h"
wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxDC;
class wxOverlayImpl
{
public:
wxOverlayImpl();
~wxOverlayImpl();
void Reset();
bool IsOk();
void Init(wxDC* dc, int x , int y , int width , int height);
void BeginDrawing(wxDC* dc);
void EndDrawing(wxDC* dc);
void Clear(wxDC* dc);
// wxDFB specific methods:
bool IsEmpty() const { return m_isEmpty; }
wxRect GetRect() const { return m_rect; }
wxIDirectFBSurfacePtr GetDirectFBSurface() const { return m_surface; }
public:
// window the overlay is associated with
wxWindow *m_window;
// rectangle covered by the overlay, in m_window's window coordinates
wxRect m_rect;
// surface of the overlay, same size as m_rect
wxIDirectFBSurfacePtr m_surface;
// this flag is set to true if nothing was drawn on the overlay (either
// initially or Clear() was called)
bool m_isEmpty;
};
#endif // _WX_DFB_PRIVATE_OVERLAY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/stc/private.h | ////////////////////////////////////////////////////////////////////////////
// Name: wx/stc/private.h
// Purpose: Private declarations for wxSTC
// Author: Robin Dunn
// Created: 2007-07-15
// Copyright: (c) 2000 by Total Control Software
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STC_PRIVATE_H_
#define _WX_STC_PRIVATE_H_
#include "wx/defs.h"
#include "wx/string.h"
//----------------------------------------------------------------------
// Utility functions used within wxSTC
#if wxUSE_UNICODE
extern wxString stc2wx(const char* str);
extern wxString stc2wx(const char* str, size_t len);
extern wxCharBuffer wx2stc(const wxString& str);
// This function takes both wxString and wxCharBuffer because it uses either
// one or the other of them depending on the build mode. In Unicode it uses the
// length of the already converted buffer to avoid doing the conversion again
// just to compute the length.
inline size_t wx2stclen(const wxString& WXUNUSED(str), const wxCharBuffer& buf)
{
return buf.length();
}
#else // not UNICODE
inline wxString stc2wx(const char* str) {
return wxString(str);
}
inline wxString stc2wx(const char* str, size_t len) {
return wxString(str, len);
}
inline const char* wx2stc(const wxString& str) {
return str.mbc_str();
}
// As explained above, the buffer argument is only used in Unicode build.
inline size_t wx2stclen(const wxString& str, const char* WXUNUSED(buf))
{
return str.length();
}
#endif // UNICODE
#endif // _WX_STC_PRIVATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/stc/stc.h | ////////////////////////////////////////////////////////////////////////////
// Name: wx/stc/stc.h
// Purpose: A wxWidgets implementation of Scintilla. This class is the
// one meant to be used directly by wx applications. It does not
// derive directly from the Scintilla classes, and in fact there
// is no mention of Scintilla classes at all in this header.
// This class delegates all method calls and events to the
// Scintilla objects and so forth. This allows the use of
// Scintilla without polluting the namespace with all the
// classes and identifiers from Scintilla.
//
// Author: Robin Dunn
//
// Created: 13-Jan-2000
// Copyright: (c) 2000 by Total Control Software
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*
IMPORTANT: include/wx/stc/stc.h is generated by src/stc/gen_iface.py from
src/stc/stc.h.in, don't edit stc.h file as your changes will be
lost after the next regeneration, edit stc.h.in and rerun the
gen_iface.py script instead!
Parts of this file generated by the script are found in between
the special "{{{" and "}}}" markers, the rest of it is copied
verbatim from src.h.in.
*/
#ifndef _WX_STC_STC_H_
#define _WX_STC_STC_H_
#include "wx/defs.h"
#if wxUSE_STC
#include "wx/control.h"
#include "wx/dnd.h"
#include "wx/stopwatch.h"
#include "wx/versioninfo.h"
#include "wx/textentry.h"
#if wxUSE_TEXTCTRL
#include "wx/textctrl.h"
#endif // wxUSE_TEXTCTRL
class WXDLLIMPEXP_FWD_CORE wxScrollBar;
// SWIG can't handle "#if" type of conditionals, only "#ifdef"
#ifdef SWIG
#define STC_USE_DND 1
#else
#if wxUSE_DRAG_AND_DROP
#define STC_USE_DND 1
#endif
#endif
//----------------------------------------------------------------------
// STC constants generated section {{{
#define wxSTC_INVALID_POSITION -1
/// Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages
/// as many EM_ messages can be used although that use is deprecated.
#define wxSTC_START 2000
#define wxSTC_OPTIONAL_START 3000
#define wxSTC_LEXER_START 4000
#define wxSTC_WS_INVISIBLE 0
#define wxSTC_WS_VISIBLEALWAYS 1
#define wxSTC_WS_VISIBLEAFTERINDENT 2
#define wxSTC_WS_VISIBLEONLYININDENT 3
#define wxSTC_TD_LONGARROW 0
#define wxSTC_TD_STRIKEOUT 1
#define wxSTC_EOL_CRLF 0
#define wxSTC_EOL_CR 1
#define wxSTC_EOL_LF 2
/// The SC_CP_UTF8 value can be used to enter Unicode mode.
/// This is the same value as CP_UTF8 in Windows
#define wxSTC_CP_UTF8 65001
#define wxSTC_IME_WINDOWED 0
#define wxSTC_IME_INLINE 1
#define wxSTC_MARKER_MAX 31
#define wxSTC_MARK_CIRCLE 0
#define wxSTC_MARK_ROUNDRECT 1
#define wxSTC_MARK_ARROW 2
#define wxSTC_MARK_SMALLRECT 3
#define wxSTC_MARK_SHORTARROW 4
#define wxSTC_MARK_EMPTY 5
#define wxSTC_MARK_ARROWDOWN 6
#define wxSTC_MARK_MINUS 7
#define wxSTC_MARK_PLUS 8
/// Shapes used for outlining column.
#define wxSTC_MARK_VLINE 9
#define wxSTC_MARK_LCORNER 10
#define wxSTC_MARK_TCORNER 11
#define wxSTC_MARK_BOXPLUS 12
#define wxSTC_MARK_BOXPLUSCONNECTED 13
#define wxSTC_MARK_BOXMINUS 14
#define wxSTC_MARK_BOXMINUSCONNECTED 15
#define wxSTC_MARK_LCORNERCURVE 16
#define wxSTC_MARK_TCORNERCURVE 17
#define wxSTC_MARK_CIRCLEPLUS 18
#define wxSTC_MARK_CIRCLEPLUSCONNECTED 19
#define wxSTC_MARK_CIRCLEMINUS 20
#define wxSTC_MARK_CIRCLEMINUSCONNECTED 21
/// Invisible mark that only sets the line background colour.
#define wxSTC_MARK_BACKGROUND 22
#define wxSTC_MARK_DOTDOTDOT 23
#define wxSTC_MARK_ARROWS 24
#define wxSTC_MARK_PIXMAP 25
#define wxSTC_MARK_FULLRECT 26
#define wxSTC_MARK_LEFTRECT 27
#define wxSTC_MARK_AVAILABLE 28
#define wxSTC_MARK_UNDERLINE 29
#define wxSTC_MARK_RGBAIMAGE 30
#define wxSTC_MARK_BOOKMARK 31
#define wxSTC_MARK_CHARACTER 10000
/// Markers used for outlining column.
#define wxSTC_MARKNUM_FOLDEREND 25
#define wxSTC_MARKNUM_FOLDEROPENMID 26
#define wxSTC_MARKNUM_FOLDERMIDTAIL 27
#define wxSTC_MARKNUM_FOLDERTAIL 28
#define wxSTC_MARKNUM_FOLDERSUB 29
#define wxSTC_MARKNUM_FOLDER 30
#define wxSTC_MARKNUM_FOLDEROPEN 31
#define wxSTC_MASK_FOLDERS 0xFE000000
#define wxSTC_MAX_MARGIN 4
#define wxSTC_MARGIN_SYMBOL 0
#define wxSTC_MARGIN_NUMBER 1
#define wxSTC_MARGIN_BACK 2
#define wxSTC_MARGIN_FORE 3
#define wxSTC_MARGIN_TEXT 4
#define wxSTC_MARGIN_RTEXT 5
#define wxSTC_MARGIN_COLOUR 6
/// Styles in range 32..38 are predefined for parts of the UI and are not used as normal styles.
/// Style 39 is for future use.
#define wxSTC_STYLE_DEFAULT 32
#define wxSTC_STYLE_LINENUMBER 33
#define wxSTC_STYLE_BRACELIGHT 34
#define wxSTC_STYLE_BRACEBAD 35
#define wxSTC_STYLE_CONTROLCHAR 36
#define wxSTC_STYLE_INDENTGUIDE 37
#define wxSTC_STYLE_CALLTIP 38
#define wxSTC_STYLE_FOLDDISPLAYTEXT 39
#define wxSTC_STYLE_LASTPREDEFINED 39
#define wxSTC_STYLE_MAX 255
/// Character set identifiers are used in StyleSetCharacterSet.
/// The values are the same as the Windows *_CHARSET values.
#define wxSTC_CHARSET_ANSI 0
#define wxSTC_CHARSET_DEFAULT 1
#define wxSTC_CHARSET_BALTIC 186
#define wxSTC_CHARSET_CHINESEBIG5 136
#define wxSTC_CHARSET_EASTEUROPE 238
#define wxSTC_CHARSET_GB2312 134
#define wxSTC_CHARSET_GREEK 161
#define wxSTC_CHARSET_HANGUL 129
#define wxSTC_CHARSET_MAC 77
#define wxSTC_CHARSET_OEM 255
#define wxSTC_CHARSET_RUSSIAN 204
#define wxSTC_CHARSET_OEM866 866
#define wxSTC_CHARSET_CYRILLIC 1251
#define wxSTC_CHARSET_SHIFTJIS 128
#define wxSTC_CHARSET_SYMBOL 2
#define wxSTC_CHARSET_TURKISH 162
#define wxSTC_CHARSET_JOHAB 130
#define wxSTC_CHARSET_HEBREW 177
#define wxSTC_CHARSET_ARABIC 178
#define wxSTC_CHARSET_VIETNAMESE 163
#define wxSTC_CHARSET_THAI 222
#define wxSTC_CHARSET_8859_15 1000
#define wxSTC_CASE_MIXED 0
#define wxSTC_CASE_UPPER 1
#define wxSTC_CASE_LOWER 2
#define wxSTC_CASE_CAMEL 3
#define wxSTC_FONT_SIZE_MULTIPLIER 100
#define wxSTC_WEIGHT_NORMAL 400
#define wxSTC_WEIGHT_SEMIBOLD 600
#define wxSTC_WEIGHT_BOLD 700
/// Indicator style enumeration and some constants
#define wxSTC_INDIC_PLAIN 0
#define wxSTC_INDIC_SQUIGGLE 1
#define wxSTC_INDIC_TT 2
#define wxSTC_INDIC_DIAGONAL 3
#define wxSTC_INDIC_STRIKE 4
#define wxSTC_INDIC_HIDDEN 5
#define wxSTC_INDIC_BOX 6
#define wxSTC_INDIC_ROUNDBOX 7
#define wxSTC_INDIC_STRAIGHTBOX 8
#define wxSTC_INDIC_DASH 9
#define wxSTC_INDIC_DOTS 10
#define wxSTC_INDIC_SQUIGGLELOW 11
#define wxSTC_INDIC_DOTBOX 12
#define wxSTC_INDIC_SQUIGGLEPIXMAP 13
#define wxSTC_INDIC_COMPOSITIONTHICK 14
#define wxSTC_INDIC_COMPOSITIONTHIN 15
#define wxSTC_INDIC_FULLBOX 16
#define wxSTC_INDIC_TEXTFORE 17
#define wxSTC_INDIC_POINT 18
#define wxSTC_INDIC_POINTCHARACTER 19
#define wxSTC_INDIC_IME 32
#define wxSTC_INDIC_IME_MAX 35
#define wxSTC_INDIC_MAX 35
#define wxSTC_INDIC_CONTAINER 8
#define wxSTC_INDICVALUEBIT 0x1000000
#define wxSTC_INDICVALUEMASK 0xFFFFFF
#define wxSTC_INDICFLAG_VALUEFORE 1
#define wxSTC_IV_NONE 0
#define wxSTC_IV_REAL 1
#define wxSTC_IV_LOOKFORWARD 2
#define wxSTC_IV_LOOKBOTH 3
/// PrintColourMode - use same colours as screen.
#define wxSTC_PRINT_NORMAL 0
/// PrintColourMode - invert the light value of each style for printing.
#define wxSTC_PRINT_INVERTLIGHT 1
/// PrintColourMode - force black text on white background for printing.
#define wxSTC_PRINT_BLACKONWHITE 2
/// PrintColourMode - text stays coloured, but all background is forced to be white for printing.
#define wxSTC_PRINT_COLOURONWHITE 3
/// PrintColourMode - only the default-background is forced to be white for printing.
#define wxSTC_PRINT_COLOURONWHITEDEFAULTBG 4
#define wxSTC_FIND_WHOLEWORD 0x2
#define wxSTC_FIND_MATCHCASE 0x4
#define wxSTC_FIND_WORDSTART 0x00100000
#define wxSTC_FIND_REGEXP 0x00200000
#define wxSTC_FIND_POSIX 0x00400000
#define wxSTC_FIND_CXX11REGEX 0x00800000
#define wxSTC_FOLDLEVELBASE 0x400
#define wxSTC_FOLDLEVELWHITEFLAG 0x1000
#define wxSTC_FOLDLEVELHEADERFLAG 0x2000
#define wxSTC_FOLDLEVELNUMBERMASK 0x0FFF
#define wxSTC_FOLDDISPLAYTEXT_HIDDEN 0
#define wxSTC_FOLDDISPLAYTEXT_STANDARD 1
#define wxSTC_FOLDDISPLAYTEXT_BOXED 2
#define wxSTC_FOLDACTION_CONTRACT 0
#define wxSTC_FOLDACTION_EXPAND 1
#define wxSTC_FOLDACTION_TOGGLE 2
#define wxSTC_AUTOMATICFOLD_SHOW 0x0001
#define wxSTC_AUTOMATICFOLD_CLICK 0x0002
#define wxSTC_AUTOMATICFOLD_CHANGE 0x0004
#define wxSTC_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002
#define wxSTC_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004
#define wxSTC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008
#define wxSTC_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010
#define wxSTC_FOLDFLAG_LEVELNUMBERS 0x0040
#define wxSTC_FOLDFLAG_LINESTATE 0x0080
#define wxSTC_TIME_FOREVER 10000000
#define wxSTC_IDLESTYLING_NONE 0
#define wxSTC_IDLESTYLING_TOVISIBLE 1
#define wxSTC_IDLESTYLING_AFTERVISIBLE 2
#define wxSTC_IDLESTYLING_ALL 3
#define wxSTC_WRAP_NONE 0
#define wxSTC_WRAP_WORD 1
#define wxSTC_WRAP_CHAR 2
#define wxSTC_WRAP_WHITESPACE 3
#define wxSTC_WRAPVISUALFLAG_NONE 0x0000
#define wxSTC_WRAPVISUALFLAG_END 0x0001
#define wxSTC_WRAPVISUALFLAG_START 0x0002
#define wxSTC_WRAPVISUALFLAG_MARGIN 0x0004
#define wxSTC_WRAPVISUALFLAGLOC_DEFAULT 0x0000
#define wxSTC_WRAPVISUALFLAGLOC_END_BY_TEXT 0x0001
#define wxSTC_WRAPVISUALFLAGLOC_START_BY_TEXT 0x0002
#define wxSTC_WRAPINDENT_FIXED 0
#define wxSTC_WRAPINDENT_SAME 1
#define wxSTC_WRAPINDENT_INDENT 2
#define wxSTC_CACHE_NONE 0
#define wxSTC_CACHE_CARET 1
#define wxSTC_CACHE_PAGE 2
#define wxSTC_CACHE_DOCUMENT 3
#define wxSTC_PHASES_ONE 0
#define wxSTC_PHASES_TWO 1
#define wxSTC_PHASES_MULTIPLE 2
/// Control font anti-aliasing.
#define wxSTC_EFF_QUALITY_MASK 0xF
#define wxSTC_EFF_QUALITY_DEFAULT 0
#define wxSTC_EFF_QUALITY_NON_ANTIALIASED 1
#define wxSTC_EFF_QUALITY_ANTIALIASED 2
#define wxSTC_EFF_QUALITY_LCD_OPTIMIZED 3
#define wxSTC_MULTIPASTE_ONCE 0
#define wxSTC_MULTIPASTE_EACH 1
#define wxSTC_EDGE_NONE 0
#define wxSTC_EDGE_LINE 1
#define wxSTC_EDGE_BACKGROUND 2
#define wxSTC_EDGE_MULTILINE 3
#define wxSTC_POPUP_NEVER 0
#define wxSTC_POPUP_ALL 1
#define wxSTC_POPUP_TEXT 2
#define wxSTC_STATUS_OK 0
#define wxSTC_STATUS_FAILURE 1
#define wxSTC_STATUS_BADALLOC 2
#define wxSTC_STATUS_WARN_START 1000
#define wxSTC_STATUS_WARN_REGEX 1001
#define wxSTC_CURSORNORMAL -1
#define wxSTC_CURSORARROW 2
#define wxSTC_CURSORWAIT 4
#define wxSTC_CURSORREVERSEARROW 7
/// Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.
#define wxSTC_VISIBLE_SLOP 0x01
#define wxSTC_VISIBLE_STRICT 0x04
/// Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.
/// If CARET_SLOP is set, we can define a slop value: caretSlop.
/// This value defines an unwanted zone (UZ) where the caret is... unwanted.
/// This zone is defined as a number of pixels near the vertical margins,
/// and as a number of lines near the horizontal margins.
/// By keeping the caret away from the edges, it is seen within its context,
/// so it is likely that the identifier that the caret is on can be completely seen,
/// and that the current line is seen with some of the lines following it which are
/// often dependent on that line.
#define wxSTC_CARET_SLOP 0x01
/// If CARET_STRICT is set, the policy is enforced... strictly.
/// The caret is centred on the display if slop is not set,
/// and cannot go in the UZ if slop is set.
#define wxSTC_CARET_STRICT 0x04
/// If CARET_JUMPS is set, the display is moved more energetically
/// so the caret can move in the same direction longer before the policy is applied again.
#define wxSTC_CARET_JUMPS 0x10
/// If CARET_EVEN is not set, instead of having symmetrical UZs,
/// the left and bottom UZs are extended up to right and top UZs respectively.
/// This way, we favour the displaying of useful information: the beginning of lines,
/// where most code reside, and the lines after the caret, eg. the body of a function.
#define wxSTC_CARET_EVEN 0x08
#define wxSTC_SEL_STREAM 0
#define wxSTC_SEL_RECTANGLE 1
#define wxSTC_SEL_LINES 2
#define wxSTC_SEL_THIN 3
#define wxSTC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE 0
#define wxSTC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE 1
#define wxSTC_MULTIAUTOC_ONCE 0
#define wxSTC_MULTIAUTOC_EACH 1
#define wxSTC_ORDER_PRESORTED 0
#define wxSTC_ORDER_PERFORMSORT 1
#define wxSTC_ORDER_CUSTOM 2
#define wxSTC_CARETSTICKY_OFF 0
#define wxSTC_CARETSTICKY_ON 1
#define wxSTC_CARETSTICKY_WHITESPACE 2
#define wxSTC_ALPHA_TRANSPARENT 0
#define wxSTC_ALPHA_OPAQUE 255
#define wxSTC_ALPHA_NOALPHA 256
#define wxSTC_CARETSTYLE_INVISIBLE 0
#define wxSTC_CARETSTYLE_LINE 1
#define wxSTC_CARETSTYLE_BLOCK 2
#define wxSTC_MARGINOPTION_NONE 0
#define wxSTC_MARGINOPTION_SUBLINESELECT 1
#define wxSTC_ANNOTATION_HIDDEN 0
#define wxSTC_ANNOTATION_STANDARD 1
#define wxSTC_ANNOTATION_BOXED 2
#define wxSTC_ANNOTATION_INDENTED 3
#define wxSTC_UNDO_MAY_COALESCE 1
#define wxSTC_VS_NONE 0
#define wxSTC_VS_RECTANGULARSELECTION 1
#define wxSTC_VS_USERACCESSIBLE 2
#define wxSTC_VS_NOWRAPLINESTART 4
#define wxSTC_TECHNOLOGY_DEFAULT 0
#define wxSTC_TECHNOLOGY_DIRECTWRITE 1
/// Line end types which may be used in addition to LF, CR, and CRLF
/// SC_LINE_END_TYPE_UNICODE includes U+2028 Line Separator,
/// U+2029 Paragraph Separator, and U+0085 Next Line
#define wxSTC_LINE_END_TYPE_DEFAULT 0
#define wxSTC_LINE_END_TYPE_UNICODE 1
/// Maximum value of keywordSet parameter of SetKeyWords.
#define wxSTC_KEYWORDSET_MAX 8
#define wxSTC_TYPE_BOOLEAN 0
#define wxSTC_TYPE_INTEGER 1
#define wxSTC_TYPE_STRING 2
/// Notifications
/// Type of modification and the action which caused the modification.
/// These are defined as a bit mask to make it easy to specify which notifications are wanted.
/// One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
#define wxSTC_MOD_INSERTTEXT 0x1
#define wxSTC_MOD_DELETETEXT 0x2
#define wxSTC_MOD_CHANGESTYLE 0x4
#define wxSTC_MOD_CHANGEFOLD 0x8
#define wxSTC_PERFORMED_USER 0x10
#define wxSTC_PERFORMED_UNDO 0x20
#define wxSTC_PERFORMED_REDO 0x40
#define wxSTC_MULTISTEPUNDOREDO 0x80
#define wxSTC_LASTSTEPINUNDOREDO 0x100
#define wxSTC_MOD_CHANGEMARKER 0x200
#define wxSTC_MOD_BEFOREINSERT 0x400
#define wxSTC_MOD_BEFOREDELETE 0x800
#define wxSTC_MULTILINEUNDOREDO 0x1000
#define wxSTC_STARTACTION 0x2000
#define wxSTC_MOD_CHANGEINDICATOR 0x4000
#define wxSTC_MOD_CHANGELINESTATE 0x8000
#define wxSTC_MOD_CHANGEMARGIN 0x10000
#define wxSTC_MOD_CHANGEANNOTATION 0x20000
#define wxSTC_MOD_CONTAINER 0x40000
#define wxSTC_MOD_LEXERSTATE 0x80000
#define wxSTC_MOD_INSERTCHECK 0x100000
#define wxSTC_MOD_CHANGETABSTOPS 0x200000
#define wxSTC_MODEVENTMASKALL 0x3FFFFF
#define wxSTC_UPDATE_CONTENT 0x1
#define wxSTC_UPDATE_SELECTION 0x2
#define wxSTC_UPDATE_V_SCROLL 0x4
#define wxSTC_UPDATE_H_SCROLL 0x8
/// Symbolic key codes and modifier flags.
/// ASCII and other printable characters below 256.
/// Extended keys above 300.
#define wxSTC_KEY_DOWN 300
#define wxSTC_KEY_UP 301
#define wxSTC_KEY_LEFT 302
#define wxSTC_KEY_RIGHT 303
#define wxSTC_KEY_HOME 304
#define wxSTC_KEY_END 305
#define wxSTC_KEY_PRIOR 306
#define wxSTC_KEY_NEXT 307
#define wxSTC_KEY_DELETE 308
#define wxSTC_KEY_INSERT 309
#define wxSTC_KEY_ESCAPE 7
#define wxSTC_KEY_BACK 8
#define wxSTC_KEY_TAB 9
#define wxSTC_KEY_RETURN 13
#define wxSTC_KEY_ADD 310
#define wxSTC_KEY_SUBTRACT 311
#define wxSTC_KEY_DIVIDE 312
#define wxSTC_KEY_WIN 313
#define wxSTC_KEY_RWIN 314
#define wxSTC_KEY_MENU 315
#define wxSTC_KEYMOD_NORM 0
#define wxSTC_KEYMOD_SHIFT 1
#define wxSTC_KEYMOD_CTRL 2
#define wxSTC_KEYMOD_ALT 4
#define wxSTC_KEYMOD_SUPER 8
#define wxSTC_KEYMOD_META 16
#define wxSTC_AC_FILLUP 1
#define wxSTC_AC_DOUBLECLICK 2
#define wxSTC_AC_TAB 3
#define wxSTC_AC_NEWLINE 4
#define wxSTC_AC_COMMAND 5
/// For SciLexer.h
#define wxSTC_LEX_CONTAINER 0
#define wxSTC_LEX_NULL 1
#define wxSTC_LEX_PYTHON 2
#define wxSTC_LEX_CPP 3
#define wxSTC_LEX_HTML 4
#define wxSTC_LEX_XML 5
#define wxSTC_LEX_PERL 6
#define wxSTC_LEX_SQL 7
#define wxSTC_LEX_VB 8
#define wxSTC_LEX_PROPERTIES 9
#define wxSTC_LEX_ERRORLIST 10
#define wxSTC_LEX_MAKEFILE 11
#define wxSTC_LEX_BATCH 12
#define wxSTC_LEX_XCODE 13
#define wxSTC_LEX_LATEX 14
#define wxSTC_LEX_LUA 15
#define wxSTC_LEX_DIFF 16
#define wxSTC_LEX_CONF 17
#define wxSTC_LEX_PASCAL 18
#define wxSTC_LEX_AVE 19
#define wxSTC_LEX_ADA 20
#define wxSTC_LEX_LISP 21
#define wxSTC_LEX_RUBY 22
#define wxSTC_LEX_EIFFEL 23
#define wxSTC_LEX_EIFFELKW 24
#define wxSTC_LEX_TCL 25
#define wxSTC_LEX_NNCRONTAB 26
#define wxSTC_LEX_BULLANT 27
#define wxSTC_LEX_VBSCRIPT 28
#define wxSTC_LEX_BAAN 31
#define wxSTC_LEX_MATLAB 32
#define wxSTC_LEX_SCRIPTOL 33
#define wxSTC_LEX_ASM 34
#define wxSTC_LEX_CPPNOCASE 35
#define wxSTC_LEX_FORTRAN 36
#define wxSTC_LEX_F77 37
#define wxSTC_LEX_CSS 38
#define wxSTC_LEX_POV 39
#define wxSTC_LEX_LOUT 40
#define wxSTC_LEX_ESCRIPT 41
#define wxSTC_LEX_PS 42
#define wxSTC_LEX_NSIS 43
#define wxSTC_LEX_MMIXAL 44
#define wxSTC_LEX_CLW 45
#define wxSTC_LEX_CLWNOCASE 46
#define wxSTC_LEX_LOT 47
#define wxSTC_LEX_YAML 48
#define wxSTC_LEX_TEX 49
#define wxSTC_LEX_METAPOST 50
#define wxSTC_LEX_POWERBASIC 51
#define wxSTC_LEX_FORTH 52
#define wxSTC_LEX_ERLANG 53
#define wxSTC_LEX_OCTAVE 54
#define wxSTC_LEX_MSSQL 55
#define wxSTC_LEX_VERILOG 56
#define wxSTC_LEX_KIX 57
#define wxSTC_LEX_GUI4CLI 58
#define wxSTC_LEX_SPECMAN 59
#define wxSTC_LEX_AU3 60
#define wxSTC_LEX_APDL 61
#define wxSTC_LEX_BASH 62
#define wxSTC_LEX_ASN1 63
#define wxSTC_LEX_VHDL 64
#define wxSTC_LEX_CAML 65
#define wxSTC_LEX_BLITZBASIC 66
#define wxSTC_LEX_PUREBASIC 67
#define wxSTC_LEX_HASKELL 68
#define wxSTC_LEX_PHPSCRIPT 69
#define wxSTC_LEX_TADS3 70
#define wxSTC_LEX_REBOL 71
#define wxSTC_LEX_SMALLTALK 72
#define wxSTC_LEX_FLAGSHIP 73
#define wxSTC_LEX_CSOUND 74
#define wxSTC_LEX_FREEBASIC 75
#define wxSTC_LEX_INNOSETUP 76
#define wxSTC_LEX_OPAL 77
#define wxSTC_LEX_SPICE 78
#define wxSTC_LEX_D 79
#define wxSTC_LEX_CMAKE 80
#define wxSTC_LEX_GAP 81
#define wxSTC_LEX_PLM 82
#define wxSTC_LEX_PROGRESS 83
#define wxSTC_LEX_ABAQUS 84
#define wxSTC_LEX_ASYMPTOTE 85
#define wxSTC_LEX_R 86
#define wxSTC_LEX_MAGIK 87
#define wxSTC_LEX_POWERSHELL 88
#define wxSTC_LEX_MYSQL 89
#define wxSTC_LEX_PO 90
#define wxSTC_LEX_TAL 91
#define wxSTC_LEX_COBOL 92
#define wxSTC_LEX_TACL 93
#define wxSTC_LEX_SORCUS 94
#define wxSTC_LEX_POWERPRO 95
#define wxSTC_LEX_NIMROD 96
#define wxSTC_LEX_SML 97
#define wxSTC_LEX_MARKDOWN 98
#define wxSTC_LEX_TXT2TAGS 99
#define wxSTC_LEX_A68K 100
#define wxSTC_LEX_MODULA 101
#define wxSTC_LEX_COFFEESCRIPT 102
#define wxSTC_LEX_TCMD 103
#define wxSTC_LEX_AVS 104
#define wxSTC_LEX_ECL 105
#define wxSTC_LEX_OSCRIPT 106
#define wxSTC_LEX_VISUALPROLOG 107
#define wxSTC_LEX_LITERATEHASKELL 108
#define wxSTC_LEX_STTXT 109
#define wxSTC_LEX_KVIRC 110
#define wxSTC_LEX_RUST 111
#define wxSTC_LEX_DMAP 112
#define wxSTC_LEX_AS 113
#define wxSTC_LEX_DMIS 114
#define wxSTC_LEX_REGISTRY 115
#define wxSTC_LEX_BIBTEX 116
#define wxSTC_LEX_SREC 117
#define wxSTC_LEX_IHEX 118
#define wxSTC_LEX_TEHEX 119
#define wxSTC_LEX_JSON 120
#define wxSTC_LEX_EDIFACT 121
/// When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
/// value assigned in sequence from SCLEX_AUTOMATIC+1.
#define wxSTC_LEX_AUTOMATIC 1000
/// Lexical states for SCLEX_PYTHON
#define wxSTC_P_DEFAULT 0
#define wxSTC_P_COMMENTLINE 1
#define wxSTC_P_NUMBER 2
#define wxSTC_P_STRING 3
#define wxSTC_P_CHARACTER 4
#define wxSTC_P_WORD 5
#define wxSTC_P_TRIPLE 6
#define wxSTC_P_TRIPLEDOUBLE 7
#define wxSTC_P_CLASSNAME 8
#define wxSTC_P_DEFNAME 9
#define wxSTC_P_OPERATOR 10
#define wxSTC_P_IDENTIFIER 11
#define wxSTC_P_COMMENTBLOCK 12
#define wxSTC_P_STRINGEOL 13
#define wxSTC_P_WORD2 14
#define wxSTC_P_DECORATOR 15
/// Lexical states for SCLEX_CPP, SCLEX_BULLANT, SCLEX_COBOL, SCLEX_TACL, SCLEX_TAL
#define wxSTC_C_DEFAULT 0
#define wxSTC_C_COMMENT 1
#define wxSTC_C_COMMENTLINE 2
#define wxSTC_C_COMMENTDOC 3
#define wxSTC_C_NUMBER 4
#define wxSTC_C_WORD 5
#define wxSTC_C_STRING 6
#define wxSTC_C_CHARACTER 7
#define wxSTC_C_UUID 8
#define wxSTC_C_PREPROCESSOR 9
#define wxSTC_C_OPERATOR 10
#define wxSTC_C_IDENTIFIER 11
#define wxSTC_C_STRINGEOL 12
#define wxSTC_C_VERBATIM 13
#define wxSTC_C_REGEX 14
#define wxSTC_C_COMMENTLINEDOC 15
#define wxSTC_C_WORD2 16
#define wxSTC_C_COMMENTDOCKEYWORD 17
#define wxSTC_C_COMMENTDOCKEYWORDERROR 18
#define wxSTC_C_GLOBALCLASS 19
#define wxSTC_C_STRINGRAW 20
#define wxSTC_C_TRIPLEVERBATIM 21
#define wxSTC_C_HASHQUOTEDSTRING 22
#define wxSTC_C_PREPROCESSORCOMMENT 23
#define wxSTC_C_PREPROCESSORCOMMENTDOC 24
#define wxSTC_C_USERLITERAL 25
#define wxSTC_C_TASKMARKER 26
#define wxSTC_C_ESCAPESEQUENCE 27
/// Lexical states for SCLEX_D
#define wxSTC_D_DEFAULT 0
#define wxSTC_D_COMMENT 1
#define wxSTC_D_COMMENTLINE 2
#define wxSTC_D_COMMENTDOC 3
#define wxSTC_D_COMMENTNESTED 4
#define wxSTC_D_NUMBER 5
#define wxSTC_D_WORD 6
#define wxSTC_D_WORD2 7
#define wxSTC_D_WORD3 8
#define wxSTC_D_TYPEDEF 9
#define wxSTC_D_STRING 10
#define wxSTC_D_STRINGEOL 11
#define wxSTC_D_CHARACTER 12
#define wxSTC_D_OPERATOR 13
#define wxSTC_D_IDENTIFIER 14
#define wxSTC_D_COMMENTLINEDOC 15
#define wxSTC_D_COMMENTDOCKEYWORD 16
#define wxSTC_D_COMMENTDOCKEYWORDERROR 17
#define wxSTC_D_STRINGB 18
#define wxSTC_D_STRINGR 19
#define wxSTC_D_WORD5 20
#define wxSTC_D_WORD6 21
#define wxSTC_D_WORD7 22
/// Lexical states for SCLEX_TCL
#define wxSTC_TCL_DEFAULT 0
#define wxSTC_TCL_COMMENT 1
#define wxSTC_TCL_COMMENTLINE 2
#define wxSTC_TCL_NUMBER 3
#define wxSTC_TCL_WORD_IN_QUOTE 4
#define wxSTC_TCL_IN_QUOTE 5
#define wxSTC_TCL_OPERATOR 6
#define wxSTC_TCL_IDENTIFIER 7
#define wxSTC_TCL_SUBSTITUTION 8
#define wxSTC_TCL_SUB_BRACE 9
#define wxSTC_TCL_MODIFIER 10
#define wxSTC_TCL_EXPAND 11
#define wxSTC_TCL_WORD 12
#define wxSTC_TCL_WORD2 13
#define wxSTC_TCL_WORD3 14
#define wxSTC_TCL_WORD4 15
#define wxSTC_TCL_WORD5 16
#define wxSTC_TCL_WORD6 17
#define wxSTC_TCL_WORD7 18
#define wxSTC_TCL_WORD8 19
#define wxSTC_TCL_COMMENT_BOX 20
#define wxSTC_TCL_BLOCK_COMMENT 21
/// Lexical states for SCLEX_HTML, SCLEX_XML
#define wxSTC_H_DEFAULT 0
#define wxSTC_H_TAG 1
#define wxSTC_H_TAGUNKNOWN 2
#define wxSTC_H_ATTRIBUTE 3
#define wxSTC_H_ATTRIBUTEUNKNOWN 4
#define wxSTC_H_NUMBER 5
#define wxSTC_H_DOUBLESTRING 6
#define wxSTC_H_SINGLESTRING 7
#define wxSTC_H_OTHER 8
#define wxSTC_H_COMMENT 9
#define wxSTC_H_ENTITY 10
/// XML and ASP
#define wxSTC_H_TAGEND 11
#define wxSTC_H_XMLSTART 12
#define wxSTC_H_XMLEND 13
#define wxSTC_H_SCRIPT 14
#define wxSTC_H_ASP 15
#define wxSTC_H_ASPAT 16
#define wxSTC_H_CDATA 17
#define wxSTC_H_QUESTION 18
/// More HTML
#define wxSTC_H_VALUE 19
/// X-Code
#define wxSTC_H_XCCOMMENT 20
/// SGML
#define wxSTC_H_SGML_DEFAULT 21
#define wxSTC_H_SGML_COMMAND 22
#define wxSTC_H_SGML_1ST_PARAM 23
#define wxSTC_H_SGML_DOUBLESTRING 24
#define wxSTC_H_SGML_SIMPLESTRING 25
#define wxSTC_H_SGML_ERROR 26
#define wxSTC_H_SGML_SPECIAL 27
#define wxSTC_H_SGML_ENTITY 28
#define wxSTC_H_SGML_COMMENT 29
#define wxSTC_H_SGML_1ST_PARAM_COMMENT 30
#define wxSTC_H_SGML_BLOCK_DEFAULT 31
/// Embedded Javascript
#define wxSTC_HJ_START 40
#define wxSTC_HJ_DEFAULT 41
#define wxSTC_HJ_COMMENT 42
#define wxSTC_HJ_COMMENTLINE 43
#define wxSTC_HJ_COMMENTDOC 44
#define wxSTC_HJ_NUMBER 45
#define wxSTC_HJ_WORD 46
#define wxSTC_HJ_KEYWORD 47
#define wxSTC_HJ_DOUBLESTRING 48
#define wxSTC_HJ_SINGLESTRING 49
#define wxSTC_HJ_SYMBOLS 50
#define wxSTC_HJ_STRINGEOL 51
#define wxSTC_HJ_REGEX 52
/// ASP Javascript
#define wxSTC_HJA_START 55
#define wxSTC_HJA_DEFAULT 56
#define wxSTC_HJA_COMMENT 57
#define wxSTC_HJA_COMMENTLINE 58
#define wxSTC_HJA_COMMENTDOC 59
#define wxSTC_HJA_NUMBER 60
#define wxSTC_HJA_WORD 61
#define wxSTC_HJA_KEYWORD 62
#define wxSTC_HJA_DOUBLESTRING 63
#define wxSTC_HJA_SINGLESTRING 64
#define wxSTC_HJA_SYMBOLS 65
#define wxSTC_HJA_STRINGEOL 66
#define wxSTC_HJA_REGEX 67
/// Embedded VBScript
#define wxSTC_HB_START 70
#define wxSTC_HB_DEFAULT 71
#define wxSTC_HB_COMMENTLINE 72
#define wxSTC_HB_NUMBER 73
#define wxSTC_HB_WORD 74
#define wxSTC_HB_STRING 75
#define wxSTC_HB_IDENTIFIER 76
#define wxSTC_HB_STRINGEOL 77
/// ASP VBScript
#define wxSTC_HBA_START 80
#define wxSTC_HBA_DEFAULT 81
#define wxSTC_HBA_COMMENTLINE 82
#define wxSTC_HBA_NUMBER 83
#define wxSTC_HBA_WORD 84
#define wxSTC_HBA_STRING 85
#define wxSTC_HBA_IDENTIFIER 86
#define wxSTC_HBA_STRINGEOL 87
/// Embedded Python
#define wxSTC_HP_START 90
#define wxSTC_HP_DEFAULT 91
#define wxSTC_HP_COMMENTLINE 92
#define wxSTC_HP_NUMBER 93
#define wxSTC_HP_STRING 94
#define wxSTC_HP_CHARACTER 95
#define wxSTC_HP_WORD 96
#define wxSTC_HP_TRIPLE 97
#define wxSTC_HP_TRIPLEDOUBLE 98
#define wxSTC_HP_CLASSNAME 99
#define wxSTC_HP_DEFNAME 100
#define wxSTC_HP_OPERATOR 101
#define wxSTC_HP_IDENTIFIER 102
/// PHP
#define wxSTC_HPHP_COMPLEX_VARIABLE 104
/// ASP Python
#define wxSTC_HPA_START 105
#define wxSTC_HPA_DEFAULT 106
#define wxSTC_HPA_COMMENTLINE 107
#define wxSTC_HPA_NUMBER 108
#define wxSTC_HPA_STRING 109
#define wxSTC_HPA_CHARACTER 110
#define wxSTC_HPA_WORD 111
#define wxSTC_HPA_TRIPLE 112
#define wxSTC_HPA_TRIPLEDOUBLE 113
#define wxSTC_HPA_CLASSNAME 114
#define wxSTC_HPA_DEFNAME 115
#define wxSTC_HPA_OPERATOR 116
#define wxSTC_HPA_IDENTIFIER 117
/// PHP
#define wxSTC_HPHP_DEFAULT 118
#define wxSTC_HPHP_HSTRING 119
#define wxSTC_HPHP_SIMPLESTRING 120
#define wxSTC_HPHP_WORD 121
#define wxSTC_HPHP_NUMBER 122
#define wxSTC_HPHP_VARIABLE 123
#define wxSTC_HPHP_COMMENT 124
#define wxSTC_HPHP_COMMENTLINE 125
#define wxSTC_HPHP_HSTRING_VARIABLE 126
#define wxSTC_HPHP_OPERATOR 127
/// Lexical states for SCLEX_PERL
#define wxSTC_PL_DEFAULT 0
#define wxSTC_PL_ERROR 1
#define wxSTC_PL_COMMENTLINE 2
#define wxSTC_PL_POD 3
#define wxSTC_PL_NUMBER 4
#define wxSTC_PL_WORD 5
#define wxSTC_PL_STRING 6
#define wxSTC_PL_CHARACTER 7
#define wxSTC_PL_PUNCTUATION 8
#define wxSTC_PL_PREPROCESSOR 9
#define wxSTC_PL_OPERATOR 10
#define wxSTC_PL_IDENTIFIER 11
#define wxSTC_PL_SCALAR 12
#define wxSTC_PL_ARRAY 13
#define wxSTC_PL_HASH 14
#define wxSTC_PL_SYMBOLTABLE 15
#define wxSTC_PL_VARIABLE_INDEXER 16
#define wxSTC_PL_REGEX 17
#define wxSTC_PL_REGSUBST 18
#define wxSTC_PL_LONGQUOTE 19
#define wxSTC_PL_BACKTICKS 20
#define wxSTC_PL_DATASECTION 21
#define wxSTC_PL_HERE_DELIM 22
#define wxSTC_PL_HERE_Q 23
#define wxSTC_PL_HERE_QQ 24
#define wxSTC_PL_HERE_QX 25
#define wxSTC_PL_STRING_Q 26
#define wxSTC_PL_STRING_QQ 27
#define wxSTC_PL_STRING_QX 28
#define wxSTC_PL_STRING_QR 29
#define wxSTC_PL_STRING_QW 30
#define wxSTC_PL_POD_VERB 31
#define wxSTC_PL_SUB_PROTOTYPE 40
#define wxSTC_PL_FORMAT_IDENT 41
#define wxSTC_PL_FORMAT 42
#define wxSTC_PL_STRING_VAR 43
#define wxSTC_PL_XLAT 44
#define wxSTC_PL_REGEX_VAR 54
#define wxSTC_PL_REGSUBST_VAR 55
#define wxSTC_PL_BACKTICKS_VAR 57
#define wxSTC_PL_HERE_QQ_VAR 61
#define wxSTC_PL_HERE_QX_VAR 62
#define wxSTC_PL_STRING_QQ_VAR 64
#define wxSTC_PL_STRING_QX_VAR 65
#define wxSTC_PL_STRING_QR_VAR 66
/// Lexical states for SCLEX_RUBY
#define wxSTC_RB_DEFAULT 0
#define wxSTC_RB_ERROR 1
#define wxSTC_RB_COMMENTLINE 2
#define wxSTC_RB_POD 3
#define wxSTC_RB_NUMBER 4
#define wxSTC_RB_WORD 5
#define wxSTC_RB_STRING 6
#define wxSTC_RB_CHARACTER 7
#define wxSTC_RB_CLASSNAME 8
#define wxSTC_RB_DEFNAME 9
#define wxSTC_RB_OPERATOR 10
#define wxSTC_RB_IDENTIFIER 11
#define wxSTC_RB_REGEX 12
#define wxSTC_RB_GLOBAL 13
#define wxSTC_RB_SYMBOL 14
#define wxSTC_RB_MODULE_NAME 15
#define wxSTC_RB_INSTANCE_VAR 16
#define wxSTC_RB_CLASS_VAR 17
#define wxSTC_RB_BACKTICKS 18
#define wxSTC_RB_DATASECTION 19
#define wxSTC_RB_HERE_DELIM 20
#define wxSTC_RB_HERE_Q 21
#define wxSTC_RB_HERE_QQ 22
#define wxSTC_RB_HERE_QX 23
#define wxSTC_RB_STRING_Q 24
#define wxSTC_RB_STRING_QQ 25
#define wxSTC_RB_STRING_QX 26
#define wxSTC_RB_STRING_QR 27
#define wxSTC_RB_STRING_QW 28
#define wxSTC_RB_WORD_DEMOTED 29
#define wxSTC_RB_STDIN 30
#define wxSTC_RB_STDOUT 31
#define wxSTC_RB_STDERR 40
#define wxSTC_RB_UPPER_BOUND 41
/// Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC, SCLEX_BLITZBASIC, SCLEX_PUREBASIC, SCLEX_FREEBASIC
#define wxSTC_B_DEFAULT 0
#define wxSTC_B_COMMENT 1
#define wxSTC_B_NUMBER 2
#define wxSTC_B_KEYWORD 3
#define wxSTC_B_STRING 4
#define wxSTC_B_PREPROCESSOR 5
#define wxSTC_B_OPERATOR 6
#define wxSTC_B_IDENTIFIER 7
#define wxSTC_B_DATE 8
#define wxSTC_B_STRINGEOL 9
#define wxSTC_B_KEYWORD2 10
#define wxSTC_B_KEYWORD3 11
#define wxSTC_B_KEYWORD4 12
#define wxSTC_B_CONSTANT 13
#define wxSTC_B_ASM 14
#define wxSTC_B_LABEL 15
#define wxSTC_B_ERROR 16
#define wxSTC_B_HEXNUMBER 17
#define wxSTC_B_BINNUMBER 18
#define wxSTC_B_COMMENTBLOCK 19
#define wxSTC_B_DOCLINE 20
#define wxSTC_B_DOCBLOCK 21
#define wxSTC_B_DOCKEYWORD 22
/// Lexical states for SCLEX_PROPERTIES
#define wxSTC_PROPS_DEFAULT 0
#define wxSTC_PROPS_COMMENT 1
#define wxSTC_PROPS_SECTION 2
#define wxSTC_PROPS_ASSIGNMENT 3
#define wxSTC_PROPS_DEFVAL 4
#define wxSTC_PROPS_KEY 5
/// Lexical states for SCLEX_LATEX
#define wxSTC_L_DEFAULT 0
#define wxSTC_L_COMMAND 1
#define wxSTC_L_TAG 2
#define wxSTC_L_MATH 3
#define wxSTC_L_COMMENT 4
#define wxSTC_L_TAG2 5
#define wxSTC_L_MATH2 6
#define wxSTC_L_COMMENT2 7
#define wxSTC_L_VERBATIM 8
#define wxSTC_L_SHORTCMD 9
#define wxSTC_L_SPECIAL 10
#define wxSTC_L_CMDOPT 11
#define wxSTC_L_ERROR 12
/// Lexical states for SCLEX_LUA
#define wxSTC_LUA_DEFAULT 0
#define wxSTC_LUA_COMMENT 1
#define wxSTC_LUA_COMMENTLINE 2
#define wxSTC_LUA_COMMENTDOC 3
#define wxSTC_LUA_NUMBER 4
#define wxSTC_LUA_WORD 5
#define wxSTC_LUA_STRING 6
#define wxSTC_LUA_CHARACTER 7
#define wxSTC_LUA_LITERALSTRING 8
#define wxSTC_LUA_PREPROCESSOR 9
#define wxSTC_LUA_OPERATOR 10
#define wxSTC_LUA_IDENTIFIER 11
#define wxSTC_LUA_STRINGEOL 12
#define wxSTC_LUA_WORD2 13
#define wxSTC_LUA_WORD3 14
#define wxSTC_LUA_WORD4 15
#define wxSTC_LUA_WORD5 16
#define wxSTC_LUA_WORD6 17
#define wxSTC_LUA_WORD7 18
#define wxSTC_LUA_WORD8 19
#define wxSTC_LUA_LABEL 20
/// Lexical states for SCLEX_ERRORLIST
#define wxSTC_ERR_DEFAULT 0
#define wxSTC_ERR_PYTHON 1
#define wxSTC_ERR_GCC 2
#define wxSTC_ERR_MS 3
#define wxSTC_ERR_CMD 4
#define wxSTC_ERR_BORLAND 5
#define wxSTC_ERR_PERL 6
#define wxSTC_ERR_NET 7
#define wxSTC_ERR_LUA 8
#define wxSTC_ERR_CTAG 9
#define wxSTC_ERR_DIFF_CHANGED 10
#define wxSTC_ERR_DIFF_ADDITION 11
#define wxSTC_ERR_DIFF_DELETION 12
#define wxSTC_ERR_DIFF_MESSAGE 13
#define wxSTC_ERR_PHP 14
#define wxSTC_ERR_ELF 15
#define wxSTC_ERR_IFC 16
#define wxSTC_ERR_IFORT 17
#define wxSTC_ERR_ABSF 18
#define wxSTC_ERR_TIDY 19
#define wxSTC_ERR_JAVA_STACK 20
#define wxSTC_ERR_VALUE 21
#define wxSTC_ERR_GCC_INCLUDED_FROM 22
#define wxSTC_ERR_ESCSEQ 23
#define wxSTC_ERR_ESCSEQ_UNKNOWN 24
#define wxSTC_ERR_ES_BLACK 40
#define wxSTC_ERR_ES_RED 41
#define wxSTC_ERR_ES_GREEN 42
#define wxSTC_ERR_ES_BROWN 43
#define wxSTC_ERR_ES_BLUE 44
#define wxSTC_ERR_ES_MAGENTA 45
#define wxSTC_ERR_ES_CYAN 46
#define wxSTC_ERR_ES_GRAY 47
#define wxSTC_ERR_ES_DARK_GRAY 48
#define wxSTC_ERR_ES_BRIGHT_RED 49
#define wxSTC_ERR_ES_BRIGHT_GREEN 50
#define wxSTC_ERR_ES_YELLOW 51
#define wxSTC_ERR_ES_BRIGHT_BLUE 52
#define wxSTC_ERR_ES_BRIGHT_MAGENTA 53
#define wxSTC_ERR_ES_BRIGHT_CYAN 54
#define wxSTC_ERR_ES_WHITE 55
/// Lexical states for SCLEX_BATCH
#define wxSTC_BAT_DEFAULT 0
#define wxSTC_BAT_COMMENT 1
#define wxSTC_BAT_WORD 2
#define wxSTC_BAT_LABEL 3
#define wxSTC_BAT_HIDE 4
#define wxSTC_BAT_COMMAND 5
#define wxSTC_BAT_IDENTIFIER 6
#define wxSTC_BAT_OPERATOR 7
/// Lexical states for SCLEX_TCMD
#define wxSTC_TCMD_DEFAULT 0
#define wxSTC_TCMD_COMMENT 1
#define wxSTC_TCMD_WORD 2
#define wxSTC_TCMD_LABEL 3
#define wxSTC_TCMD_HIDE 4
#define wxSTC_TCMD_COMMAND 5
#define wxSTC_TCMD_IDENTIFIER 6
#define wxSTC_TCMD_OPERATOR 7
#define wxSTC_TCMD_ENVIRONMENT 8
#define wxSTC_TCMD_EXPANSION 9
#define wxSTC_TCMD_CLABEL 10
/// Lexical states for SCLEX_MAKEFILE
#define wxSTC_MAKE_DEFAULT 0
#define wxSTC_MAKE_COMMENT 1
#define wxSTC_MAKE_PREPROCESSOR 2
#define wxSTC_MAKE_IDENTIFIER 3
#define wxSTC_MAKE_OPERATOR 4
#define wxSTC_MAKE_TARGET 5
#define wxSTC_MAKE_IDEOL 9
/// Lexical states for SCLEX_DIFF
#define wxSTC_DIFF_DEFAULT 0
#define wxSTC_DIFF_COMMENT 1
#define wxSTC_DIFF_COMMAND 2
#define wxSTC_DIFF_HEADER 3
#define wxSTC_DIFF_POSITION 4
#define wxSTC_DIFF_DELETED 5
#define wxSTC_DIFF_ADDED 6
#define wxSTC_DIFF_CHANGED 7
/// Lexical states for SCLEX_CONF (Apache Configuration Files Lexer)
#define wxSTC_CONF_DEFAULT 0
#define wxSTC_CONF_COMMENT 1
#define wxSTC_CONF_NUMBER 2
#define wxSTC_CONF_IDENTIFIER 3
#define wxSTC_CONF_EXTENSION 4
#define wxSTC_CONF_PARAMETER 5
#define wxSTC_CONF_STRING 6
#define wxSTC_CONF_OPERATOR 7
#define wxSTC_CONF_IP 8
#define wxSTC_CONF_DIRECTIVE 9
/// Lexical states for SCLEX_AVE, Avenue
#define wxSTC_AVE_DEFAULT 0
#define wxSTC_AVE_COMMENT 1
#define wxSTC_AVE_NUMBER 2
#define wxSTC_AVE_WORD 3
#define wxSTC_AVE_STRING 6
#define wxSTC_AVE_ENUM 7
#define wxSTC_AVE_STRINGEOL 8
#define wxSTC_AVE_IDENTIFIER 9
#define wxSTC_AVE_OPERATOR 10
#define wxSTC_AVE_WORD1 11
#define wxSTC_AVE_WORD2 12
#define wxSTC_AVE_WORD3 13
#define wxSTC_AVE_WORD4 14
#define wxSTC_AVE_WORD5 15
#define wxSTC_AVE_WORD6 16
/// Lexical states for SCLEX_ADA
#define wxSTC_ADA_DEFAULT 0
#define wxSTC_ADA_WORD 1
#define wxSTC_ADA_IDENTIFIER 2
#define wxSTC_ADA_NUMBER 3
#define wxSTC_ADA_DELIMITER 4
#define wxSTC_ADA_CHARACTER 5
#define wxSTC_ADA_CHARACTEREOL 6
#define wxSTC_ADA_STRING 7
#define wxSTC_ADA_STRINGEOL 8
#define wxSTC_ADA_LABEL 9
#define wxSTC_ADA_COMMENTLINE 10
#define wxSTC_ADA_ILLEGAL 11
/// Lexical states for SCLEX_BAAN
#define wxSTC_BAAN_DEFAULT 0
#define wxSTC_BAAN_COMMENT 1
#define wxSTC_BAAN_COMMENTDOC 2
#define wxSTC_BAAN_NUMBER 3
#define wxSTC_BAAN_WORD 4
#define wxSTC_BAAN_STRING 5
#define wxSTC_BAAN_PREPROCESSOR 6
#define wxSTC_BAAN_OPERATOR 7
#define wxSTC_BAAN_IDENTIFIER 8
#define wxSTC_BAAN_STRINGEOL 9
#define wxSTC_BAAN_WORD2 10
#define wxSTC_BAAN_WORD3 11
#define wxSTC_BAAN_WORD4 12
#define wxSTC_BAAN_WORD5 13
#define wxSTC_BAAN_WORD6 14
#define wxSTC_BAAN_WORD7 15
#define wxSTC_BAAN_WORD8 16
#define wxSTC_BAAN_WORD9 17
#define wxSTC_BAAN_TABLEDEF 18
#define wxSTC_BAAN_TABLESQL 19
#define wxSTC_BAAN_FUNCTION 20
#define wxSTC_BAAN_DOMDEF 21
#define wxSTC_BAAN_FUNCDEF 22
#define wxSTC_BAAN_OBJECTDEF 23
#define wxSTC_BAAN_DEFINEDEF 24
/// Lexical states for SCLEX_LISP
#define wxSTC_LISP_DEFAULT 0
#define wxSTC_LISP_COMMENT 1
#define wxSTC_LISP_NUMBER 2
#define wxSTC_LISP_KEYWORD 3
#define wxSTC_LISP_KEYWORD_KW 4
#define wxSTC_LISP_SYMBOL 5
#define wxSTC_LISP_STRING 6
#define wxSTC_LISP_STRINGEOL 8
#define wxSTC_LISP_IDENTIFIER 9
#define wxSTC_LISP_OPERATOR 10
#define wxSTC_LISP_SPECIAL 11
#define wxSTC_LISP_MULTI_COMMENT 12
/// Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW
#define wxSTC_EIFFEL_DEFAULT 0
#define wxSTC_EIFFEL_COMMENTLINE 1
#define wxSTC_EIFFEL_NUMBER 2
#define wxSTC_EIFFEL_WORD 3
#define wxSTC_EIFFEL_STRING 4
#define wxSTC_EIFFEL_CHARACTER 5
#define wxSTC_EIFFEL_OPERATOR 6
#define wxSTC_EIFFEL_IDENTIFIER 7
#define wxSTC_EIFFEL_STRINGEOL 8
/// Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer)
#define wxSTC_NNCRONTAB_DEFAULT 0
#define wxSTC_NNCRONTAB_COMMENT 1
#define wxSTC_NNCRONTAB_TASK 2
#define wxSTC_NNCRONTAB_SECTION 3
#define wxSTC_NNCRONTAB_KEYWORD 4
#define wxSTC_NNCRONTAB_MODIFIER 5
#define wxSTC_NNCRONTAB_ASTERISK 6
#define wxSTC_NNCRONTAB_NUMBER 7
#define wxSTC_NNCRONTAB_STRING 8
#define wxSTC_NNCRONTAB_ENVIRONMENT 9
#define wxSTC_NNCRONTAB_IDENTIFIER 10
/// Lexical states for SCLEX_FORTH (Forth Lexer)
#define wxSTC_FORTH_DEFAULT 0
#define wxSTC_FORTH_COMMENT 1
#define wxSTC_FORTH_COMMENT_ML 2
#define wxSTC_FORTH_IDENTIFIER 3
#define wxSTC_FORTH_CONTROL 4
#define wxSTC_FORTH_KEYWORD 5
#define wxSTC_FORTH_DEFWORD 6
#define wxSTC_FORTH_PREWORD1 7
#define wxSTC_FORTH_PREWORD2 8
#define wxSTC_FORTH_NUMBER 9
#define wxSTC_FORTH_STRING 10
#define wxSTC_FORTH_LOCALE 11
/// Lexical states for SCLEX_MATLAB
#define wxSTC_MATLAB_DEFAULT 0
#define wxSTC_MATLAB_COMMENT 1
#define wxSTC_MATLAB_COMMAND 2
#define wxSTC_MATLAB_NUMBER 3
#define wxSTC_MATLAB_KEYWORD 4
/// single quoted string
#define wxSTC_MATLAB_STRING 5
#define wxSTC_MATLAB_OPERATOR 6
#define wxSTC_MATLAB_IDENTIFIER 7
#define wxSTC_MATLAB_DOUBLEQUOTESTRING 8
/// Lexical states for SCLEX_SCRIPTOL
#define wxSTC_SCRIPTOL_DEFAULT 0
#define wxSTC_SCRIPTOL_WHITE 1
#define wxSTC_SCRIPTOL_COMMENTLINE 2
#define wxSTC_SCRIPTOL_PERSISTENT 3
#define wxSTC_SCRIPTOL_CSTYLE 4
#define wxSTC_SCRIPTOL_COMMENTBLOCK 5
#define wxSTC_SCRIPTOL_NUMBER 6
#define wxSTC_SCRIPTOL_STRING 7
#define wxSTC_SCRIPTOL_CHARACTER 8
#define wxSTC_SCRIPTOL_STRINGEOL 9
#define wxSTC_SCRIPTOL_KEYWORD 10
#define wxSTC_SCRIPTOL_OPERATOR 11
#define wxSTC_SCRIPTOL_IDENTIFIER 12
#define wxSTC_SCRIPTOL_TRIPLE 13
#define wxSTC_SCRIPTOL_CLASSNAME 14
#define wxSTC_SCRIPTOL_PREPROCESSOR 15
/// Lexical states for SCLEX_ASM, SCLEX_AS
#define wxSTC_ASM_DEFAULT 0
#define wxSTC_ASM_COMMENT 1
#define wxSTC_ASM_NUMBER 2
#define wxSTC_ASM_STRING 3
#define wxSTC_ASM_OPERATOR 4
#define wxSTC_ASM_IDENTIFIER 5
#define wxSTC_ASM_CPUINSTRUCTION 6
#define wxSTC_ASM_MATHINSTRUCTION 7
#define wxSTC_ASM_REGISTER 8
#define wxSTC_ASM_DIRECTIVE 9
#define wxSTC_ASM_DIRECTIVEOPERAND 10
#define wxSTC_ASM_COMMENTBLOCK 11
#define wxSTC_ASM_CHARACTER 12
#define wxSTC_ASM_STRINGEOL 13
#define wxSTC_ASM_EXTINSTRUCTION 14
#define wxSTC_ASM_COMMENTDIRECTIVE 15
/// Lexical states for SCLEX_FORTRAN
#define wxSTC_F_DEFAULT 0
#define wxSTC_F_COMMENT 1
#define wxSTC_F_NUMBER 2
#define wxSTC_F_STRING1 3
#define wxSTC_F_STRING2 4
#define wxSTC_F_STRINGEOL 5
#define wxSTC_F_OPERATOR 6
#define wxSTC_F_IDENTIFIER 7
#define wxSTC_F_WORD 8
#define wxSTC_F_WORD2 9
#define wxSTC_F_WORD3 10
#define wxSTC_F_PREPROCESSOR 11
#define wxSTC_F_OPERATOR2 12
#define wxSTC_F_LABEL 13
#define wxSTC_F_CONTINUATION 14
/// Lexical states for SCLEX_CSS
#define wxSTC_CSS_DEFAULT 0
#define wxSTC_CSS_TAG 1
#define wxSTC_CSS_CLASS 2
#define wxSTC_CSS_PSEUDOCLASS 3
#define wxSTC_CSS_UNKNOWN_PSEUDOCLASS 4
#define wxSTC_CSS_OPERATOR 5
#define wxSTC_CSS_IDENTIFIER 6
#define wxSTC_CSS_UNKNOWN_IDENTIFIER 7
#define wxSTC_CSS_VALUE 8
#define wxSTC_CSS_COMMENT 9
#define wxSTC_CSS_ID 10
#define wxSTC_CSS_IMPORTANT 11
#define wxSTC_CSS_DIRECTIVE 12
#define wxSTC_CSS_DOUBLESTRING 13
#define wxSTC_CSS_SINGLESTRING 14
#define wxSTC_CSS_IDENTIFIER2 15
#define wxSTC_CSS_ATTRIBUTE 16
#define wxSTC_CSS_IDENTIFIER3 17
#define wxSTC_CSS_PSEUDOELEMENT 18
#define wxSTC_CSS_EXTENDED_IDENTIFIER 19
#define wxSTC_CSS_EXTENDED_PSEUDOCLASS 20
#define wxSTC_CSS_EXTENDED_PSEUDOELEMENT 21
#define wxSTC_CSS_MEDIA 22
#define wxSTC_CSS_VARIABLE 23
/// Lexical states for SCLEX_POV
#define wxSTC_POV_DEFAULT 0
#define wxSTC_POV_COMMENT 1
#define wxSTC_POV_COMMENTLINE 2
#define wxSTC_POV_NUMBER 3
#define wxSTC_POV_OPERATOR 4
#define wxSTC_POV_IDENTIFIER 5
#define wxSTC_POV_STRING 6
#define wxSTC_POV_STRINGEOL 7
#define wxSTC_POV_DIRECTIVE 8
#define wxSTC_POV_BADDIRECTIVE 9
#define wxSTC_POV_WORD2 10
#define wxSTC_POV_WORD3 11
#define wxSTC_POV_WORD4 12
#define wxSTC_POV_WORD5 13
#define wxSTC_POV_WORD6 14
#define wxSTC_POV_WORD7 15
#define wxSTC_POV_WORD8 16
/// Lexical states for SCLEX_LOUT
#define wxSTC_LOUT_DEFAULT 0
#define wxSTC_LOUT_COMMENT 1
#define wxSTC_LOUT_NUMBER 2
#define wxSTC_LOUT_WORD 3
#define wxSTC_LOUT_WORD2 4
#define wxSTC_LOUT_WORD3 5
#define wxSTC_LOUT_WORD4 6
#define wxSTC_LOUT_STRING 7
#define wxSTC_LOUT_OPERATOR 8
#define wxSTC_LOUT_IDENTIFIER 9
#define wxSTC_LOUT_STRINGEOL 10
/// Lexical states for SCLEX_ESCRIPT
#define wxSTC_ESCRIPT_DEFAULT 0
#define wxSTC_ESCRIPT_COMMENT 1
#define wxSTC_ESCRIPT_COMMENTLINE 2
#define wxSTC_ESCRIPT_COMMENTDOC 3
#define wxSTC_ESCRIPT_NUMBER 4
#define wxSTC_ESCRIPT_WORD 5
#define wxSTC_ESCRIPT_STRING 6
#define wxSTC_ESCRIPT_OPERATOR 7
#define wxSTC_ESCRIPT_IDENTIFIER 8
#define wxSTC_ESCRIPT_BRACE 9
#define wxSTC_ESCRIPT_WORD2 10
#define wxSTC_ESCRIPT_WORD3 11
/// Lexical states for SCLEX_PS
#define wxSTC_PS_DEFAULT 0
#define wxSTC_PS_COMMENT 1
#define wxSTC_PS_DSC_COMMENT 2
#define wxSTC_PS_DSC_VALUE 3
#define wxSTC_PS_NUMBER 4
#define wxSTC_PS_NAME 5
#define wxSTC_PS_KEYWORD 6
#define wxSTC_PS_LITERAL 7
#define wxSTC_PS_IMMEVAL 8
#define wxSTC_PS_PAREN_ARRAY 9
#define wxSTC_PS_PAREN_DICT 10
#define wxSTC_PS_PAREN_PROC 11
#define wxSTC_PS_TEXT 12
#define wxSTC_PS_HEXSTRING 13
#define wxSTC_PS_BASE85STRING 14
#define wxSTC_PS_BADSTRINGCHAR 15
/// Lexical states for SCLEX_NSIS
#define wxSTC_NSIS_DEFAULT 0
#define wxSTC_NSIS_COMMENT 1
#define wxSTC_NSIS_STRINGDQ 2
#define wxSTC_NSIS_STRINGLQ 3
#define wxSTC_NSIS_STRINGRQ 4
#define wxSTC_NSIS_FUNCTION 5
#define wxSTC_NSIS_VARIABLE 6
#define wxSTC_NSIS_LABEL 7
#define wxSTC_NSIS_USERDEFINED 8
#define wxSTC_NSIS_SECTIONDEF 9
#define wxSTC_NSIS_SUBSECTIONDEF 10
#define wxSTC_NSIS_IFDEFINEDEF 11
#define wxSTC_NSIS_MACRODEF 12
#define wxSTC_NSIS_STRINGVAR 13
#define wxSTC_NSIS_NUMBER 14
#define wxSTC_NSIS_SECTIONGROUP 15
#define wxSTC_NSIS_PAGEEX 16
#define wxSTC_NSIS_FUNCTIONDEF 17
#define wxSTC_NSIS_COMMENTBOX 18
/// Lexical states for SCLEX_MMIXAL
#define wxSTC_MMIXAL_LEADWS 0
#define wxSTC_MMIXAL_COMMENT 1
#define wxSTC_MMIXAL_LABEL 2
#define wxSTC_MMIXAL_OPCODE 3
#define wxSTC_MMIXAL_OPCODE_PRE 4
#define wxSTC_MMIXAL_OPCODE_VALID 5
#define wxSTC_MMIXAL_OPCODE_UNKNOWN 6
#define wxSTC_MMIXAL_OPCODE_POST 7
#define wxSTC_MMIXAL_OPERANDS 8
#define wxSTC_MMIXAL_NUMBER 9
#define wxSTC_MMIXAL_REF 10
#define wxSTC_MMIXAL_CHAR 11
#define wxSTC_MMIXAL_STRING 12
#define wxSTC_MMIXAL_REGISTER 13
#define wxSTC_MMIXAL_HEX 14
#define wxSTC_MMIXAL_OPERATOR 15
#define wxSTC_MMIXAL_SYMBOL 16
#define wxSTC_MMIXAL_INCLUDE 17
/// Lexical states for SCLEX_CLW
#define wxSTC_CLW_DEFAULT 0
#define wxSTC_CLW_LABEL 1
#define wxSTC_CLW_COMMENT 2
#define wxSTC_CLW_STRING 3
#define wxSTC_CLW_USER_IDENTIFIER 4
#define wxSTC_CLW_INTEGER_CONSTANT 5
#define wxSTC_CLW_REAL_CONSTANT 6
#define wxSTC_CLW_PICTURE_STRING 7
#define wxSTC_CLW_KEYWORD 8
#define wxSTC_CLW_COMPILER_DIRECTIVE 9
#define wxSTC_CLW_RUNTIME_EXPRESSIONS 10
#define wxSTC_CLW_BUILTIN_PROCEDURES_FUNCTION 11
#define wxSTC_CLW_STRUCTURE_DATA_TYPE 12
#define wxSTC_CLW_ATTRIBUTE 13
#define wxSTC_CLW_STANDARD_EQUATE 14
#define wxSTC_CLW_ERROR 15
#define wxSTC_CLW_DEPRECATED 16
/// Lexical states for SCLEX_LOT
#define wxSTC_LOT_DEFAULT 0
#define wxSTC_LOT_HEADER 1
#define wxSTC_LOT_BREAK 2
#define wxSTC_LOT_SET 3
#define wxSTC_LOT_PASS 4
#define wxSTC_LOT_FAIL 5
#define wxSTC_LOT_ABORT 6
/// Lexical states for SCLEX_YAML
#define wxSTC_YAML_DEFAULT 0
#define wxSTC_YAML_COMMENT 1
#define wxSTC_YAML_IDENTIFIER 2
#define wxSTC_YAML_KEYWORD 3
#define wxSTC_YAML_NUMBER 4
#define wxSTC_YAML_REFERENCE 5
#define wxSTC_YAML_DOCUMENT 6
#define wxSTC_YAML_TEXT 7
#define wxSTC_YAML_ERROR 8
#define wxSTC_YAML_OPERATOR 9
/// Lexical states for SCLEX_TEX
#define wxSTC_TEX_DEFAULT 0
#define wxSTC_TEX_SPECIAL 1
#define wxSTC_TEX_GROUP 2
#define wxSTC_TEX_SYMBOL 3
#define wxSTC_TEX_COMMAND 4
#define wxSTC_TEX_TEXT 5
#define wxSTC_METAPOST_DEFAULT 0
#define wxSTC_METAPOST_SPECIAL 1
#define wxSTC_METAPOST_GROUP 2
#define wxSTC_METAPOST_SYMBOL 3
#define wxSTC_METAPOST_COMMAND 4
#define wxSTC_METAPOST_TEXT 5
#define wxSTC_METAPOST_EXTRA 6
/// Lexical states for SCLEX_ERLANG
#define wxSTC_ERLANG_DEFAULT 0
#define wxSTC_ERLANG_COMMENT 1
#define wxSTC_ERLANG_VARIABLE 2
#define wxSTC_ERLANG_NUMBER 3
#define wxSTC_ERLANG_KEYWORD 4
#define wxSTC_ERLANG_STRING 5
#define wxSTC_ERLANG_OPERATOR 6
#define wxSTC_ERLANG_ATOM 7
#define wxSTC_ERLANG_FUNCTION_NAME 8
#define wxSTC_ERLANG_CHARACTER 9
#define wxSTC_ERLANG_MACRO 10
#define wxSTC_ERLANG_RECORD 11
#define wxSTC_ERLANG_PREPROC 12
#define wxSTC_ERLANG_NODE_NAME 13
#define wxSTC_ERLANG_COMMENT_FUNCTION 14
#define wxSTC_ERLANG_COMMENT_MODULE 15
#define wxSTC_ERLANG_COMMENT_DOC 16
#define wxSTC_ERLANG_COMMENT_DOC_MACRO 17
#define wxSTC_ERLANG_ATOM_QUOTED 18
#define wxSTC_ERLANG_MACRO_QUOTED 19
#define wxSTC_ERLANG_RECORD_QUOTED 20
#define wxSTC_ERLANG_NODE_NAME_QUOTED 21
#define wxSTC_ERLANG_BIFS 22
#define wxSTC_ERLANG_MODULES 23
#define wxSTC_ERLANG_MODULES_ATT 24
#define wxSTC_ERLANG_UNKNOWN 31
/// Lexical states for SCLEX_OCTAVE are identical to MatLab
/// Lexical states for SCLEX_MSSQL
#define wxSTC_MSSQL_DEFAULT 0
#define wxSTC_MSSQL_COMMENT 1
#define wxSTC_MSSQL_LINE_COMMENT 2
#define wxSTC_MSSQL_NUMBER 3
#define wxSTC_MSSQL_STRING 4
#define wxSTC_MSSQL_OPERATOR 5
#define wxSTC_MSSQL_IDENTIFIER 6
#define wxSTC_MSSQL_VARIABLE 7
#define wxSTC_MSSQL_COLUMN_NAME 8
#define wxSTC_MSSQL_STATEMENT 9
#define wxSTC_MSSQL_DATATYPE 10
#define wxSTC_MSSQL_SYSTABLE 11
#define wxSTC_MSSQL_GLOBAL_VARIABLE 12
#define wxSTC_MSSQL_FUNCTION 13
#define wxSTC_MSSQL_STORED_PROCEDURE 14
#define wxSTC_MSSQL_DEFAULT_PREF_DATATYPE 15
#define wxSTC_MSSQL_COLUMN_NAME_2 16
/// Lexical states for SCLEX_VERILOG
#define wxSTC_V_DEFAULT 0
#define wxSTC_V_COMMENT 1
#define wxSTC_V_COMMENTLINE 2
#define wxSTC_V_COMMENTLINEBANG 3
#define wxSTC_V_NUMBER 4
#define wxSTC_V_WORD 5
#define wxSTC_V_STRING 6
#define wxSTC_V_WORD2 7
#define wxSTC_V_WORD3 8
#define wxSTC_V_PREPROCESSOR 9
#define wxSTC_V_OPERATOR 10
#define wxSTC_V_IDENTIFIER 11
#define wxSTC_V_STRINGEOL 12
#define wxSTC_V_USER 19
#define wxSTC_V_COMMENT_WORD 20
#define wxSTC_V_INPUT 21
#define wxSTC_V_OUTPUT 22
#define wxSTC_V_INOUT 23
#define wxSTC_V_PORT_CONNECT 24
/// Lexical states for SCLEX_KIX
#define wxSTC_KIX_DEFAULT 0
#define wxSTC_KIX_COMMENT 1
#define wxSTC_KIX_STRING1 2
#define wxSTC_KIX_STRING2 3
#define wxSTC_KIX_NUMBER 4
#define wxSTC_KIX_VAR 5
#define wxSTC_KIX_MACRO 6
#define wxSTC_KIX_KEYWORD 7
#define wxSTC_KIX_FUNCTIONS 8
#define wxSTC_KIX_OPERATOR 9
#define wxSTC_KIX_COMMENTSTREAM 10
#define wxSTC_KIX_IDENTIFIER 31
/// Lexical states for SCLEX_GUI4CLI
#define wxSTC_GC_DEFAULT 0
#define wxSTC_GC_COMMENTLINE 1
#define wxSTC_GC_COMMENTBLOCK 2
#define wxSTC_GC_GLOBAL 3
#define wxSTC_GC_EVENT 4
#define wxSTC_GC_ATTRIBUTE 5
#define wxSTC_GC_CONTROL 6
#define wxSTC_GC_COMMAND 7
#define wxSTC_GC_STRING 8
#define wxSTC_GC_OPERATOR 9
/// Lexical states for SCLEX_SPECMAN
#define wxSTC_SN_DEFAULT 0
#define wxSTC_SN_CODE 1
#define wxSTC_SN_COMMENTLINE 2
#define wxSTC_SN_COMMENTLINEBANG 3
#define wxSTC_SN_NUMBER 4
#define wxSTC_SN_WORD 5
#define wxSTC_SN_STRING 6
#define wxSTC_SN_WORD2 7
#define wxSTC_SN_WORD3 8
#define wxSTC_SN_PREPROCESSOR 9
#define wxSTC_SN_OPERATOR 10
#define wxSTC_SN_IDENTIFIER 11
#define wxSTC_SN_STRINGEOL 12
#define wxSTC_SN_REGEXTAG 13
#define wxSTC_SN_SIGNAL 14
#define wxSTC_SN_USER 19
/// Lexical states for SCLEX_AU3
#define wxSTC_AU3_DEFAULT 0
#define wxSTC_AU3_COMMENT 1
#define wxSTC_AU3_COMMENTBLOCK 2
#define wxSTC_AU3_NUMBER 3
#define wxSTC_AU3_FUNCTION 4
#define wxSTC_AU3_KEYWORD 5
#define wxSTC_AU3_MACRO 6
#define wxSTC_AU3_STRING 7
#define wxSTC_AU3_OPERATOR 8
#define wxSTC_AU3_VARIABLE 9
#define wxSTC_AU3_SENT 10
#define wxSTC_AU3_PREPROCESSOR 11
#define wxSTC_AU3_SPECIAL 12
#define wxSTC_AU3_EXPAND 13
#define wxSTC_AU3_COMOBJ 14
#define wxSTC_AU3_UDF 15
/// Lexical states for SCLEX_APDL
#define wxSTC_APDL_DEFAULT 0
#define wxSTC_APDL_COMMENT 1
#define wxSTC_APDL_COMMENTBLOCK 2
#define wxSTC_APDL_NUMBER 3
#define wxSTC_APDL_STRING 4
#define wxSTC_APDL_OPERATOR 5
#define wxSTC_APDL_WORD 6
#define wxSTC_APDL_PROCESSOR 7
#define wxSTC_APDL_COMMAND 8
#define wxSTC_APDL_SLASHCOMMAND 9
#define wxSTC_APDL_STARCOMMAND 10
#define wxSTC_APDL_ARGUMENT 11
#define wxSTC_APDL_FUNCTION 12
/// Lexical states for SCLEX_BASH
#define wxSTC_SH_DEFAULT 0
#define wxSTC_SH_ERROR 1
#define wxSTC_SH_COMMENTLINE 2
#define wxSTC_SH_NUMBER 3
#define wxSTC_SH_WORD 4
#define wxSTC_SH_STRING 5
#define wxSTC_SH_CHARACTER 6
#define wxSTC_SH_OPERATOR 7
#define wxSTC_SH_IDENTIFIER 8
#define wxSTC_SH_SCALAR 9
#define wxSTC_SH_PARAM 10
#define wxSTC_SH_BACKTICKS 11
#define wxSTC_SH_HERE_DELIM 12
#define wxSTC_SH_HERE_Q 13
/// Lexical states for SCLEX_ASN1
#define wxSTC_ASN1_DEFAULT 0
#define wxSTC_ASN1_COMMENT 1
#define wxSTC_ASN1_IDENTIFIER 2
#define wxSTC_ASN1_STRING 3
#define wxSTC_ASN1_OID 4
#define wxSTC_ASN1_SCALAR 5
#define wxSTC_ASN1_KEYWORD 6
#define wxSTC_ASN1_ATTRIBUTE 7
#define wxSTC_ASN1_DESCRIPTOR 8
#define wxSTC_ASN1_TYPE 9
#define wxSTC_ASN1_OPERATOR 10
/// Lexical states for SCLEX_VHDL
#define wxSTC_VHDL_DEFAULT 0
#define wxSTC_VHDL_COMMENT 1
#define wxSTC_VHDL_COMMENTLINEBANG 2
#define wxSTC_VHDL_NUMBER 3
#define wxSTC_VHDL_STRING 4
#define wxSTC_VHDL_OPERATOR 5
#define wxSTC_VHDL_IDENTIFIER 6
#define wxSTC_VHDL_STRINGEOL 7
#define wxSTC_VHDL_KEYWORD 8
#define wxSTC_VHDL_STDOPERATOR 9
#define wxSTC_VHDL_ATTRIBUTE 10
#define wxSTC_VHDL_STDFUNCTION 11
#define wxSTC_VHDL_STDPACKAGE 12
#define wxSTC_VHDL_STDTYPE 13
#define wxSTC_VHDL_USERWORD 14
#define wxSTC_VHDL_BLOCK_COMMENT 15
/// Lexical states for SCLEX_CAML
#define wxSTC_CAML_DEFAULT 0
#define wxSTC_CAML_IDENTIFIER 1
#define wxSTC_CAML_TAGNAME 2
#define wxSTC_CAML_KEYWORD 3
#define wxSTC_CAML_KEYWORD2 4
#define wxSTC_CAML_KEYWORD3 5
#define wxSTC_CAML_LINENUM 6
#define wxSTC_CAML_OPERATOR 7
#define wxSTC_CAML_NUMBER 8
#define wxSTC_CAML_CHAR 9
#define wxSTC_CAML_WHITE 10
#define wxSTC_CAML_STRING 11
#define wxSTC_CAML_COMMENT 12
#define wxSTC_CAML_COMMENT1 13
#define wxSTC_CAML_COMMENT2 14
#define wxSTC_CAML_COMMENT3 15
/// Lexical states for SCLEX_HASKELL
#define wxSTC_HA_DEFAULT 0
#define wxSTC_HA_IDENTIFIER 1
#define wxSTC_HA_KEYWORD 2
#define wxSTC_HA_NUMBER 3
#define wxSTC_HA_STRING 4
#define wxSTC_HA_CHARACTER 5
#define wxSTC_HA_CLASS 6
#define wxSTC_HA_MODULE 7
#define wxSTC_HA_CAPITAL 8
#define wxSTC_HA_DATA 9
#define wxSTC_HA_IMPORT 10
#define wxSTC_HA_OPERATOR 11
#define wxSTC_HA_INSTANCE 12
#define wxSTC_HA_COMMENTLINE 13
#define wxSTC_HA_COMMENTBLOCK 14
#define wxSTC_HA_COMMENTBLOCK2 15
#define wxSTC_HA_COMMENTBLOCK3 16
#define wxSTC_HA_PRAGMA 17
#define wxSTC_HA_PREPROCESSOR 18
#define wxSTC_HA_STRINGEOL 19
#define wxSTC_HA_RESERVED_OPERATOR 20
#define wxSTC_HA_LITERATE_COMMENT 21
#define wxSTC_HA_LITERATE_CODEDELIM 22
/// Lexical states of SCLEX_TADS3
#define wxSTC_T3_DEFAULT 0
#define wxSTC_T3_X_DEFAULT 1
#define wxSTC_T3_PREPROCESSOR 2
#define wxSTC_T3_BLOCK_COMMENT 3
#define wxSTC_T3_LINE_COMMENT 4
#define wxSTC_T3_OPERATOR 5
#define wxSTC_T3_KEYWORD 6
#define wxSTC_T3_NUMBER 7
#define wxSTC_T3_IDENTIFIER 8
#define wxSTC_T3_S_STRING 9
#define wxSTC_T3_D_STRING 10
#define wxSTC_T3_X_STRING 11
#define wxSTC_T3_LIB_DIRECTIVE 12
#define wxSTC_T3_MSG_PARAM 13
#define wxSTC_T3_HTML_TAG 14
#define wxSTC_T3_HTML_DEFAULT 15
#define wxSTC_T3_HTML_STRING 16
#define wxSTC_T3_USER1 17
#define wxSTC_T3_USER2 18
#define wxSTC_T3_USER3 19
#define wxSTC_T3_BRACE 20
/// Lexical states for SCLEX_REBOL
#define wxSTC_REBOL_DEFAULT 0
#define wxSTC_REBOL_COMMENTLINE 1
#define wxSTC_REBOL_COMMENTBLOCK 2
#define wxSTC_REBOL_PREFACE 3
#define wxSTC_REBOL_OPERATOR 4
#define wxSTC_REBOL_CHARACTER 5
#define wxSTC_REBOL_QUOTEDSTRING 6
#define wxSTC_REBOL_BRACEDSTRING 7
#define wxSTC_REBOL_NUMBER 8
#define wxSTC_REBOL_PAIR 9
#define wxSTC_REBOL_TUPLE 10
#define wxSTC_REBOL_BINARY 11
#define wxSTC_REBOL_MONEY 12
#define wxSTC_REBOL_ISSUE 13
#define wxSTC_REBOL_TAG 14
#define wxSTC_REBOL_FILE 15
#define wxSTC_REBOL_EMAIL 16
#define wxSTC_REBOL_URL 17
#define wxSTC_REBOL_DATE 18
#define wxSTC_REBOL_TIME 19
#define wxSTC_REBOL_IDENTIFIER 20
#define wxSTC_REBOL_WORD 21
#define wxSTC_REBOL_WORD2 22
#define wxSTC_REBOL_WORD3 23
#define wxSTC_REBOL_WORD4 24
#define wxSTC_REBOL_WORD5 25
#define wxSTC_REBOL_WORD6 26
#define wxSTC_REBOL_WORD7 27
#define wxSTC_REBOL_WORD8 28
/// Lexical states for SCLEX_SQL
#define wxSTC_SQL_DEFAULT 0
#define wxSTC_SQL_COMMENT 1
#define wxSTC_SQL_COMMENTLINE 2
#define wxSTC_SQL_COMMENTDOC 3
#define wxSTC_SQL_NUMBER 4
#define wxSTC_SQL_WORD 5
#define wxSTC_SQL_STRING 6
#define wxSTC_SQL_CHARACTER 7
#define wxSTC_SQL_SQLPLUS 8
#define wxSTC_SQL_SQLPLUS_PROMPT 9
#define wxSTC_SQL_OPERATOR 10
#define wxSTC_SQL_IDENTIFIER 11
#define wxSTC_SQL_SQLPLUS_COMMENT 13
#define wxSTC_SQL_COMMENTLINEDOC 15
#define wxSTC_SQL_WORD2 16
#define wxSTC_SQL_COMMENTDOCKEYWORD 17
#define wxSTC_SQL_COMMENTDOCKEYWORDERROR 18
#define wxSTC_SQL_USER1 19
#define wxSTC_SQL_USER2 20
#define wxSTC_SQL_USER3 21
#define wxSTC_SQL_USER4 22
#define wxSTC_SQL_QUOTEDIDENTIFIER 23
#define wxSTC_SQL_QOPERATOR 24
/// Lexical states for SCLEX_SMALLTALK
#define wxSTC_ST_DEFAULT 0
#define wxSTC_ST_STRING 1
#define wxSTC_ST_NUMBER 2
#define wxSTC_ST_COMMENT 3
#define wxSTC_ST_SYMBOL 4
#define wxSTC_ST_BINARY 5
#define wxSTC_ST_BOOL 6
#define wxSTC_ST_SELF 7
#define wxSTC_ST_SUPER 8
#define wxSTC_ST_NIL 9
#define wxSTC_ST_GLOBAL 10
#define wxSTC_ST_RETURN 11
#define wxSTC_ST_SPECIAL 12
#define wxSTC_ST_KWSEND 13
#define wxSTC_ST_ASSIGN 14
#define wxSTC_ST_CHARACTER 15
#define wxSTC_ST_SPEC_SEL 16
/// Lexical states for SCLEX_FLAGSHIP (clipper)
#define wxSTC_FS_DEFAULT 0
#define wxSTC_FS_COMMENT 1
#define wxSTC_FS_COMMENTLINE 2
#define wxSTC_FS_COMMENTDOC 3
#define wxSTC_FS_COMMENTLINEDOC 4
#define wxSTC_FS_COMMENTDOCKEYWORD 5
#define wxSTC_FS_COMMENTDOCKEYWORDERROR 6
#define wxSTC_FS_KEYWORD 7
#define wxSTC_FS_KEYWORD2 8
#define wxSTC_FS_KEYWORD3 9
#define wxSTC_FS_KEYWORD4 10
#define wxSTC_FS_NUMBER 11
#define wxSTC_FS_STRING 12
#define wxSTC_FS_PREPROCESSOR 13
#define wxSTC_FS_OPERATOR 14
#define wxSTC_FS_IDENTIFIER 15
#define wxSTC_FS_DATE 16
#define wxSTC_FS_STRINGEOL 17
#define wxSTC_FS_CONSTANT 18
#define wxSTC_FS_WORDOPERATOR 19
#define wxSTC_FS_DISABLEDCODE 20
#define wxSTC_FS_DEFAULT_C 21
#define wxSTC_FS_COMMENTDOC_C 22
#define wxSTC_FS_COMMENTLINEDOC_C 23
#define wxSTC_FS_KEYWORD_C 24
#define wxSTC_FS_KEYWORD2_C 25
#define wxSTC_FS_NUMBER_C 26
#define wxSTC_FS_STRING_C 27
#define wxSTC_FS_PREPROCESSOR_C 28
#define wxSTC_FS_OPERATOR_C 29
#define wxSTC_FS_IDENTIFIER_C 30
#define wxSTC_FS_STRINGEOL_C 31
/// Lexical states for SCLEX_CSOUND
#define wxSTC_CSOUND_DEFAULT 0
#define wxSTC_CSOUND_COMMENT 1
#define wxSTC_CSOUND_NUMBER 2
#define wxSTC_CSOUND_OPERATOR 3
#define wxSTC_CSOUND_INSTR 4
#define wxSTC_CSOUND_IDENTIFIER 5
#define wxSTC_CSOUND_OPCODE 6
#define wxSTC_CSOUND_HEADERSTMT 7
#define wxSTC_CSOUND_USERKEYWORD 8
#define wxSTC_CSOUND_COMMENTBLOCK 9
#define wxSTC_CSOUND_PARAM 10
#define wxSTC_CSOUND_ARATE_VAR 11
#define wxSTC_CSOUND_KRATE_VAR 12
#define wxSTC_CSOUND_IRATE_VAR 13
#define wxSTC_CSOUND_GLOBAL_VAR 14
#define wxSTC_CSOUND_STRINGEOL 15
/// Lexical states for SCLEX_INNOSETUP
#define wxSTC_INNO_DEFAULT 0
#define wxSTC_INNO_COMMENT 1
#define wxSTC_INNO_KEYWORD 2
#define wxSTC_INNO_PARAMETER 3
#define wxSTC_INNO_SECTION 4
#define wxSTC_INNO_PREPROC 5
#define wxSTC_INNO_INLINE_EXPANSION 6
#define wxSTC_INNO_COMMENT_PASCAL 7
#define wxSTC_INNO_KEYWORD_PASCAL 8
#define wxSTC_INNO_KEYWORD_USER 9
#define wxSTC_INNO_STRING_DOUBLE 10
#define wxSTC_INNO_STRING_SINGLE 11
#define wxSTC_INNO_IDENTIFIER 12
/// Lexical states for SCLEX_OPAL
#define wxSTC_OPAL_SPACE 0
#define wxSTC_OPAL_COMMENT_BLOCK 1
#define wxSTC_OPAL_COMMENT_LINE 2
#define wxSTC_OPAL_INTEGER 3
#define wxSTC_OPAL_KEYWORD 4
#define wxSTC_OPAL_SORT 5
#define wxSTC_OPAL_STRING 6
#define wxSTC_OPAL_PAR 7
#define wxSTC_OPAL_BOOL_CONST 8
#define wxSTC_OPAL_DEFAULT 32
/// Lexical states for SCLEX_SPICE
#define wxSTC_SPICE_DEFAULT 0
#define wxSTC_SPICE_IDENTIFIER 1
#define wxSTC_SPICE_KEYWORD 2
#define wxSTC_SPICE_KEYWORD2 3
#define wxSTC_SPICE_KEYWORD3 4
#define wxSTC_SPICE_NUMBER 5
#define wxSTC_SPICE_DELIMITER 6
#define wxSTC_SPICE_VALUE 7
#define wxSTC_SPICE_COMMENTLINE 8
/// Lexical states for SCLEX_CMAKE
#define wxSTC_CMAKE_DEFAULT 0
#define wxSTC_CMAKE_COMMENT 1
#define wxSTC_CMAKE_STRINGDQ 2
#define wxSTC_CMAKE_STRINGLQ 3
#define wxSTC_CMAKE_STRINGRQ 4
#define wxSTC_CMAKE_COMMANDS 5
#define wxSTC_CMAKE_PARAMETERS 6
#define wxSTC_CMAKE_VARIABLE 7
#define wxSTC_CMAKE_USERDEFINED 8
#define wxSTC_CMAKE_WHILEDEF 9
#define wxSTC_CMAKE_FOREACHDEF 10
#define wxSTC_CMAKE_IFDEFINEDEF 11
#define wxSTC_CMAKE_MACRODEF 12
#define wxSTC_CMAKE_STRINGVAR 13
#define wxSTC_CMAKE_NUMBER 14
/// Lexical states for SCLEX_GAP
#define wxSTC_GAP_DEFAULT 0
#define wxSTC_GAP_IDENTIFIER 1
#define wxSTC_GAP_KEYWORD 2
#define wxSTC_GAP_KEYWORD2 3
#define wxSTC_GAP_KEYWORD3 4
#define wxSTC_GAP_KEYWORD4 5
#define wxSTC_GAP_STRING 6
#define wxSTC_GAP_CHAR 7
#define wxSTC_GAP_OPERATOR 8
#define wxSTC_GAP_COMMENT 9
#define wxSTC_GAP_NUMBER 10
#define wxSTC_GAP_STRINGEOL 11
/// Lexical state for SCLEX_PLM
#define wxSTC_PLM_DEFAULT 0
#define wxSTC_PLM_COMMENT 1
#define wxSTC_PLM_STRING 2
#define wxSTC_PLM_NUMBER 3
#define wxSTC_PLM_IDENTIFIER 4
#define wxSTC_PLM_OPERATOR 5
#define wxSTC_PLM_CONTROL 6
#define wxSTC_PLM_KEYWORD 7
/// Lexical state for SCLEX_PROGRESS
#define wxSTC_ABL_DEFAULT 0
#define wxSTC_ABL_NUMBER 1
#define wxSTC_ABL_WORD 2
#define wxSTC_ABL_STRING 3
#define wxSTC_ABL_CHARACTER 4
#define wxSTC_ABL_PREPROCESSOR 5
#define wxSTC_ABL_OPERATOR 6
#define wxSTC_ABL_IDENTIFIER 7
#define wxSTC_ABL_BLOCK 8
#define wxSTC_ABL_END 9
#define wxSTC_ABL_COMMENT 10
#define wxSTC_ABL_TASKMARKER 11
#define wxSTC_ABL_LINECOMMENT 12
/// Lexical states for SCLEX_ABAQUS
#define wxSTC_ABAQUS_DEFAULT 0
#define wxSTC_ABAQUS_COMMENT 1
#define wxSTC_ABAQUS_COMMENTBLOCK 2
#define wxSTC_ABAQUS_NUMBER 3
#define wxSTC_ABAQUS_STRING 4
#define wxSTC_ABAQUS_OPERATOR 5
#define wxSTC_ABAQUS_WORD 6
#define wxSTC_ABAQUS_PROCESSOR 7
#define wxSTC_ABAQUS_COMMAND 8
#define wxSTC_ABAQUS_SLASHCOMMAND 9
#define wxSTC_ABAQUS_STARCOMMAND 10
#define wxSTC_ABAQUS_ARGUMENT 11
#define wxSTC_ABAQUS_FUNCTION 12
/// Lexical states for SCLEX_ASYMPTOTE
#define wxSTC_ASY_DEFAULT 0
#define wxSTC_ASY_COMMENT 1
#define wxSTC_ASY_COMMENTLINE 2
#define wxSTC_ASY_NUMBER 3
#define wxSTC_ASY_WORD 4
#define wxSTC_ASY_STRING 5
#define wxSTC_ASY_CHARACTER 6
#define wxSTC_ASY_OPERATOR 7
#define wxSTC_ASY_IDENTIFIER 8
#define wxSTC_ASY_STRINGEOL 9
#define wxSTC_ASY_COMMENTLINEDOC 10
#define wxSTC_ASY_WORD2 11
/// Lexical states for SCLEX_R
#define wxSTC_R_DEFAULT 0
#define wxSTC_R_COMMENT 1
#define wxSTC_R_KWORD 2
#define wxSTC_R_BASEKWORD 3
#define wxSTC_R_OTHERKWORD 4
#define wxSTC_R_NUMBER 5
#define wxSTC_R_STRING 6
#define wxSTC_R_STRING2 7
#define wxSTC_R_OPERATOR 8
#define wxSTC_R_IDENTIFIER 9
#define wxSTC_R_INFIX 10
#define wxSTC_R_INFIXEOL 11
/// Lexical state for SCLEX_MAGIK
#define wxSTC_MAGIK_DEFAULT 0
#define wxSTC_MAGIK_COMMENT 1
#define wxSTC_MAGIK_HYPER_COMMENT 16
#define wxSTC_MAGIK_STRING 2
#define wxSTC_MAGIK_CHARACTER 3
#define wxSTC_MAGIK_NUMBER 4
#define wxSTC_MAGIK_IDENTIFIER 5
#define wxSTC_MAGIK_OPERATOR 6
#define wxSTC_MAGIK_FLOW 7
#define wxSTC_MAGIK_CONTAINER 8
#define wxSTC_MAGIK_BRACKET_BLOCK 9
#define wxSTC_MAGIK_BRACE_BLOCK 10
#define wxSTC_MAGIK_SQBRACKET_BLOCK 11
#define wxSTC_MAGIK_UNKNOWN_KEYWORD 12
#define wxSTC_MAGIK_KEYWORD 13
#define wxSTC_MAGIK_PRAGMA 14
#define wxSTC_MAGIK_SYMBOL 15
/// Lexical state for SCLEX_POWERSHELL
#define wxSTC_POWERSHELL_DEFAULT 0
#define wxSTC_POWERSHELL_COMMENT 1
#define wxSTC_POWERSHELL_STRING 2
#define wxSTC_POWERSHELL_CHARACTER 3
#define wxSTC_POWERSHELL_NUMBER 4
#define wxSTC_POWERSHELL_VARIABLE 5
#define wxSTC_POWERSHELL_OPERATOR 6
#define wxSTC_POWERSHELL_IDENTIFIER 7
#define wxSTC_POWERSHELL_KEYWORD 8
#define wxSTC_POWERSHELL_CMDLET 9
#define wxSTC_POWERSHELL_ALIAS 10
#define wxSTC_POWERSHELL_FUNCTION 11
#define wxSTC_POWERSHELL_USER1 12
#define wxSTC_POWERSHELL_COMMENTSTREAM 13
#define wxSTC_POWERSHELL_HERE_STRING 14
#define wxSTC_POWERSHELL_HERE_CHARACTER 15
#define wxSTC_POWERSHELL_COMMENTDOCKEYWORD 16
/// Lexical state for SCLEX_MYSQL
#define wxSTC_MYSQL_DEFAULT 0
#define wxSTC_MYSQL_COMMENT 1
#define wxSTC_MYSQL_COMMENTLINE 2
#define wxSTC_MYSQL_VARIABLE 3
#define wxSTC_MYSQL_SYSTEMVARIABLE 4
#define wxSTC_MYSQL_KNOWNSYSTEMVARIABLE 5
#define wxSTC_MYSQL_NUMBER 6
#define wxSTC_MYSQL_MAJORKEYWORD 7
#define wxSTC_MYSQL_KEYWORD 8
#define wxSTC_MYSQL_DATABASEOBJECT 9
#define wxSTC_MYSQL_PROCEDUREKEYWORD 10
#define wxSTC_MYSQL_STRING 11
#define wxSTC_MYSQL_SQSTRING 12
#define wxSTC_MYSQL_DQSTRING 13
#define wxSTC_MYSQL_OPERATOR 14
#define wxSTC_MYSQL_FUNCTION 15
#define wxSTC_MYSQL_IDENTIFIER 16
#define wxSTC_MYSQL_QUOTEDIDENTIFIER 17
#define wxSTC_MYSQL_USER1 18
#define wxSTC_MYSQL_USER2 19
#define wxSTC_MYSQL_USER3 20
#define wxSTC_MYSQL_HIDDENCOMMAND 21
#define wxSTC_MYSQL_PLACEHOLDER 22
/// Lexical state for SCLEX_PO
#define wxSTC_PO_DEFAULT 0
#define wxSTC_PO_COMMENT 1
#define wxSTC_PO_MSGID 2
#define wxSTC_PO_MSGID_TEXT 3
#define wxSTC_PO_MSGSTR 4
#define wxSTC_PO_MSGSTR_TEXT 5
#define wxSTC_PO_MSGCTXT 6
#define wxSTC_PO_MSGCTXT_TEXT 7
#define wxSTC_PO_FUZZY 8
#define wxSTC_PO_PROGRAMMER_COMMENT 9
#define wxSTC_PO_REFERENCE 10
#define wxSTC_PO_FLAGS 11
#define wxSTC_PO_MSGID_TEXT_EOL 12
#define wxSTC_PO_MSGSTR_TEXT_EOL 13
#define wxSTC_PO_MSGCTXT_TEXT_EOL 14
#define wxSTC_PO_ERROR 15
/// Lexical states for SCLEX_PASCAL
#define wxSTC_PAS_DEFAULT 0
#define wxSTC_PAS_IDENTIFIER 1
#define wxSTC_PAS_COMMENT 2
#define wxSTC_PAS_COMMENT2 3
#define wxSTC_PAS_COMMENTLINE 4
#define wxSTC_PAS_PREPROCESSOR 5
#define wxSTC_PAS_PREPROCESSOR2 6
#define wxSTC_PAS_NUMBER 7
#define wxSTC_PAS_HEXNUMBER 8
#define wxSTC_PAS_WORD 9
#define wxSTC_PAS_STRING 10
#define wxSTC_PAS_STRINGEOL 11
#define wxSTC_PAS_CHARACTER 12
#define wxSTC_PAS_OPERATOR 13
#define wxSTC_PAS_ASM 14
/// Lexical state for SCLEX_SORCUS
#define wxSTC_SORCUS_DEFAULT 0
#define wxSTC_SORCUS_COMMAND 1
#define wxSTC_SORCUS_PARAMETER 2
#define wxSTC_SORCUS_COMMENTLINE 3
#define wxSTC_SORCUS_STRING 4
#define wxSTC_SORCUS_STRINGEOL 5
#define wxSTC_SORCUS_IDENTIFIER 6
#define wxSTC_SORCUS_OPERATOR 7
#define wxSTC_SORCUS_NUMBER 8
#define wxSTC_SORCUS_CONSTANT 9
/// Lexical state for SCLEX_POWERPRO
#define wxSTC_POWERPRO_DEFAULT 0
#define wxSTC_POWERPRO_COMMENTBLOCK 1
#define wxSTC_POWERPRO_COMMENTLINE 2
#define wxSTC_POWERPRO_NUMBER 3
#define wxSTC_POWERPRO_WORD 4
#define wxSTC_POWERPRO_WORD2 5
#define wxSTC_POWERPRO_WORD3 6
#define wxSTC_POWERPRO_WORD4 7
#define wxSTC_POWERPRO_DOUBLEQUOTEDSTRING 8
#define wxSTC_POWERPRO_SINGLEQUOTEDSTRING 9
#define wxSTC_POWERPRO_LINECONTINUE 10
#define wxSTC_POWERPRO_OPERATOR 11
#define wxSTC_POWERPRO_IDENTIFIER 12
#define wxSTC_POWERPRO_STRINGEOL 13
#define wxSTC_POWERPRO_VERBATIM 14
#define wxSTC_POWERPRO_ALTQUOTE 15
#define wxSTC_POWERPRO_FUNCTION 16
/// Lexical states for SCLEX_SML
#define wxSTC_SML_DEFAULT 0
#define wxSTC_SML_IDENTIFIER 1
#define wxSTC_SML_TAGNAME 2
#define wxSTC_SML_KEYWORD 3
#define wxSTC_SML_KEYWORD2 4
#define wxSTC_SML_KEYWORD3 5
#define wxSTC_SML_LINENUM 6
#define wxSTC_SML_OPERATOR 7
#define wxSTC_SML_NUMBER 8
#define wxSTC_SML_CHAR 9
#define wxSTC_SML_STRING 11
#define wxSTC_SML_COMMENT 12
#define wxSTC_SML_COMMENT1 13
#define wxSTC_SML_COMMENT2 14
#define wxSTC_SML_COMMENT3 15
/// Lexical state for SCLEX_MARKDOWN
#define wxSTC_MARKDOWN_DEFAULT 0
#define wxSTC_MARKDOWN_LINE_BEGIN 1
#define wxSTC_MARKDOWN_STRONG1 2
#define wxSTC_MARKDOWN_STRONG2 3
#define wxSTC_MARKDOWN_EM1 4
#define wxSTC_MARKDOWN_EM2 5
#define wxSTC_MARKDOWN_HEADER1 6
#define wxSTC_MARKDOWN_HEADER2 7
#define wxSTC_MARKDOWN_HEADER3 8
#define wxSTC_MARKDOWN_HEADER4 9
#define wxSTC_MARKDOWN_HEADER5 10
#define wxSTC_MARKDOWN_HEADER6 11
#define wxSTC_MARKDOWN_PRECHAR 12
#define wxSTC_MARKDOWN_ULIST_ITEM 13
#define wxSTC_MARKDOWN_OLIST_ITEM 14
#define wxSTC_MARKDOWN_BLOCKQUOTE 15
#define wxSTC_MARKDOWN_STRIKEOUT 16
#define wxSTC_MARKDOWN_HRULE 17
#define wxSTC_MARKDOWN_LINK 18
#define wxSTC_MARKDOWN_CODE 19
#define wxSTC_MARKDOWN_CODE2 20
#define wxSTC_MARKDOWN_CODEBK 21
/// Lexical state for SCLEX_TXT2TAGS
#define wxSTC_TXT2TAGS_DEFAULT 0
#define wxSTC_TXT2TAGS_LINE_BEGIN 1
#define wxSTC_TXT2TAGS_STRONG1 2
#define wxSTC_TXT2TAGS_STRONG2 3
#define wxSTC_TXT2TAGS_EM1 4
#define wxSTC_TXT2TAGS_EM2 5
#define wxSTC_TXT2TAGS_HEADER1 6
#define wxSTC_TXT2TAGS_HEADER2 7
#define wxSTC_TXT2TAGS_HEADER3 8
#define wxSTC_TXT2TAGS_HEADER4 9
#define wxSTC_TXT2TAGS_HEADER5 10
#define wxSTC_TXT2TAGS_HEADER6 11
#define wxSTC_TXT2TAGS_PRECHAR 12
#define wxSTC_TXT2TAGS_ULIST_ITEM 13
#define wxSTC_TXT2TAGS_OLIST_ITEM 14
#define wxSTC_TXT2TAGS_BLOCKQUOTE 15
#define wxSTC_TXT2TAGS_STRIKEOUT 16
#define wxSTC_TXT2TAGS_HRULE 17
#define wxSTC_TXT2TAGS_LINK 18
#define wxSTC_TXT2TAGS_CODE 19
#define wxSTC_TXT2TAGS_CODE2 20
#define wxSTC_TXT2TAGS_CODEBK 21
#define wxSTC_TXT2TAGS_COMMENT 22
#define wxSTC_TXT2TAGS_OPTION 23
#define wxSTC_TXT2TAGS_PREPROC 24
#define wxSTC_TXT2TAGS_POSTPROC 25
/// Lexical states for SCLEX_A68K
#define wxSTC_A68K_DEFAULT 0
#define wxSTC_A68K_COMMENT 1
#define wxSTC_A68K_NUMBER_DEC 2
#define wxSTC_A68K_NUMBER_BIN 3
#define wxSTC_A68K_NUMBER_HEX 4
#define wxSTC_A68K_STRING1 5
#define wxSTC_A68K_OPERATOR 6
#define wxSTC_A68K_CPUINSTRUCTION 7
#define wxSTC_A68K_EXTINSTRUCTION 8
#define wxSTC_A68K_REGISTER 9
#define wxSTC_A68K_DIRECTIVE 10
#define wxSTC_A68K_MACRO_ARG 11
#define wxSTC_A68K_LABEL 12
#define wxSTC_A68K_STRING2 13
#define wxSTC_A68K_IDENTIFIER 14
#define wxSTC_A68K_MACRO_DECLARATION 15
#define wxSTC_A68K_COMMENT_WORD 16
#define wxSTC_A68K_COMMENT_SPECIAL 17
#define wxSTC_A68K_COMMENT_DOXYGEN 18
/// Lexical states for SCLEX_MODULA
#define wxSTC_MODULA_DEFAULT 0
#define wxSTC_MODULA_COMMENT 1
#define wxSTC_MODULA_DOXYCOMM 2
#define wxSTC_MODULA_DOXYKEY 3
#define wxSTC_MODULA_KEYWORD 4
#define wxSTC_MODULA_RESERVED 5
#define wxSTC_MODULA_NUMBER 6
#define wxSTC_MODULA_BASENUM 7
#define wxSTC_MODULA_FLOAT 8
#define wxSTC_MODULA_STRING 9
#define wxSTC_MODULA_STRSPEC 10
#define wxSTC_MODULA_CHAR 11
#define wxSTC_MODULA_CHARSPEC 12
#define wxSTC_MODULA_PROC 13
#define wxSTC_MODULA_PRAGMA 14
#define wxSTC_MODULA_PRGKEY 15
#define wxSTC_MODULA_OPERATOR 16
#define wxSTC_MODULA_BADSTR 17
/// Lexical states for SCLEX_COFFEESCRIPT
#define wxSTC_COFFEESCRIPT_DEFAULT 0
#define wxSTC_COFFEESCRIPT_COMMENT 1
#define wxSTC_COFFEESCRIPT_COMMENTLINE 2
#define wxSTC_COFFEESCRIPT_COMMENTDOC 3
#define wxSTC_COFFEESCRIPT_NUMBER 4
#define wxSTC_COFFEESCRIPT_WORD 5
#define wxSTC_COFFEESCRIPT_STRING 6
#define wxSTC_COFFEESCRIPT_CHARACTER 7
#define wxSTC_COFFEESCRIPT_UUID 8
#define wxSTC_COFFEESCRIPT_PREPROCESSOR 9
#define wxSTC_COFFEESCRIPT_OPERATOR 10
#define wxSTC_COFFEESCRIPT_IDENTIFIER 11
#define wxSTC_COFFEESCRIPT_STRINGEOL 12
#define wxSTC_COFFEESCRIPT_VERBATIM 13
#define wxSTC_COFFEESCRIPT_REGEX 14
#define wxSTC_COFFEESCRIPT_COMMENTLINEDOC 15
#define wxSTC_COFFEESCRIPT_WORD2 16
#define wxSTC_COFFEESCRIPT_COMMENTDOCKEYWORD 17
#define wxSTC_COFFEESCRIPT_COMMENTDOCKEYWORDERROR 18
#define wxSTC_COFFEESCRIPT_GLOBALCLASS 19
#define wxSTC_COFFEESCRIPT_STRINGRAW 20
#define wxSTC_COFFEESCRIPT_TRIPLEVERBATIM 21
#define wxSTC_COFFEESCRIPT_COMMENTBLOCK 22
#define wxSTC_COFFEESCRIPT_VERBOSE_REGEX 23
#define wxSTC_COFFEESCRIPT_VERBOSE_REGEX_COMMENT 24
#define wxSTC_COFFEESCRIPT_INSTANCEPROPERTY 25
/// Lexical states for SCLEX_AVS
#define wxSTC_AVS_DEFAULT 0
#define wxSTC_AVS_COMMENTBLOCK 1
#define wxSTC_AVS_COMMENTBLOCKN 2
#define wxSTC_AVS_COMMENTLINE 3
#define wxSTC_AVS_NUMBER 4
#define wxSTC_AVS_OPERATOR 5
#define wxSTC_AVS_IDENTIFIER 6
#define wxSTC_AVS_STRING 7
#define wxSTC_AVS_TRIPLESTRING 8
#define wxSTC_AVS_KEYWORD 9
#define wxSTC_AVS_FILTER 10
#define wxSTC_AVS_PLUGIN 11
#define wxSTC_AVS_FUNCTION 12
#define wxSTC_AVS_CLIPPROP 13
#define wxSTC_AVS_USERDFN 14
/// Lexical states for SCLEX_ECL
#define wxSTC_ECL_DEFAULT 0
#define wxSTC_ECL_COMMENT 1
#define wxSTC_ECL_COMMENTLINE 2
#define wxSTC_ECL_NUMBER 3
#define wxSTC_ECL_STRING 4
#define wxSTC_ECL_WORD0 5
#define wxSTC_ECL_OPERATOR 6
#define wxSTC_ECL_CHARACTER 7
#define wxSTC_ECL_UUID 8
#define wxSTC_ECL_PREPROCESSOR 9
#define wxSTC_ECL_UNKNOWN 10
#define wxSTC_ECL_IDENTIFIER 11
#define wxSTC_ECL_STRINGEOL 12
#define wxSTC_ECL_VERBATIM 13
#define wxSTC_ECL_REGEX 14
#define wxSTC_ECL_COMMENTLINEDOC 15
#define wxSTC_ECL_WORD1 16
#define wxSTC_ECL_COMMENTDOCKEYWORD 17
#define wxSTC_ECL_COMMENTDOCKEYWORDERROR 18
#define wxSTC_ECL_WORD2 19
#define wxSTC_ECL_WORD3 20
#define wxSTC_ECL_WORD4 21
#define wxSTC_ECL_WORD5 22
#define wxSTC_ECL_COMMENTDOC 23
#define wxSTC_ECL_ADDED 24
#define wxSTC_ECL_DELETED 25
#define wxSTC_ECL_CHANGED 26
#define wxSTC_ECL_MOVED 27
/// Lexical states for SCLEX_OSCRIPT
#define wxSTC_OSCRIPT_DEFAULT 0
#define wxSTC_OSCRIPT_LINE_COMMENT 1
#define wxSTC_OSCRIPT_BLOCK_COMMENT 2
#define wxSTC_OSCRIPT_DOC_COMMENT 3
#define wxSTC_OSCRIPT_PREPROCESSOR 4
#define wxSTC_OSCRIPT_NUMBER 5
#define wxSTC_OSCRIPT_SINGLEQUOTE_STRING 6
#define wxSTC_OSCRIPT_DOUBLEQUOTE_STRING 7
#define wxSTC_OSCRIPT_CONSTANT 8
#define wxSTC_OSCRIPT_IDENTIFIER 9
#define wxSTC_OSCRIPT_GLOBAL 10
#define wxSTC_OSCRIPT_KEYWORD 11
#define wxSTC_OSCRIPT_OPERATOR 12
#define wxSTC_OSCRIPT_LABEL 13
#define wxSTC_OSCRIPT_TYPE 14
#define wxSTC_OSCRIPT_FUNCTION 15
#define wxSTC_OSCRIPT_OBJECT 16
#define wxSTC_OSCRIPT_PROPERTY 17
#define wxSTC_OSCRIPT_METHOD 18
/// Lexical states for SCLEX_VISUALPROLOG
#define wxSTC_VISUALPROLOG_DEFAULT 0
#define wxSTC_VISUALPROLOG_KEY_MAJOR 1
#define wxSTC_VISUALPROLOG_KEY_MINOR 2
#define wxSTC_VISUALPROLOG_KEY_DIRECTIVE 3
#define wxSTC_VISUALPROLOG_COMMENT_BLOCK 4
#define wxSTC_VISUALPROLOG_COMMENT_LINE 5
#define wxSTC_VISUALPROLOG_COMMENT_KEY 6
#define wxSTC_VISUALPROLOG_COMMENT_KEY_ERROR 7
#define wxSTC_VISUALPROLOG_IDENTIFIER 8
#define wxSTC_VISUALPROLOG_VARIABLE 9
#define wxSTC_VISUALPROLOG_ANONYMOUS 10
#define wxSTC_VISUALPROLOG_NUMBER 11
#define wxSTC_VISUALPROLOG_OPERATOR 12
#define wxSTC_VISUALPROLOG_CHARACTER 13
#define wxSTC_VISUALPROLOG_CHARACTER_TOO_MANY 14
#define wxSTC_VISUALPROLOG_CHARACTER_ESCAPE_ERROR 15
#define wxSTC_VISUALPROLOG_STRING 16
#define wxSTC_VISUALPROLOG_STRING_ESCAPE 17
#define wxSTC_VISUALPROLOG_STRING_ESCAPE_ERROR 18
#define wxSTC_VISUALPROLOG_STRING_EOL_OPEN 19
#define wxSTC_VISUALPROLOG_STRING_VERBATIM 20
#define wxSTC_VISUALPROLOG_STRING_VERBATIM_SPECIAL 21
#define wxSTC_VISUALPROLOG_STRING_VERBATIM_EOL 22
/// Lexical states for SCLEX_STTXT
#define wxSTC_STTXT_DEFAULT 0
#define wxSTC_STTXT_COMMENT 1
#define wxSTC_STTXT_COMMENTLINE 2
#define wxSTC_STTXT_KEYWORD 3
#define wxSTC_STTXT_TYPE 4
#define wxSTC_STTXT_FUNCTION 5
#define wxSTC_STTXT_FB 6
#define wxSTC_STTXT_NUMBER 7
#define wxSTC_STTXT_HEXNUMBER 8
#define wxSTC_STTXT_PRAGMA 9
#define wxSTC_STTXT_OPERATOR 10
#define wxSTC_STTXT_CHARACTER 11
#define wxSTC_STTXT_STRING1 12
#define wxSTC_STTXT_STRING2 13
#define wxSTC_STTXT_STRINGEOL 14
#define wxSTC_STTXT_IDENTIFIER 15
#define wxSTC_STTXT_DATETIME 16
#define wxSTC_STTXT_VARS 17
#define wxSTC_STTXT_PRAGMAS 18
/// Lexical states for SCLEX_KVIRC
#define wxSTC_KVIRC_DEFAULT 0
#define wxSTC_KVIRC_COMMENT 1
#define wxSTC_KVIRC_COMMENTBLOCK 2
#define wxSTC_KVIRC_STRING 3
#define wxSTC_KVIRC_WORD 4
#define wxSTC_KVIRC_KEYWORD 5
#define wxSTC_KVIRC_FUNCTION_KEYWORD 6
#define wxSTC_KVIRC_FUNCTION 7
#define wxSTC_KVIRC_VARIABLE 8
#define wxSTC_KVIRC_NUMBER 9
#define wxSTC_KVIRC_OPERATOR 10
#define wxSTC_KVIRC_STRING_FUNCTION 11
#define wxSTC_KVIRC_STRING_VARIABLE 12
/// Lexical states for SCLEX_RUST
#define wxSTC_RUST_DEFAULT 0
#define wxSTC_RUST_COMMENTBLOCK 1
#define wxSTC_RUST_COMMENTLINE 2
#define wxSTC_RUST_COMMENTBLOCKDOC 3
#define wxSTC_RUST_COMMENTLINEDOC 4
#define wxSTC_RUST_NUMBER 5
#define wxSTC_RUST_WORD 6
#define wxSTC_RUST_WORD2 7
#define wxSTC_RUST_WORD3 8
#define wxSTC_RUST_WORD4 9
#define wxSTC_RUST_WORD5 10
#define wxSTC_RUST_WORD6 11
#define wxSTC_RUST_WORD7 12
#define wxSTC_RUST_STRING 13
#define wxSTC_RUST_STRINGR 14
#define wxSTC_RUST_CHARACTER 15
#define wxSTC_RUST_OPERATOR 16
#define wxSTC_RUST_IDENTIFIER 17
#define wxSTC_RUST_LIFETIME 18
#define wxSTC_RUST_MACRO 19
#define wxSTC_RUST_LEXERROR 20
#define wxSTC_RUST_BYTESTRING 21
#define wxSTC_RUST_BYTESTRINGR 22
#define wxSTC_RUST_BYTECHARACTER 23
/// Lexical states for SCLEX_DMAP
#define wxSTC_DMAP_DEFAULT 0
#define wxSTC_DMAP_COMMENT 1
#define wxSTC_DMAP_NUMBER 2
#define wxSTC_DMAP_STRING1 3
#define wxSTC_DMAP_STRING2 4
#define wxSTC_DMAP_STRINGEOL 5
#define wxSTC_DMAP_OPERATOR 6
#define wxSTC_DMAP_IDENTIFIER 7
#define wxSTC_DMAP_WORD 8
#define wxSTC_DMAP_WORD2 9
#define wxSTC_DMAP_WORD3 10
/// Lexical states for SCLEX_DMIS
#define wxSTC_DMIS_DEFAULT 0
#define wxSTC_DMIS_COMMENT 1
#define wxSTC_DMIS_STRING 2
#define wxSTC_DMIS_NUMBER 3
#define wxSTC_DMIS_KEYWORD 4
#define wxSTC_DMIS_MAJORWORD 5
#define wxSTC_DMIS_MINORWORD 6
#define wxSTC_DMIS_UNSUPPORTED_MAJOR 7
#define wxSTC_DMIS_UNSUPPORTED_MINOR 8
#define wxSTC_DMIS_LABEL 9
/// Lexical states for SCLEX_REGISTRY
#define wxSTC_REG_DEFAULT 0
#define wxSTC_REG_COMMENT 1
#define wxSTC_REG_VALUENAME 2
#define wxSTC_REG_STRING 3
#define wxSTC_REG_HEXDIGIT 4
#define wxSTC_REG_VALUETYPE 5
#define wxSTC_REG_ADDEDKEY 6
#define wxSTC_REG_DELETEDKEY 7
#define wxSTC_REG_ESCAPED 8
#define wxSTC_REG_KEYPATH_GUID 9
#define wxSTC_REG_STRING_GUID 10
#define wxSTC_REG_PARAMETER 11
#define wxSTC_REG_OPERATOR 12
/// Lexical state for SCLEX_BIBTEX
#define wxSTC_BIBTEX_DEFAULT 0
#define wxSTC_BIBTEX_ENTRY 1
#define wxSTC_BIBTEX_UNKNOWN_ENTRY 2
#define wxSTC_BIBTEX_KEY 3
#define wxSTC_BIBTEX_PARAMETER 4
#define wxSTC_BIBTEX_VALUE 5
#define wxSTC_BIBTEX_COMMENT 6
/// Lexical state for SCLEX_SREC
#define wxSTC_HEX_DEFAULT 0
#define wxSTC_HEX_RECSTART 1
#define wxSTC_HEX_RECTYPE 2
#define wxSTC_HEX_RECTYPE_UNKNOWN 3
#define wxSTC_HEX_BYTECOUNT 4
#define wxSTC_HEX_BYTECOUNT_WRONG 5
#define wxSTC_HEX_NOADDRESS 6
#define wxSTC_HEX_DATAADDRESS 7
#define wxSTC_HEX_RECCOUNT 8
#define wxSTC_HEX_STARTADDRESS 9
#define wxSTC_HEX_ADDRESSFIELD_UNKNOWN 10
#define wxSTC_HEX_EXTENDEDADDRESS 11
#define wxSTC_HEX_DATA_ODD 12
#define wxSTC_HEX_DATA_EVEN 13
#define wxSTC_HEX_DATA_UNKNOWN 14
#define wxSTC_HEX_DATA_EMPTY 15
#define wxSTC_HEX_CHECKSUM 16
#define wxSTC_HEX_CHECKSUM_WRONG 17
#define wxSTC_HEX_GARBAGE 18
/// Lexical state for SCLEX_IHEX (shared with Srec)
/// Lexical state for SCLEX_TEHEX (shared with Srec)
/// Lexical states for SCLEX_JSON
#define wxSTC_JSON_DEFAULT 0
#define wxSTC_JSON_NUMBER 1
#define wxSTC_JSON_STRING 2
#define wxSTC_JSON_STRINGEOL 3
#define wxSTC_JSON_PROPERTYNAME 4
#define wxSTC_JSON_ESCAPESEQUENCE 5
#define wxSTC_JSON_LINECOMMENT 6
#define wxSTC_JSON_BLOCKCOMMENT 7
#define wxSTC_JSON_OPERATOR 8
#define wxSTC_JSON_URI 9
#define wxSTC_JSON_COMPACTIRI 10
#define wxSTC_JSON_KEYWORD 11
#define wxSTC_JSON_LDKEYWORD 12
#define wxSTC_JSON_ERROR 13
#define wxSTC_EDI_DEFAULT 0
#define wxSTC_EDI_SEGMENTSTART 1
#define wxSTC_EDI_SEGMENTEND 2
#define wxSTC_EDI_SEP_ELEMENT 3
#define wxSTC_EDI_SEP_COMPOSITE 4
#define wxSTC_EDI_SEP_RELEASE 5
#define wxSTC_EDI_UNA 6
#define wxSTC_EDI_UNH 7
#define wxSTC_EDI_BADSEGMENT 8
//}}}
//----------------------------------------------------------------------
#if defined(__clang__) || wxCHECK_GCC_VERSION(4, 5)
#define wxSTC_STRINGIFY(X) #X
#define wxSTC_DEPRECATED_MACRO_VALUE(value,msg) \
_Pragma(wxSTC_STRINGIFY(GCC warning msg)) value
#else
#define wxSTC_DEPRECATED_MACRO_VALUE(value,msg) value
#endif
#if WXWIN_COMPATIBILITY_3_0
// The wxSTC_INDIC{0,1,2,S}_MASK values are no longer used in Scintilla
#if wxCHECK_VISUALC_VERSION(10)
#pragma deprecated(wxSTC_INDIC0_MASK, wxSTC_INDIC1_MASK, \
wxSTC_INDIC2_MASK, wxSTC_INDICS_MASK)
#endif
#define wxSTC_INDIC0_MASK wxSTC_DEPRECATED_MACRO_VALUE(0x20,\
"wxSTC_INDIC0_MASK is deprecated. Style byte indicators are no longer used.")
#define wxSTC_INDIC1_MASK wxSTC_DEPRECATED_MACRO_VALUE(0x40,\
"wxSTC_INDIC1_MASK is deprecated. Style byte indicators are no longer used.")
#define wxSTC_INDIC2_MASK wxSTC_DEPRECATED_MACRO_VALUE(0x80,\
"wxSTC_INDIC2_MASK is deprecated. Style byte indicators are no longer used.")
#define wxSTC_INDICS_MASK wxSTC_DEPRECATED_MACRO_VALUE(0xE0,\
"wxSTC_INDICS_MASK is deprecated. Style byte indicators are no longer used.")
// The following entries have non-conformant prefixes.
#if wxCHECK_VISUALC_VERSION(10)
#pragma deprecated(wxSTC_SCMOD_NORM, wxSTC_SCMOD_SHIFT, wxSTC_SCMOD_CTRL, \
wxSTC_SCMOD_ALT, wxSTC_SCMOD_SUPER, wxSTC_SCMOD_META, \
wxSTC_SCVS_NONE, wxSTC_SCVS_RECTANGULARSELECTION, \
wxSTC_SCVS_USERACCESSIBLE, wxSTC_SCVS_NOWRAPLINESTART)
#endif
#define wxSTC_SCMOD_NORM wxSTC_DEPRECATED_MACRO_VALUE(0,\
"wxSTC_SCMOD_NORM is deprecated. Use wxSTC_KEYMOD_NORM instead.")
#define wxSTC_SCMOD_SHIFT wxSTC_DEPRECATED_MACRO_VALUE(1,\
"wxSTC_SCMOD_SHIFT is deprecated. Use wxSTC_KEYMOD_SHIFT instead.")
#define wxSTC_SCMOD_CTRL wxSTC_DEPRECATED_MACRO_VALUE(2,\
"wxSTC_SCMOD_CTRL is deprecated. Use wxSTC_KEYMOD_CTRL instead.")
#define wxSTC_SCMOD_ALT wxSTC_DEPRECATED_MACRO_VALUE(4,\
"wxSTC_SCMOD_ALT is deprecated. Use wxSTC_KEYMOD_ALT instead.")
#define wxSTC_SCMOD_SUPER wxSTC_DEPRECATED_MACRO_VALUE(8,\
"wxSTC_SCMOD_SUPER is deprecated. Use wxSTC_KEYMOD_SUPER instead.")
#define wxSTC_SCMOD_META wxSTC_DEPRECATED_MACRO_VALUE(16,\
"wxSTC_SCMOD_META is deprecated. Use wxSTC_KEYMOD_META instead.")
#define wxSTC_SCVS_NONE wxSTC_DEPRECATED_MACRO_VALUE(0, \
"wxSTC_SCVS_NONE is deprecated. Use wxSTC_VS_NONE instead.")
#define wxSTC_SCVS_RECTANGULARSELECTION wxSTC_DEPRECATED_MACRO_VALUE(1, \
"wxSTC_SCVS_RECTANGULARSELECTION is deprecated. Use wxSTC_VS_RECTANGULARSELECTION instead.")
#define wxSTC_SCVS_USERACCESSIBLE wxSTC_DEPRECATED_MACRO_VALUE(2, \
"wxSTC_SCVS_USERACCESSIBLE is deprecated. Use wxSTC_VS_USERACCESSIBLE instead.")
#define wxSTC_SCVS_NOWRAPLINESTART wxSTC_DEPRECATED_MACRO_VALUE(4, \
"wxSTC_SCVS_NOWRAPLINESTART is deprecated. Use wxSTC_VS_NOWRAPLINESTART instead.")
#endif // WXWIN_COMPATIBILITY_3_0
//----------------------------------------------------------------------
// Commands that can be bound to keystrokes section {{{
/// Redoes the next action on the undo history.
#define wxSTC_CMD_REDO 2011
/// Select all the text in the document.
#define wxSTC_CMD_SELECTALL 2013
/// Undo one action in the undo history.
#define wxSTC_CMD_UNDO 2176
/// Cut the selection to the clipboard.
#define wxSTC_CMD_CUT 2177
/// Copy the selection to the clipboard.
#define wxSTC_CMD_COPY 2178
/// Paste the contents of the clipboard into the document replacing the selection.
#define wxSTC_CMD_PASTE 2179
/// Clear the selection.
#define wxSTC_CMD_CLEAR 2180
/// Move caret down one line.
#define wxSTC_CMD_LINEDOWN 2300
/// Move caret down one line extending selection to new caret position.
#define wxSTC_CMD_LINEDOWNEXTEND 2301
/// Move caret up one line.
#define wxSTC_CMD_LINEUP 2302
/// Move caret up one line extending selection to new caret position.
#define wxSTC_CMD_LINEUPEXTEND 2303
/// Move caret left one character.
#define wxSTC_CMD_CHARLEFT 2304
/// Move caret left one character extending selection to new caret position.
#define wxSTC_CMD_CHARLEFTEXTEND 2305
/// Move caret right one character.
#define wxSTC_CMD_CHARRIGHT 2306
/// Move caret right one character extending selection to new caret position.
#define wxSTC_CMD_CHARRIGHTEXTEND 2307
/// Move caret left one word.
#define wxSTC_CMD_WORDLEFT 2308
/// Move caret left one word extending selection to new caret position.
#define wxSTC_CMD_WORDLEFTEXTEND 2309
/// Move caret right one word.
#define wxSTC_CMD_WORDRIGHT 2310
/// Move caret right one word extending selection to new caret position.
#define wxSTC_CMD_WORDRIGHTEXTEND 2311
/// Move caret to first position on line.
#define wxSTC_CMD_HOME 2312
/// Move caret to first position on line extending selection to new caret position.
#define wxSTC_CMD_HOMEEXTEND 2313
/// Move caret to last position on line.
#define wxSTC_CMD_LINEEND 2314
/// Move caret to last position on line extending selection to new caret position.
#define wxSTC_CMD_LINEENDEXTEND 2315
/// Move caret to first position in document.
#define wxSTC_CMD_DOCUMENTSTART 2316
/// Move caret to first position in document extending selection to new caret position.
#define wxSTC_CMD_DOCUMENTSTARTEXTEND 2317
/// Move caret to last position in document.
#define wxSTC_CMD_DOCUMENTEND 2318
/// Move caret to last position in document extending selection to new caret position.
#define wxSTC_CMD_DOCUMENTENDEXTEND 2319
/// Move caret one page up.
#define wxSTC_CMD_PAGEUP 2320
/// Move caret one page up extending selection to new caret position.
#define wxSTC_CMD_PAGEUPEXTEND 2321
/// Move caret one page down.
#define wxSTC_CMD_PAGEDOWN 2322
/// Move caret one page down extending selection to new caret position.
#define wxSTC_CMD_PAGEDOWNEXTEND 2323
/// Switch from insert to overtype mode or the reverse.
#define wxSTC_CMD_EDITTOGGLEOVERTYPE 2324
/// Cancel any modes such as call tip or auto-completion list display.
#define wxSTC_CMD_CANCEL 2325
/// Delete the selection or if no selection, the character before the caret.
#define wxSTC_CMD_DELETEBACK 2326
/// If selection is empty or all on one line replace the selection with a tab character.
/// If more than one line selected, indent the lines.
#define wxSTC_CMD_TAB 2327
/// Dedent the selected lines.
#define wxSTC_CMD_BACKTAB 2328
/// Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
#define wxSTC_CMD_NEWLINE 2329
/// Insert a Form Feed character.
#define wxSTC_CMD_FORMFEED 2330
/// Move caret to before first visible character on line.
/// If already there move to first character on line.
#define wxSTC_CMD_VCHOME 2331
/// Like VCHome but extending selection to new caret position.
#define wxSTC_CMD_VCHOMEEXTEND 2332
/// Magnify the displayed text by increasing the sizes by 1 point.
#define wxSTC_CMD_ZOOMIN 2333
/// Make the displayed text smaller by decreasing the sizes by 1 point.
#define wxSTC_CMD_ZOOMOUT 2334
/// Delete the word to the left of the caret.
#define wxSTC_CMD_DELWORDLEFT 2335
/// Delete the word to the right of the caret.
#define wxSTC_CMD_DELWORDRIGHT 2336
/// Delete the word to the right of the caret, but not the trailing non-word characters.
#define wxSTC_CMD_DELWORDRIGHTEND 2518
/// Cut the line containing the caret.
#define wxSTC_CMD_LINECUT 2337
/// Delete the line containing the caret.
#define wxSTC_CMD_LINEDELETE 2338
/// Switch the current line with the previous.
#define wxSTC_CMD_LINETRANSPOSE 2339
/// Duplicate the current line.
#define wxSTC_CMD_LINEDUPLICATE 2404
/// Transform the selection to lower case.
#define wxSTC_CMD_LOWERCASE 2340
/// Transform the selection to upper case.
#define wxSTC_CMD_UPPERCASE 2341
/// Scroll the document down, keeping the caret visible.
#define wxSTC_CMD_LINESCROLLDOWN 2342
/// Scroll the document up, keeping the caret visible.
#define wxSTC_CMD_LINESCROLLUP 2343
/// Delete the selection or if no selection, the character before the caret.
/// Will not delete the character before at the start of a line.
#define wxSTC_CMD_DELETEBACKNOTLINE 2344
/// Move caret to first position on display line.
#define wxSTC_CMD_HOMEDISPLAY 2345
/// Move caret to first position on display line extending selection to
/// new caret position.
#define wxSTC_CMD_HOMEDISPLAYEXTEND 2346
/// Move caret to last position on display line.
#define wxSTC_CMD_LINEENDDISPLAY 2347
/// Move caret to last position on display line extending selection to new
/// caret position.
#define wxSTC_CMD_LINEENDDISPLAYEXTEND 2348
/// Like Home but when word-wrap is enabled goes first to start of display line
/// HomeDisplay, then to start of document line Home.
#define wxSTC_CMD_HOMEWRAP 2349
/// Like HomeExtend but when word-wrap is enabled extends first to start of display line
/// HomeDisplayExtend, then to start of document line HomeExtend.
#define wxSTC_CMD_HOMEWRAPEXTEND 2450
/// Like LineEnd but when word-wrap is enabled goes first to end of display line
/// LineEndDisplay, then to start of document line LineEnd.
#define wxSTC_CMD_LINEENDWRAP 2451
/// Like LineEndExtend but when word-wrap is enabled extends first to end of display line
/// LineEndDisplayExtend, then to start of document line LineEndExtend.
#define wxSTC_CMD_LINEENDWRAPEXTEND 2452
/// Like VCHome but when word-wrap is enabled goes first to start of display line
/// VCHomeDisplay, then behaves like VCHome.
#define wxSTC_CMD_VCHOMEWRAP 2453
/// Like VCHomeExtend but when word-wrap is enabled extends first to start of display line
/// VCHomeDisplayExtend, then behaves like VCHomeExtend.
#define wxSTC_CMD_VCHOMEWRAPEXTEND 2454
/// Copy the line containing the caret.
#define wxSTC_CMD_LINECOPY 2455
/// Move to the previous change in capitalisation.
#define wxSTC_CMD_WORDPARTLEFT 2390
/// Move to the previous change in capitalisation extending selection
/// to new caret position.
#define wxSTC_CMD_WORDPARTLEFTEXTEND 2391
/// Move to the change next in capitalisation.
#define wxSTC_CMD_WORDPARTRIGHT 2392
/// Move to the next change in capitalisation extending selection
/// to new caret position.
#define wxSTC_CMD_WORDPARTRIGHTEXTEND 2393
/// Delete back from the current position to the start of the line.
#define wxSTC_CMD_DELLINELEFT 2395
/// Delete forwards from the current position to the end of the line.
#define wxSTC_CMD_DELLINERIGHT 2396
/// Move caret down one paragraph (delimited by empty lines).
#define wxSTC_CMD_PARADOWN 2413
/// Extend selection down one paragraph (delimited by empty lines).
#define wxSTC_CMD_PARADOWNEXTEND 2414
/// Move caret up one paragraph (delimited by empty lines).
#define wxSTC_CMD_PARAUP 2415
/// Extend selection up one paragraph (delimited by empty lines).
#define wxSTC_CMD_PARAUPEXTEND 2416
/// Move caret down one line, extending rectangular selection to new caret position.
#define wxSTC_CMD_LINEDOWNRECTEXTEND 2426
/// Move caret up one line, extending rectangular selection to new caret position.
#define wxSTC_CMD_LINEUPRECTEXTEND 2427
/// Move caret left one character, extending rectangular selection to new caret position.
#define wxSTC_CMD_CHARLEFTRECTEXTEND 2428
/// Move caret right one character, extending rectangular selection to new caret position.
#define wxSTC_CMD_CHARRIGHTRECTEXTEND 2429
/// Move caret to first position on line, extending rectangular selection to new caret position.
#define wxSTC_CMD_HOMERECTEXTEND 2430
/// Move caret to before first visible character on line.
/// If already there move to first character on line.
/// In either case, extend rectangular selection to new caret position.
#define wxSTC_CMD_VCHOMERECTEXTEND 2431
/// Move caret to last position on line, extending rectangular selection to new caret position.
#define wxSTC_CMD_LINEENDRECTEXTEND 2432
/// Move caret one page up, extending rectangular selection to new caret position.
#define wxSTC_CMD_PAGEUPRECTEXTEND 2433
/// Move caret one page down, extending rectangular selection to new caret position.
#define wxSTC_CMD_PAGEDOWNRECTEXTEND 2434
/// Move caret to top of page, or one page up if already at top of page.
#define wxSTC_CMD_STUTTEREDPAGEUP 2435
/// Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
#define wxSTC_CMD_STUTTEREDPAGEUPEXTEND 2436
/// Move caret to bottom of page, or one page down if already at bottom of page.
#define wxSTC_CMD_STUTTEREDPAGEDOWN 2437
/// Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
#define wxSTC_CMD_STUTTEREDPAGEDOWNEXTEND 2438
/// Move caret left one word, position cursor at end of word.
#define wxSTC_CMD_WORDLEFTEND 2439
/// Move caret left one word, position cursor at end of word, extending selection to new caret position.
#define wxSTC_CMD_WORDLEFTENDEXTEND 2440
/// Move caret right one word, position cursor at end of word.
#define wxSTC_CMD_WORDRIGHTEND 2441
/// Move caret right one word, position cursor at end of word, extending selection to new caret position.
#define wxSTC_CMD_WORDRIGHTENDEXTEND 2442
/// Centre current line in window.
#define wxSTC_CMD_VERTICALCENTRECARET 2619
/// Move the selected lines up one line, shifting the line above after the selection
#define wxSTC_CMD_MOVESELECTEDLINESUP 2620
/// Move the selected lines down one line, shifting the line below before the selection
#define wxSTC_CMD_MOVESELECTEDLINESDOWN 2621
/// Scroll to start of document.
#define wxSTC_CMD_SCROLLTOSTART 2628
/// Scroll to end of document.
#define wxSTC_CMD_SCROLLTOEND 2629
/// Move caret to before first visible character on display line.
/// If already there move to first character on display line.
#define wxSTC_CMD_VCHOMEDISPLAY 2652
/// Like VCHomeDisplay but extending selection to new caret position.
#define wxSTC_CMD_VCHOMEDISPLAYEXTEND 2653
//}}}
//----------------------------------------------------------------------
class ScintillaWX; // forward declare
class WordList;
struct SCNotification;
#ifndef SWIG
extern WXDLLIMPEXP_DATA_STC(const char) wxSTCNameStr[];
class WXDLLIMPEXP_FWD_STC wxStyledTextCtrl;
class WXDLLIMPEXP_FWD_STC wxStyledTextEvent;
#endif
//----------------------------------------------------------------------
class WXDLLIMPEXP_STC wxStyledTextCtrl : public wxControl,
#if wxUSE_TEXTCTRL
public wxTextCtrlIface
#else // !wxUSE_TEXTCTRL
public wxTextEntryBase
#endif // wxUSE_TEXTCTRL/!wxUSE_TEXTCTRL
{
public:
#ifdef SWIG
%pythonAppend wxStyledTextCtrl "self._setOORInfo(self)"
%pythonAppend wxStyledTextCtrl() ""
wxStyledTextCtrl(wxWindow *parent, wxWindowID id=wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxPySTCNameStr);
%RenameCtor(PreStyledTextCtrl, wxStyledTextCtrl());
#else
wxStyledTextCtrl(wxWindow *parent, wxWindowID id=wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxSTCNameStr);
wxStyledTextCtrl() { m_swx = NULL; }
~wxStyledTextCtrl();
#endif
bool Create(wxWindow *parent, wxWindowID id=wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxSTCNameStr);
//----------------------------------------------------------------------
// Generated method declaration section {{{
// Add text to the document at current position.
void AddText(const wxString& text);
// Add array of cells to document.
void AddStyledText(const wxMemoryBuffer& data);
// Insert string at a position.
void InsertText(int pos, const wxString& text);
// Change the text that is being inserted in response to wxSTC_MOD_INSERTCHECK
void ChangeInsertion(int length, const wxString& text);
// Delete all text in the document.
void ClearAll();
// Delete a range of text in the document.
void DeleteRange(int start, int lengthDelete);
// Set all style bytes to 0, remove all folding information.
void ClearDocumentStyle();
// Returns the number of bytes in the document.
int GetLength() const;
// Returns the character byte at the position.
int GetCharAt(int pos) const;
// Returns the position of the caret.
int GetCurrentPos() const;
// Returns the position of the opposite end of the selection to the caret.
int GetAnchor() const;
// Returns the style byte at the position.
int GetStyleAt(int pos) const;
// Redoes the next action on the undo history.
void Redo() wxOVERRIDE;
// Choose between collecting actions into the undo
// history and discarding them.
void SetUndoCollection(bool collectUndo);
// Select all the text in the document.
void SelectAll() wxOVERRIDE;
// Remember the current position in the undo history as the position
// at which the document was saved.
void SetSavePoint();
// Retrieve a buffer of cells.
wxMemoryBuffer GetStyledText(int startPos, int endPos);
// Are there any redoable actions in the undo history?
bool CanRedo() const wxOVERRIDE;
// Retrieve the line number at which a particular marker is located.
int MarkerLineFromHandle(int markerHandle);
// Delete a marker.
void MarkerDeleteHandle(int markerHandle);
// Is undo history being collected?
bool GetUndoCollection() const;
// Are white space characters currently visible?
// Returns one of wxSTC_WS_* constants.
int GetViewWhiteSpace() const;
// Make white space characters invisible, always visible or visible outside indentation.
void SetViewWhiteSpace(int viewWS);
// Retrieve the current tab draw mode.
// Returns one of wxSTC_TD_* constants.
int GetTabDrawMode() const;
// Set how tabs are drawn when visible.
void SetTabDrawMode(int tabDrawMode);
// Find the position from a point within the window.
int PositionFromPoint(wxPoint pt) const;
// Find the position from a point within the window but return
// wxSTC_INVALID_POSITION if not close to text.
int PositionFromPointClose(int x, int y);
// Set caret to start of a line and ensure it is visible.
void GotoLine(int line);
// Set caret to a position and ensure it is visible.
void GotoPos(int caret);
// Set the selection anchor to a position. The anchor is the opposite
// end of the selection from the caret.
void SetAnchor(int anchor);
// Retrieve the text of the line containing the caret.
#ifdef SWIG
wxString GetCurLine(int* OUTPUT);
#else
wxString GetCurLine(int* linePos=NULL);
#endif
// Retrieve the position of the last correctly styled character.
int GetEndStyled() const;
// Convert all line endings in the document to one mode.
void ConvertEOLs(int eolMode);
// Retrieve the current end of line mode - one of wxSTC_EOL_CRLF, wxSTC_EOL_CR, or wxSTC_EOL_LF.
int GetEOLMode() const;
// Set the current end of line mode.
void SetEOLMode(int eolMode);
// Set the current styling position to start.
void StartStyling(int start);
// Change style from current styling position for length characters to a style
// and move the current styling position to after this newly styled segment.
void SetStyling(int length, int style);
// Is drawing done first into a buffer or direct to the screen?
bool GetBufferedDraw() const;
// If drawing is buffered then each line of text is drawn into a bitmap buffer
// before drawing it to the screen to avoid flicker.
void SetBufferedDraw(bool buffered);
// Change the visible size of a tab to be a multiple of the width of a space character.
void SetTabWidth(int tabWidth);
// Retrieve the visible size of a tab.
int GetTabWidth() const;
// Clear explicit tabstops on a line.
void ClearTabStops(int line);
// Add an explicit tab stop for a line.
void AddTabStop(int line, int x);
// Find the next explicit tab stop position on a line after a position.
int GetNextTabStop(int line, int x);
// Set the code page used to interpret the bytes of the document as characters.
void SetCodePage(int codePage);
// Is the IME displayed in a window or inline?
int GetIMEInteraction() const;
// Choose to display the the IME in a winow or inline.
void SetIMEInteraction(int imeInteraction);
// Set the symbol used for a particular marker number,
// and optionally the fore and background colours.
void MarkerDefine(int markerNumber, int markerSymbol,
const wxColour& foreground = wxNullColour,
const wxColour& background = wxNullColour);
// Set the foreground colour used for a particular marker number.
void MarkerSetForeground(int markerNumber, const wxColour& fore);
// Set the background colour used for a particular marker number.
void MarkerSetBackground(int markerNumber, const wxColour& back);
// Set the background colour used for a particular marker number when its folding block is selected.
void MarkerSetBackgroundSelected(int markerNumber, const wxColour& back);
// Enable/disable highlight for current folding bloc (smallest one that contains the caret)
void MarkerEnableHighlight(bool enabled);
// Add a marker to a line, returning an ID which can be used to find or delete the marker.
int MarkerAdd(int line, int markerNumber);
// Delete a marker from a line.
void MarkerDelete(int line, int markerNumber);
// Delete all markers with a particular number from all lines.
void MarkerDeleteAll(int markerNumber);
// Get a bit mask of all the markers set on a line.
int MarkerGet(int line);
// Find the next line at or after lineStart that includes a marker in mask.
// Return -1 when no more lines.
int MarkerNext(int lineStart, int markerMask);
// Find the previous line before lineStart that includes a marker in mask.
int MarkerPrevious(int lineStart, int markerMask);
// Define a marker from a bitmap
void MarkerDefineBitmap(int markerNumber, const wxBitmap& bmp);
// Add a set of markers to a line.
void MarkerAddSet(int line, int markerSet);
// Set the alpha used for a marker that is drawn in the text area, not the margin.
void MarkerSetAlpha(int markerNumber, int alpha);
// Set a margin to be either numeric or symbolic.
void SetMarginType(int margin, int marginType);
// Retrieve the type of a margin.
int GetMarginType(int margin) const;
// Set the width of a margin to a width expressed in pixels.
void SetMarginWidth(int margin, int pixelWidth);
// Retrieve the width of a margin in pixels.
int GetMarginWidth(int margin) const;
// Set a mask that determines which markers are displayed in a margin.
void SetMarginMask(int margin, int mask);
// Retrieve the marker mask of a margin.
int GetMarginMask(int margin) const;
// Make a margin sensitive or insensitive to mouse clicks.
void SetMarginSensitive(int margin, bool sensitive);
// Retrieve the mouse click sensitivity of a margin.
bool GetMarginSensitive(int margin) const;
// Set the cursor shown when the mouse is inside a margin.
void SetMarginCursor(int margin, int cursor);
// Retrieve the cursor shown in a margin.
int GetMarginCursor(int margin) const;
// Set the background colour of a margin. Only visible for wxSTC_MARGIN_COLOUR.
void SetMarginBackground(int margin, const wxColour& back);
// Retrieve the background colour of a margin
wxColour GetMarginBackground(int margin) const;
// Allocate a non-standard number of margins.
void SetMarginCount(int margins);
// How many margins are there?.
int GetMarginCount() const;
// Clear all the styles and make equivalent to the global default style.
void StyleClearAll();
// Set the foreground colour of a style.
void StyleSetForeground(int style, const wxColour& fore);
// Set the background colour of a style.
void StyleSetBackground(int style, const wxColour& back);
// Set a style to be bold or not.
void StyleSetBold(int style, bool bold);
// Set a style to be italic or not.
void StyleSetItalic(int style, bool italic);
// Set the size of characters of a style.
void StyleSetSize(int style, int sizePoints);
// Set the font of a style.
void StyleSetFaceName(int style, const wxString& fontName);
// Set a style to have its end of line filled or not.
void StyleSetEOLFilled(int style, bool eolFilled);
// Reset the default style to its state at startup
void StyleResetDefault();
// Set a style to be underlined or not.
void StyleSetUnderline(int style, bool underline);
// Get the foreground colour of a style.
wxColour StyleGetForeground(int style) const;
// Get the background colour of a style.
wxColour StyleGetBackground(int style) const;
// Get is a style bold or not.
bool StyleGetBold(int style) const;
// Get is a style italic or not.
bool StyleGetItalic(int style) const;
// Get the size of characters of a style.
int StyleGetSize(int style) const;
// Get the font facename of a style
wxString StyleGetFaceName(int style);
// Get is a style to have its end of line filled or not.
bool StyleGetEOLFilled(int style) const;
// Get is a style underlined or not.
bool StyleGetUnderline(int style) const;
// Get is a style mixed case, or to force upper or lower case.
int StyleGetCase(int style) const;
// Get the character get of the font in a style.
int StyleGetCharacterSet(int style) const;
// Get is a style visible or not.
bool StyleGetVisible(int style) const;
// Get is a style changeable or not (read only).
// Experimental feature, currently buggy.
bool StyleGetChangeable(int style) const;
// Get is a style a hotspot or not.
bool StyleGetHotSpot(int style) const;
// Set a style to be mixed case, or to force upper or lower case.
void StyleSetCase(int style, int caseVisible);
// Set the size of characters of a style. Size is in points multiplied by 100.
void StyleSetSizeFractional(int style, int sizeHundredthPoints);
// Get the size of characters of a style in points multiplied by 100
int StyleGetSizeFractional(int style) const;
// Set the weight of characters of a style.
void StyleSetWeight(int style, int weight);
// Get the weight of characters of a style.
int StyleGetWeight(int style) const;
// Set the character set of the font in a style.
void StyleSetCharacterSet(int style, int characterSet);
// Set a style to be a hotspot or not.
void StyleSetHotSpot(int style, bool hotspot);
// Set the foreground colour of the main and additional selections and whether to use this setting.
void SetSelForeground(bool useSetting, const wxColour& fore);
// Set the background colour of the main and additional selections and whether to use this setting.
void SetSelBackground(bool useSetting, const wxColour& back);
// Get the alpha of the selection.
int GetSelAlpha() const;
// Set the alpha of the selection.
void SetSelAlpha(int alpha);
// Is the selection end of line filled?
bool GetSelEOLFilled() const;
// Set the selection to have its end of line filled or not.
void SetSelEOLFilled(bool filled);
// Set the foreground colour of the caret.
void SetCaretForeground(const wxColour& fore);
// When key+modifier combination keyDefinition is pressed perform sciCommand.
void CmdKeyAssign(int key, int modifiers, int cmd);
// When key+modifier combination keyDefinition is pressed do nothing.
void CmdKeyClear(int key, int modifiers);
// Drop all key mappings.
void CmdKeyClearAll();
// Set the styles for a segment of the document.
void SetStyleBytes(int length, char* styleBytes);
// Set a style to be visible or not.
void StyleSetVisible(int style, bool visible);
// Get the time in milliseconds that the caret is on and off.
int GetCaretPeriod() const;
// Get the time in milliseconds that the caret is on and off. 0 = steady on.
void SetCaretPeriod(int periodMilliseconds);
// Set the set of characters making up words for when moving or selecting by word.
// First sets defaults like SetCharsDefault.
void SetWordChars(const wxString& characters);
// Get the set of characters making up words for when moving or selecting by word.
wxString GetWordChars() const;
// Start a sequence of actions that is undone and redone as a unit.
// May be nested.
void BeginUndoAction();
// End a sequence of actions that is undone and redone as a unit.
void EndUndoAction();
// Set an indicator to plain, squiggle or TT.
void IndicatorSetStyle(int indicator, int indicatorStyle);
// Retrieve the style of an indicator.
int IndicatorGetStyle(int indicator) const;
// Set the foreground colour of an indicator.
void IndicatorSetForeground(int indicator, const wxColour& fore);
// Retrieve the foreground colour of an indicator.
wxColour IndicatorGetForeground(int indicator) const;
// Set an indicator to draw under text or over(default).
void IndicatorSetUnder(int indicator, bool under);
// Retrieve whether indicator drawn under or over text.
bool IndicatorGetUnder(int indicator) const;
// Set a hover indicator to plain, squiggle or TT.
void IndicatorSetHoverStyle(int indicator, int indicatorStyle);
// Retrieve the hover style of an indicator.
int IndicatorGetHoverStyle(int indicator) const;
// Set the foreground hover colour of an indicator.
void IndicatorSetHoverForeground(int indicator, const wxColour& fore);
// Retrieve the foreground hover colour of an indicator.
wxColour IndicatorGetHoverForeground(int indicator) const;
// Set the attributes of an indicator.
void IndicatorSetFlags(int indicator, int flags);
// Retrieve the attributes of an indicator.
int IndicatorGetFlags(int indicator) const;
// Set the foreground colour of all whitespace and whether to use this setting.
void SetWhitespaceForeground(bool useSetting, const wxColour& fore);
// Set the background colour of all whitespace and whether to use this setting.
void SetWhitespaceBackground(bool useSetting, const wxColour& back);
// Set the size of the dots used to mark space characters.
void SetWhitespaceSize(int size);
// Get the size of the dots used to mark space characters.
int GetWhitespaceSize() const;
// Divide each styling byte into lexical class bits (default: 5) and indicator
// bits (default: 3). If a lexer requires more than 32 lexical states, then this
// is used to expand the possible states.
wxDEPRECATED_MSG( "This method uses a function deprecated in the Scintilla library." )
void SetStyleBits(int bits);
// Retrieve number of bits in style bytes used to hold the lexical state.
wxDEPRECATED_MSG( "This method uses a function deprecated in the Scintilla library." )
int GetStyleBits() const;
// Used to hold extra styling information for each line.
void SetLineState(int line, int state);
// Retrieve the extra styling information for a line.
int GetLineState(int line) const;
// Retrieve the last line number that has line state.
int GetMaxLineState() const;
// Is the background of the line containing the caret in a different colour?
bool GetCaretLineVisible() const;
// Display the background of the line containing the caret in a different colour.
void SetCaretLineVisible(bool show);
// Get the colour of the background of the line containing the caret.
wxColour GetCaretLineBackground() const;
// Set the colour of the background of the line containing the caret.
void SetCaretLineBackground(const wxColour& back);
// Set a style to be changeable or not (read only).
// Experimental feature, currently buggy.
void StyleSetChangeable(int style, bool changeable);
// Display a auto-completion list.
// The lengthEntered parameter indicates how many characters before
// the caret should be used to provide context.
void AutoCompShow(int lengthEntered, const wxString& itemList);
// Remove the auto-completion list from the screen.
void AutoCompCancel();
// Is there an auto-completion list visible?
bool AutoCompActive();
// Retrieve the position of the caret when the auto-completion list was displayed.
int AutoCompPosStart();
// User has selected an item so remove the list and insert the selection.
void AutoCompComplete();
// Define a set of character that when typed cancel the auto-completion list.
void AutoCompStops(const wxString& characterSet);
// Change the separator character in the string setting up an auto-completion list.
// Default is space but can be changed if items contain space.
void AutoCompSetSeparator(int separatorCharacter);
// Retrieve the auto-completion list separator character.
int AutoCompGetSeparator() const;
// Select the item in the auto-completion list that starts with a string.
void AutoCompSelect(const wxString& select);
// Should the auto-completion list be cancelled if the user backspaces to a
// position before where the box was created.
void AutoCompSetCancelAtStart(bool cancel);
// Retrieve whether auto-completion cancelled by backspacing before start.
bool AutoCompGetCancelAtStart() const;
// Define a set of characters that when typed will cause the autocompletion to
// choose the selected item.
void AutoCompSetFillUps(const wxString& characterSet);
// Should a single item auto-completion list automatically choose the item.
void AutoCompSetChooseSingle(bool chooseSingle);
// Retrieve whether a single item auto-completion list automatically choose the item.
bool AutoCompGetChooseSingle() const;
// Set whether case is significant when performing auto-completion searches.
void AutoCompSetIgnoreCase(bool ignoreCase);
// Retrieve state of ignore case flag.
bool AutoCompGetIgnoreCase() const;
// Display a list of strings and send notification when user chooses one.
void UserListShow(int listType, const wxString& itemList);
// Set whether or not autocompletion is hidden automatically when nothing matches.
void AutoCompSetAutoHide(bool autoHide);
// Retrieve whether or not autocompletion is hidden automatically when nothing matches.
bool AutoCompGetAutoHide() const;
// Set whether or not autocompletion deletes any word characters
// after the inserted text upon completion.
void AutoCompSetDropRestOfWord(bool dropRestOfWord);
// Retrieve whether or not autocompletion deletes any word characters
// after the inserted text upon completion.
bool AutoCompGetDropRestOfWord() const;
// Register an image for use in autocompletion lists.
void RegisterImage(int type, const wxBitmap& bmp);
// Clear all the registered images.
void ClearRegisteredImages();
// Retrieve the auto-completion list type-separator character.
int AutoCompGetTypeSeparator() const;
// Change the type-separator character in the string setting up an auto-completion list.
// Default is '?' but can be changed if items contain '?'.
void AutoCompSetTypeSeparator(int separatorCharacter);
// Set the maximum width, in characters, of auto-completion and user lists.
// Set to 0 to autosize to fit longest item, which is the default.
void AutoCompSetMaxWidth(int characterCount);
// Get the maximum width, in characters, of auto-completion and user lists.
int AutoCompGetMaxWidth() const;
// Set the maximum height, in rows, of auto-completion and user lists.
// The default is 5 rows.
void AutoCompSetMaxHeight(int rowCount);
// Set the maximum height, in rows, of auto-completion and user lists.
int AutoCompGetMaxHeight() const;
// Set the number of spaces used for one level of indentation.
void SetIndent(int indentSize);
// Retrieve indentation size.
int GetIndent() const;
// Indentation will only use space characters if useTabs is false, otherwise
// it will use a combination of tabs and spaces.
void SetUseTabs(bool useTabs);
// Retrieve whether tabs will be used in indentation.
bool GetUseTabs() const;
// Change the indentation of a line to a number of columns.
void SetLineIndentation(int line, int indentation);
// Retrieve the number of columns that a line is indented.
int GetLineIndentation(int line) const;
// Retrieve the position before the first non indentation character on a line.
int GetLineIndentPosition(int line) const;
// Retrieve the column number of a position, taking tab width into account.
int GetColumn(int pos) const;
// Count characters between two positions.
int CountCharacters(int start, int end);
// Show or hide the horizontal scroll bar.
void SetUseHorizontalScrollBar(bool visible);
// Is the horizontal scroll bar visible?
bool GetUseHorizontalScrollBar() const;
// Show or hide indentation guides.
void SetIndentationGuides(int indentView);
// Are the indentation guides visible?
int GetIndentationGuides() const;
// Set the highlighted indentation guide column.
// 0 = no highlighted guide.
void SetHighlightGuide(int column);
// Get the highlighted indentation guide column.
int GetHighlightGuide() const;
// Get the position after the last visible characters on a line.
int GetLineEndPosition(int line) const;
// Get the code page used to interpret the bytes of the document as characters.
int GetCodePage() const;
// Get the foreground colour of the caret.
wxColour GetCaretForeground() const;
// In read-only mode?
bool GetReadOnly() const;
// Sets the position of the caret.
void SetCurrentPos(int caret);
// Sets the position that starts the selection - this becomes the anchor.
void SetSelectionStart(int anchor);
// Returns the position at the start of the selection.
int GetSelectionStart() const;
// Sets the position that ends the selection - this becomes the caret.
void SetSelectionEnd(int caret);
// Returns the position at the end of the selection.
int GetSelectionEnd() const;
// Set caret to a position, while removing any existing selection.
void SetEmptySelection(int caret);
// Sets the print magnification added to the point size of each style for printing.
void SetPrintMagnification(int magnification);
// Returns the print magnification.
int GetPrintMagnification() const;
// Modify colours when printing for clearer printed text.
void SetPrintColourMode(int mode);
// Returns the print colour mode.
int GetPrintColourMode() const;
// Find some text in the document.
int FindText(int minPos, int maxPos, const wxString& text, int flags=0,
int* findEnd=NULL);
// On Windows, will draw the document into a display context such as a printer.
int FormatRange(bool doDraw,
int startPos,
int endPos,
wxDC* draw,
wxDC* target,
wxRect renderRect,
wxRect pageRect);
// Retrieve the display line at the top of the display.
int GetFirstVisibleLine() const;
// Retrieve the contents of a line.
wxString GetLine(int line) const;
// Returns the number of lines in the document. There is always at least one.
int GetLineCount() const;
// Sets the size in pixels of the left margin.
void SetMarginLeft(int pixelWidth);
// Returns the size in pixels of the left margin.
int GetMarginLeft() const;
// Sets the size in pixels of the right margin.
void SetMarginRight(int pixelWidth);
// Returns the size in pixels of the right margin.
int GetMarginRight() const;
// Is the document different from when it was last saved?
bool GetModify() const;
// Retrieve the selected text.
wxString GetSelectedText();
// Retrieve a range of text.
wxString GetTextRange(int startPos, int endPos);
// Draw the selection in normal style or with selection highlighted.
void HideSelection(bool hide);
// Retrieve the point in the window where a position is displayed.
wxPoint PointFromPosition(int pos);
// Retrieve the line containing a position.
int LineFromPosition(int pos) const;
// Retrieve the position at the start of a line.
int PositionFromLine(int line) const;
// Scroll horizontally and vertically.
void LineScroll(int columns, int lines);
// Ensure the caret is visible.
void EnsureCaretVisible();
// Scroll the argument positions and the range between them into view giving
// priority to the primary position then the secondary position.
// This may be used to make a search match visible.
void ScrollRange(int secondary, int primary);
// Replace the selected text with the argument text.
void ReplaceSelection(const wxString& text);
// Set to read only or read write.
void SetReadOnly(bool readOnly);
// Will a paste succeed?
bool CanPaste() const wxOVERRIDE;
// Are there any undoable actions in the undo history?
bool CanUndo() const wxOVERRIDE;
// Delete the undo history.
void EmptyUndoBuffer();
// Undo one action in the undo history.
void Undo() wxOVERRIDE;
// Cut the selection to the clipboard.
void Cut() wxOVERRIDE;
// Copy the selection to the clipboard.
void Copy() wxOVERRIDE;
// Paste the contents of the clipboard into the document replacing the selection.
void Paste() wxOVERRIDE;
// Clear the selection.
void Clear() wxOVERRIDE;
// Replace the contents of the document with the argument text.
void SetText(const wxString& text);
// Retrieve all the text in the document.
wxString GetText() const;
// Retrieve the number of characters in the document.
int GetTextLength() const;
// Retrieve a pointer to a function that processes messages for this Scintilla.
void* GetDirectFunction() const;
// Retrieve a pointer value to use as the first argument when calling
// the function returned by GetDirectFunction.
void* GetDirectPointer() const;
// Set to overtype (true) or insert mode.
void SetOvertype(bool overType);
// Returns true if overtype mode is active otherwise false is returned.
bool GetOvertype() const;
// Set the width of the insert mode caret.
void SetCaretWidth(int pixelWidth);
// Returns the width of the insert mode caret.
int GetCaretWidth() const;
// Sets the position that starts the target which is used for updating the
// document without affecting the scroll position.
void SetTargetStart(int start);
// Get the position that starts the target.
int GetTargetStart() const;
// Sets the position that ends the target which is used for updating the
// document without affecting the scroll position.
void SetTargetEnd(int end);
// Get the position that ends the target.
int GetTargetEnd() const;
// Sets both the start and end of the target in one call.
void SetTargetRange(int start, int end);
// Retrieve the text in the target.
wxString GetTargetText() const;
// Make the target range start and end be the same as the selection range start and end.
void TargetFromSelection();
// Sets the target to the whole document.
void TargetWholeDocument();
// Replace the target text with the argument text.
// Text is counted so it can contain NULs.
// Returns the length of the replacement text.
int ReplaceTarget(const wxString& text);
// Replace the target text with the argument text after \\d processing.
// Text is counted so it can contain NULs.
// Looks for \\d where d is between 1 and 9 and replaces these with the strings
// matched in the last search operation which were surrounded by \\( and \\).
// Returns the length of the replacement text including any change
// caused by processing the \\d patterns.
int ReplaceTargetRE(const wxString& text);
// Search for a counted string in the target and set the target to the found
// range. Text is counted so it can contain NULs.
// Returns length of range or -1 for failure in which case target is not moved.
int SearchInTarget(const wxString& text);
// Set the search flags used by SearchInTarget.
void SetSearchFlags(int searchFlags);
// Get the search flags used by SearchInTarget.
int GetSearchFlags() const;
// Show a call tip containing a definition near position pos.
void CallTipShow(int pos, const wxString& definition);
// Remove the call tip from the screen.
void CallTipCancel();
// Is there an active call tip?
bool CallTipActive();
// Retrieve the position where the caret was before displaying the call tip.
int CallTipPosAtStart();
// Set the start position in order to change when backspacing removes the calltip.
void CallTipSetPosAtStart(int posStart);
// Highlight a segment of the definition.
void CallTipSetHighlight(int highlightStart, int highlightEnd);
// Set the background colour for the call tip.
void CallTipSetBackground(const wxColour& back);
// Set the foreground colour for the call tip.
void CallTipSetForeground(const wxColour& fore);
// Set the foreground colour for the highlighted part of the call tip.
void CallTipSetForegroundHighlight(const wxColour& fore);
// Enable use of wxSTC_STYLE_CALLTIP and set call tip tab size in pixels.
void CallTipUseStyle(int tabSize);
// Set position of calltip, above or below text.
void CallTipSetPosition(bool above);
// Find the display line of a document line taking hidden lines into account.
int VisibleFromDocLine(int docLine);
// Find the document line of a display line taking hidden lines into account.
int DocLineFromVisible(int displayLine);
// The number of display lines needed to wrap a document line
int WrapCount(int docLine);
// Set the fold level of a line.
// This encodes an integer level along with flags indicating whether the
// line is a header and whether it is effectively white space.
void SetFoldLevel(int line, int level);
// Retrieve the fold level of a line.
int GetFoldLevel(int line) const;
// Find the last child line of a header line.
int GetLastChild(int line, int level) const;
// Find the parent line of a child line.
int GetFoldParent(int line) const;
// Make a range of lines visible.
void ShowLines(int lineStart, int lineEnd);
// Make a range of lines invisible.
void HideLines(int lineStart, int lineEnd);
// Is a line visible?
bool GetLineVisible(int line) const;
// Are all lines visible?
bool GetAllLinesVisible() const;
// Show the children of a header line.
void SetFoldExpanded(int line, bool expanded);
// Is a header line expanded?
bool GetFoldExpanded(int line) const;
// Switch a header line between expanded and contracted.
void ToggleFold(int line);
// Switch a header line between expanded and contracted and show some text after the line.
void ToggleFoldShowText(int line, const wxString& text);
// Set the style of fold display text
void FoldDisplayTextSetStyle(int style);
// Expand or contract a fold header.
void FoldLine(int line, int action);
// Expand or contract a fold header and its children.
void FoldChildren(int line, int action);
// Expand a fold header and all children. Use the level argument instead of the line's current level.
void ExpandChildren(int line, int level);
// Expand or contract all fold headers.
void FoldAll(int action);
// Ensure a particular line is visible by expanding any header line hiding it.
void EnsureVisible(int line);
// Set automatic folding behaviours.
void SetAutomaticFold(int automaticFold);
// Get automatic folding behaviours.
int GetAutomaticFold() const;
// Set some style options for folding.
void SetFoldFlags(int flags);
// Ensure a particular line is visible by expanding any header line hiding it.
// Use the currently set visibility policy to determine which range to display.
void EnsureVisibleEnforcePolicy(int line);
// Sets whether a tab pressed when caret is within indentation indents.
void SetTabIndents(bool tabIndents);
// Does a tab pressed when caret is within indentation indent?
bool GetTabIndents() const;
// Sets whether a backspace pressed when caret is within indentation unindents.
void SetBackSpaceUnIndents(bool bsUnIndents);
// Does a backspace pressed when caret is within indentation unindent?
bool GetBackSpaceUnIndents() const;
// Sets the time the mouse must sit still to generate a mouse dwell event.
void SetMouseDwellTime(int periodMilliseconds);
// Retrieve the time the mouse must sit still to generate a mouse dwell event.
int GetMouseDwellTime() const;
// Get position of start of word.
int WordStartPosition(int pos, bool onlyWordCharacters);
// Get position of end of word.
int WordEndPosition(int pos, bool onlyWordCharacters);
// Is the range start..end considered a word?
bool IsRangeWord(int start, int end);
// Sets limits to idle styling.
void SetIdleStyling(int idleStyling);
// Retrieve the limits to idle styling.
int GetIdleStyling() const;
// Sets whether text is word wrapped.
void SetWrapMode(int wrapMode);
// Retrieve whether text is word wrapped.
int GetWrapMode() const;
// Set the display mode of visual flags for wrapped lines.
void SetWrapVisualFlags(int wrapVisualFlags);
// Retrive the display mode of visual flags for wrapped lines.
int GetWrapVisualFlags() const;
// Set the location of visual flags for wrapped lines.
void SetWrapVisualFlagsLocation(int wrapVisualFlagsLocation);
// Retrive the location of visual flags for wrapped lines.
int GetWrapVisualFlagsLocation() const;
// Set the start indent for wrapped lines.
void SetWrapStartIndent(int indent);
// Retrive the start indent for wrapped lines.
int GetWrapStartIndent() const;
// Sets how wrapped sublines are placed. Default is wxSTC_WRAPINDENT_FIXED.
void SetWrapIndentMode(int wrapIndentMode);
// Retrieve how wrapped sublines are placed. Default is wxSTC_WRAPINDENT_FIXED.
int GetWrapIndentMode() const;
// Sets the degree of caching of layout information.
void SetLayoutCache(int cacheMode);
// Retrieve the degree of caching of layout information.
int GetLayoutCache() const;
// Sets the document width assumed for scrolling.
void SetScrollWidth(int pixelWidth);
// Retrieve the document width assumed for scrolling.
int GetScrollWidth() const;
// Sets whether the maximum width line displayed is used to set scroll width.
void SetScrollWidthTracking(bool tracking);
// Retrieve whether the scroll width tracks wide lines.
bool GetScrollWidthTracking() const;
// Measure the pixel width of some text in a particular style.
// Does not handle tab or control characters.
int TextWidth(int style, const wxString& text);
// Sets the scroll range so that maximum scroll position has
// the last line at the bottom of the view (default).
// Setting this to false allows scrolling one page below the last line.
void SetEndAtLastLine(bool endAtLastLine);
// Retrieve whether the maximum scroll position has the last
// line at the bottom of the view.
bool GetEndAtLastLine() const;
// Retrieve the height of a particular line of text in pixels.
int TextHeight(int line);
// Show or hide the vertical scroll bar.
void SetUseVerticalScrollBar(bool visible);
// Is the vertical scroll bar visible?
bool GetUseVerticalScrollBar() const;
// Append a string to the end of the document without changing the selection.
void AppendText(const wxString& text) wxOVERRIDE;
// Is drawing done in two phases with backgrounds drawn before foregrounds?
bool GetTwoPhaseDraw() const;
// In twoPhaseDraw mode, drawing is performed in two phases, first the background
// and then the foreground. This avoids chopping off characters that overlap the next run.
void SetTwoPhaseDraw(bool twoPhase);
// How many phases is drawing done in?
int GetPhasesDraw() const;
// In one phase draw, text is drawn in a series of rectangular blocks with no overlap.
// In two phase draw, text is drawn in a series of lines allowing runs to overlap horizontally.
// In multiple phase draw, each element is drawn over the whole drawing area, allowing text
// to overlap from one line to the next.
void SetPhasesDraw(int phases);
// Choose the quality level for text.
void SetFontQuality(int fontQuality);
// Retrieve the quality level for text.
int GetFontQuality() const;
// Scroll so that a display line is at the top of the display.
void SetFirstVisibleLine(int displayLine);
// Change the effect of pasting when there are multiple selections.
void SetMultiPaste(int multiPaste);
// Retrieve the effect of pasting when there are multiple selections.
int GetMultiPaste() const;
// Retrieve the value of a tag from a regular expression search.
wxString GetTag(int tagNumber) const;
// Join the lines in the target.
void LinesJoin();
// Split the lines in the target into lines that are less wide than pixelWidth
// where possible.
void LinesSplit(int pixelWidth);
// Set one of the colours used as a chequerboard pattern in the fold margin
void SetFoldMarginColour(bool useSetting, const wxColour& back);
// Set the other colour used as a chequerboard pattern in the fold margin
void SetFoldMarginHiColour(bool useSetting, const wxColour& fore);
// Move caret down one line.
void LineDown();
// Move caret down one line extending selection to new caret position.
void LineDownExtend();
// Move caret up one line.
void LineUp();
// Move caret up one line extending selection to new caret position.
void LineUpExtend();
// Move caret left one character.
void CharLeft();
// Move caret left one character extending selection to new caret position.
void CharLeftExtend();
// Move caret right one character.
void CharRight();
// Move caret right one character extending selection to new caret position.
void CharRightExtend();
// Move caret left one word.
void WordLeft();
// Move caret left one word extending selection to new caret position.
void WordLeftExtend();
// Move caret right one word.
void WordRight();
// Move caret right one word extending selection to new caret position.
void WordRightExtend();
// Move caret to first position on line.
void Home();
// Move caret to first position on line extending selection to new caret position.
void HomeExtend();
// Move caret to last position on line.
void LineEnd();
// Move caret to last position on line extending selection to new caret position.
void LineEndExtend();
// Move caret to first position in document.
void DocumentStart();
// Move caret to first position in document extending selection to new caret position.
void DocumentStartExtend();
// Move caret to last position in document.
void DocumentEnd();
// Move caret to last position in document extending selection to new caret position.
void DocumentEndExtend();
// Move caret one page up.
void PageUp();
// Move caret one page up extending selection to new caret position.
void PageUpExtend();
// Move caret one page down.
void PageDown();
// Move caret one page down extending selection to new caret position.
void PageDownExtend();
// Switch from insert to overtype mode or the reverse.
void EditToggleOvertype();
// Cancel any modes such as call tip or auto-completion list display.
void Cancel();
// Delete the selection or if no selection, the character before the caret.
void DeleteBack();
// If selection is empty or all on one line replace the selection with a tab character.
// If more than one line selected, indent the lines.
void Tab();
// Dedent the selected lines.
void BackTab();
// Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
void NewLine();
// Insert a Form Feed character.
void FormFeed();
// Move caret to before first visible character on line.
// If already there move to first character on line.
void VCHome();
// Like VCHome but extending selection to new caret position.
void VCHomeExtend();
// Magnify the displayed text by increasing the sizes by 1 point.
void ZoomIn();
// Make the displayed text smaller by decreasing the sizes by 1 point.
void ZoomOut();
// Delete the word to the left of the caret.
void DelWordLeft();
// Delete the word to the right of the caret.
void DelWordRight();
// Delete the word to the right of the caret, but not the trailing non-word characters.
void DelWordRightEnd();
// Cut the line containing the caret.
void LineCut();
// Delete the line containing the caret.
void LineDelete();
// Switch the current line with the previous.
void LineTranspose();
// Duplicate the current line.
void LineDuplicate();
// Transform the selection to lower case.
void LowerCase();
// Transform the selection to upper case.
void UpperCase();
// Scroll the document down, keeping the caret visible.
void LineScrollDown();
// Scroll the document up, keeping the caret visible.
void LineScrollUp();
// Delete the selection or if no selection, the character before the caret.
// Will not delete the character before at the start of a line.
void DeleteBackNotLine();
// Move caret to first position on display line.
void HomeDisplay();
// Move caret to first position on display line extending selection to
// new caret position.
void HomeDisplayExtend();
// Move caret to last position on display line.
void LineEndDisplay();
// Move caret to last position on display line extending selection to new
// caret position.
void LineEndDisplayExtend();
// Like Home but when word-wrap is enabled goes first to start of display line
// HomeDisplay, then to start of document line Home.
void HomeWrap();
// Like HomeExtend but when word-wrap is enabled extends first to start of display line
// HomeDisplayExtend, then to start of document line HomeExtend.
void HomeWrapExtend();
// Like LineEnd but when word-wrap is enabled goes first to end of display line
// LineEndDisplay, then to start of document line LineEnd.
void LineEndWrap();
// Like LineEndExtend but when word-wrap is enabled extends first to end of display line
// LineEndDisplayExtend, then to start of document line LineEndExtend.
void LineEndWrapExtend();
// Like VCHome but when word-wrap is enabled goes first to start of display line
// VCHomeDisplay, then behaves like VCHome.
void VCHomeWrap();
// Like VCHomeExtend but when word-wrap is enabled extends first to start of display line
// VCHomeDisplayExtend, then behaves like VCHomeExtend.
void VCHomeWrapExtend();
// Copy the line containing the caret.
void LineCopy();
// Move the caret inside current view if it's not there already.
void MoveCaretInsideView();
// How many characters are on a line, including end of line characters?
int LineLength(int line) const;
// Highlight the characters at two positions.
void BraceHighlight(int posA, int posB);
// Use specified indicator to highlight matching braces instead of changing their style.
void BraceHighlightIndicator(bool useSetting, int indicator);
// Highlight the character at a position indicating there is no matching brace.
void BraceBadLight(int pos);
// Use specified indicator to highlight non matching brace instead of changing its style.
void BraceBadLightIndicator(bool useSetting, int indicator);
// Find the position of a matching brace or wxSTC_INVALID_POSITION if no match.
// The maxReStyle must be 0 for now. It may be defined in a future release.
int BraceMatch(int pos, int maxReStyle=0);
// Are the end of line characters visible?
bool GetViewEOL() const;
// Make the end of line characters visible or invisible.
void SetViewEOL(bool visible);
// Retrieve a pointer to the document object.
void* GetDocPointer();
// Change the document object used.
void SetDocPointer(void* docPointer);
// Set which document modification events are sent to the container.
void SetModEventMask(int eventMask);
// Retrieve the column number which text should be kept within.
int GetEdgeColumn() const;
// Set the column number of the edge.
// If text goes past the edge then it is highlighted.
void SetEdgeColumn(int column);
// Retrieve the edge highlight mode.
int GetEdgeMode() const;
// The edge may be displayed by a line (wxSTC_EDGE_LINE/wxSTC_EDGE_MULTILINE) or by highlighting text that
// goes beyond it (wxSTC_EDGE_BACKGROUND) or not displayed at all (wxSTC_EDGE_NONE).
void SetEdgeMode(int edgeMode);
// Retrieve the colour used in edge indication.
wxColour GetEdgeColour() const;
// Change the colour used in edge indication.
void SetEdgeColour(const wxColour& edgeColour);
// Add a new vertical edge to the view.
void MultiEdgeAddLine(int column, const wxColour& edgeColour);
// Clear all vertical edges.
void MultiEdgeClearAll();
// Sets the current caret position to be the search anchor.
void SearchAnchor();
// Find some text starting at the search anchor.
// Does not ensure the selection is visible.
int SearchNext(int searchFlags, const wxString& text);
// Find some text starting at the search anchor and moving backwards.
// Does not ensure the selection is visible.
int SearchPrev(int searchFlags, const wxString& text);
// Retrieves the number of lines completely visible.
int LinesOnScreen() const;
// Set whether a pop up menu is displayed automatically when the user presses
// the wrong mouse button on certain areas.
void UsePopUp(int popUpMode);
// Is the selection rectangular? The alternative is the more common stream selection.
bool SelectionIsRectangle() const;
// Set the zoom level. This number of points is added to the size of all fonts.
// It may be positive to magnify or negative to reduce.
void SetZoom(int zoomInPoints);
// Retrieve the zoom level.
int GetZoom() const;
// Create a new document object.
// Starts with reference count of 1 and not selected into editor.
void* CreateDocument();
// Extend life of document.
void AddRefDocument(void* docPointer);
// Release a reference to the document, deleting document if it fades to black.
void ReleaseDocument(void* docPointer);
// Get which document modification events are sent to the container.
int GetModEventMask() const;
// Change internal focus flag.
void SetSTCFocus(bool focus);
// Get internal focus flag.
bool GetSTCFocus() const;
// Change error status - 0 = OK.
void SetStatus(int status);
// Get error status.
int GetStatus() const;
// Set whether the mouse is captured when its button is pressed.
void SetMouseDownCaptures(bool captures);
// Get whether mouse gets captured.
bool GetMouseDownCaptures() const;
// Set whether the mouse wheel can be active outside the window.
void SetMouseWheelCaptures(bool captures);
// Get whether mouse wheel can be active outside the window.
bool GetMouseWheelCaptures() const;
// Sets the cursor to one of the wxSTC_CURSOR* values.
void SetSTCCursor(int cursorType);
// Get cursor type.
int GetSTCCursor() const;
// Change the way control characters are displayed:
// If symbol is < 32, keep the drawn way, else, use the given character.
void SetControlCharSymbol(int symbol);
// Get the way control characters are displayed.
int GetControlCharSymbol() const;
// Move to the previous change in capitalisation.
void WordPartLeft();
// Move to the previous change in capitalisation extending selection
// to new caret position.
void WordPartLeftExtend();
// Move to the change next in capitalisation.
void WordPartRight();
// Move to the next change in capitalisation extending selection
// to new caret position.
void WordPartRightExtend();
// Set the way the display area is determined when a particular line
// is to be moved to by Find, FindNext, GotoLine, etc.
void SetVisiblePolicy(int visiblePolicy, int visibleSlop);
// Delete back from the current position to the start of the line.
void DelLineLeft();
// Delete forwards from the current position to the end of the line.
void DelLineRight();
// Set the xOffset (ie, horizontal scroll position).
void SetXOffset(int xOffset);
// Get the xOffset (ie, horizontal scroll position).
int GetXOffset() const;
// Set the last x chosen value to be the caret x position.
void ChooseCaretX();
// Set the way the caret is kept visible when going sideways.
// The exclusion zone is given in pixels.
void SetXCaretPolicy(int caretPolicy, int caretSlop);
// Set the way the line the caret is on is kept visible.
// The exclusion zone is given in lines.
void SetYCaretPolicy(int caretPolicy, int caretSlop);
// Set printing to line wrapped (wxSTC_WRAP_WORD) or not line wrapped (wxSTC_WRAP_NONE).
void SetPrintWrapMode(int wrapMode);
// Is printing line wrapped?
int GetPrintWrapMode() const;
// Set a fore colour for active hotspots.
void SetHotspotActiveForeground(bool useSetting, const wxColour& fore);
// Get the fore colour for active hotspots.
wxColour GetHotspotActiveForeground() const;
// Set a back colour for active hotspots.
void SetHotspotActiveBackground(bool useSetting, const wxColour& back);
// Get the back colour for active hotspots.
wxColour GetHotspotActiveBackground() const;
// Enable / Disable underlining active hotspots.
void SetHotspotActiveUnderline(bool underline);
// Get whether underlining for active hotspots.
bool GetHotspotActiveUnderline() const;
// Limit hotspots to single line so hotspots on two lines don't merge.
void SetHotspotSingleLine(bool singleLine);
// Get the HotspotSingleLine property
bool GetHotspotSingleLine() const;
// Move caret down one paragraph (delimited by empty lines).
void ParaDown();
// Extend selection down one paragraph (delimited by empty lines).
void ParaDownExtend();
// Move caret up one paragraph (delimited by empty lines).
void ParaUp();
// Extend selection up one paragraph (delimited by empty lines).
void ParaUpExtend();
// Given a valid document position, return the previous position taking code
// page into account. Returns 0 if passed 0.
int PositionBefore(int pos);
// Given a valid document position, return the next position taking code
// page into account. Maximum value returned is the last position in the document.
int PositionAfter(int pos);
// Given a valid document position, return a position that differs in a number
// of characters. Returned value is always between 0 and last position in document.
int PositionRelative(int pos, int relative);
// Copy a range of text to the clipboard. Positions are clipped into the document.
void CopyRange(int start, int end);
// Copy argument text to the clipboard.
void CopyText(int length, const wxString& text);
// Set the selection mode to stream (wxSTC_SEL_STREAM) or rectangular (wxSTC_SEL_RECTANGLE/wxSTC_SEL_THIN) or
// by lines (wxSTC_SEL_LINES).
void SetSelectionMode(int selectionMode);
// Get the mode of the current selection.
int GetSelectionMode() const;
// Retrieve the position of the start of the selection at the given line (wxSTC_INVALID_POSITION if no selection on this line).
int GetLineSelStartPosition(int line);
// Retrieve the position of the end of the selection at the given line (wxSTC_INVALID_POSITION if no selection on this line).
int GetLineSelEndPosition(int line);
// Move caret down one line, extending rectangular selection to new caret position.
void LineDownRectExtend();
// Move caret up one line, extending rectangular selection to new caret position.
void LineUpRectExtend();
// Move caret left one character, extending rectangular selection to new caret position.
void CharLeftRectExtend();
// Move caret right one character, extending rectangular selection to new caret position.
void CharRightRectExtend();
// Move caret to first position on line, extending rectangular selection to new caret position.
void HomeRectExtend();
// Move caret to before first visible character on line.
// If already there move to first character on line.
// In either case, extend rectangular selection to new caret position.
void VCHomeRectExtend();
// Move caret to last position on line, extending rectangular selection to new caret position.
void LineEndRectExtend();
// Move caret one page up, extending rectangular selection to new caret position.
void PageUpRectExtend();
// Move caret one page down, extending rectangular selection to new caret position.
void PageDownRectExtend();
// Move caret to top of page, or one page up if already at top of page.
void StutteredPageUp();
// Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
void StutteredPageUpExtend();
// Move caret to bottom of page, or one page down if already at bottom of page.
void StutteredPageDown();
// Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
void StutteredPageDownExtend();
// Move caret left one word, position cursor at end of word.
void WordLeftEnd();
// Move caret left one word, position cursor at end of word, extending selection to new caret position.
void WordLeftEndExtend();
// Move caret right one word, position cursor at end of word.
void WordRightEnd();
// Move caret right one word, position cursor at end of word, extending selection to new caret position.
void WordRightEndExtend();
// Set the set of characters making up whitespace for when moving or selecting by word.
// Should be called after SetWordChars.
void SetWhitespaceChars(const wxString& characters);
// Get the set of characters making up whitespace for when moving or selecting by word.
wxString GetWhitespaceChars() const;
// Set the set of characters making up punctuation characters
// Should be called after SetWordChars.
void SetPunctuationChars(const wxString& characters);
// Get the set of characters making up punctuation characters
wxString GetPunctuationChars() const;
// Reset the set of characters for whitespace and word characters to the defaults.
void SetCharsDefault();
// Get currently selected item position in the auto-completion list
int AutoCompGetCurrent() const;
// Get currently selected item text in the auto-completion list
wxString AutoCompGetCurrentText() const;
// Set auto-completion case insensitive behaviour to either prefer case-sensitive matches or have no preference.
void AutoCompSetCaseInsensitiveBehaviour(int behaviour);
// Get auto-completion case insensitive behaviour.
int AutoCompGetCaseInsensitiveBehaviour() const;
// Change the effect of autocompleting when there are multiple selections.
void AutoCompSetMulti(int multi);
// Retrieve the effect of autocompleting when there are multiple selections.
int AutoCompGetMulti() const;
// Set the way autocompletion lists are ordered.
void AutoCompSetOrder(int order);
// Get the way autocompletion lists are ordered.
int AutoCompGetOrder() const;
// Enlarge the document to a particular size of text bytes.
void Allocate(int bytes);
// Find the position of a column on a line taking into account tabs and
// multi-byte characters. If beyond end of line, return line end position.
int FindColumn(int line, int column);
// Can the caret preferred x position only be changed by explicit movement commands?
int GetCaretSticky() const;
// Stop the caret preferred x position changing when the user types.
void SetCaretSticky(int useCaretStickyBehaviour);
// Switch between sticky and non-sticky: meant to be bound to a key.
void ToggleCaretSticky();
// Enable/Disable convert-on-paste for line endings
void SetPasteConvertEndings(bool convert);
// Get convert-on-paste setting
bool GetPasteConvertEndings() const;
// Duplicate the selection. If selection empty duplicate the line containing the caret.
void SelectionDuplicate();
// Set background alpha of the caret line.
void SetCaretLineBackAlpha(int alpha);
// Get the background alpha of the caret line.
int GetCaretLineBackAlpha() const;
// Set the style of the caret to be drawn.
void SetCaretStyle(int caretStyle);
// Returns the current style of the caret.
int GetCaretStyle() const;
// Set the indicator used for IndicatorFillRange and IndicatorClearRange
void SetIndicatorCurrent(int indicator);
// Get the current indicator
int GetIndicatorCurrent() const;
// Set the value used for IndicatorFillRange
void SetIndicatorValue(int value);
// Get the current indicator value
int GetIndicatorValue() const;
// Turn a indicator on over a range.
void IndicatorFillRange(int start, int lengthFill);
// Turn a indicator off over a range.
void IndicatorClearRange(int start, int lengthClear);
// Are any indicators present at pos?
int IndicatorAllOnFor(int pos);
// What value does a particular indicator have at a position?
int IndicatorValueAt(int indicator, int pos);
// Where does a particular indicator start?
int IndicatorStart(int indicator, int pos);
// Where does a particular indicator end?
int IndicatorEnd(int indicator, int pos);
// Set number of entries in position cache
void SetPositionCacheSize(int size);
// How many entries are allocated to the position cache?
int GetPositionCacheSize() const;
// Copy the selection, if selection empty copy the line with the caret
void CopyAllowLine();
// Compact the document buffer and return a read-only pointer to the
// characters in the document.
const char* GetCharacterPointer() const;
// Return a read-only pointer to a range of characters in the document.
// May move the gap so that the range is contiguous, but will only move up
// to lengthRange bytes.
const char* GetRangePointer(int position, int rangeLength) const;
// Return a position which, to avoid performance costs, should not be within
// the range of a call to GetRangePointer.
int GetGapPosition() const;
// Set the alpha fill colour of the given indicator.
void IndicatorSetAlpha(int indicator, int alpha);
// Get the alpha fill colour of the given indicator.
int IndicatorGetAlpha(int indicator) const;
// Set the alpha outline colour of the given indicator.
void IndicatorSetOutlineAlpha(int indicator, int alpha);
// Get the alpha outline colour of the given indicator.
int IndicatorGetOutlineAlpha(int indicator) const;
// Set extra ascent for each line
void SetExtraAscent(int extraAscent);
// Get extra ascent for each line
int GetExtraAscent() const;
// Set extra descent for each line
void SetExtraDescent(int extraDescent);
// Get extra descent for each line
int GetExtraDescent() const;
// Which symbol was defined for markerNumber with MarkerDefine
int GetMarkerSymbolDefined(int markerNumber);
// Set the text in the text margin for a line
void MarginSetText(int line, const wxString& text);
// Get the text in the text margin for a line
wxString MarginGetText(int line) const;
// Set the style number for the text margin for a line
void MarginSetStyle(int line, int style);
// Get the style number for the text margin for a line
int MarginGetStyle(int line) const;
// Set the style in the text margin for a line
void MarginSetStyles(int line, const wxString& styles);
// Get the styles in the text margin for a line
wxString MarginGetStyles(int line) const;
// Clear the margin text on all lines
void MarginTextClearAll();
// Get the start of the range of style numbers used for margin text
void MarginSetStyleOffset(int style);
// Get the start of the range of style numbers used for margin text
int MarginGetStyleOffset() const;
// Set the margin options.
void SetMarginOptions(int marginOptions);
// Get the margin options.
int GetMarginOptions() const;
// Set the annotation text for a line
void AnnotationSetText(int line, const wxString& text);
// Get the annotation text for a line
wxString AnnotationGetText(int line) const;
// Set the style number for the annotations for a line
void AnnotationSetStyle(int line, int style);
// Get the style number for the annotations for a line
int AnnotationGetStyle(int line) const;
// Set the annotation styles for a line
void AnnotationSetStyles(int line, const wxString& styles);
// Get the annotation styles for a line
wxString AnnotationGetStyles(int line) const;
// Get the number of annotation lines for a line
int AnnotationGetLines(int line) const;
// Clear the annotations from all lines
void AnnotationClearAll();
// Set the visibility for the annotations for a view
void AnnotationSetVisible(int visible);
// Get the visibility for the annotations for a view
int AnnotationGetVisible() const;
// Get the start of the range of style numbers used for annotations
void AnnotationSetStyleOffset(int style);
// Get the start of the range of style numbers used for annotations
int AnnotationGetStyleOffset() const;
// Release all extended (>255) style numbers
void ReleaseAllExtendedStyles();
// Allocate some extended (>255) style numbers and return the start of the range
int AllocateExtendedStyles(int numberStyles);
// Add a container action to the undo stack
void AddUndoAction(int token, int flags);
// Find the position of a character from a point within the window.
int CharPositionFromPoint(int x, int y);
// Find the position of a character from a point within the window.
// Return wxSTC_INVALID_POSITION if not close to text.
int CharPositionFromPointClose(int x, int y);
// Set whether switching to rectangular mode while selecting with the mouse is allowed.
void SetMouseSelectionRectangularSwitch(bool mouseSelectionRectangularSwitch);
// Whether switching to rectangular mode while selecting with the mouse is allowed.
bool GetMouseSelectionRectangularSwitch() const;
// Set whether multiple selections can be made
void SetMultipleSelection(bool multipleSelection);
// Whether multiple selections can be made
bool GetMultipleSelection() const;
// Set whether typing can be performed into multiple selections
void SetAdditionalSelectionTyping(bool additionalSelectionTyping);
// Whether typing can be performed into multiple selections
bool GetAdditionalSelectionTyping() const;
// Set whether additional carets will blink
void SetAdditionalCaretsBlink(bool additionalCaretsBlink);
// Whether additional carets will blink
bool GetAdditionalCaretsBlink() const;
// Set whether additional carets are visible
void SetAdditionalCaretsVisible(bool additionalCaretsVisible);
// Whether additional carets are visible
bool GetAdditionalCaretsVisible() const;
// How many selections are there?
int GetSelections() const;
// Is every selected range empty?
bool GetSelectionEmpty() const;
// Clear selections to a single empty stream selection
void ClearSelections();
// Add a selection
int AddSelection(int caret, int anchor);
// Drop one selection
void DropSelectionN(int selection);
// Set the main selection
void SetMainSelection(int selection);
// Which selection is the main selection
int GetMainSelection() const;
// Set the caret position of the nth selection.
void SetSelectionNCaret(int selection, int caret);
// Return the caret position of the nth selection.
int GetSelectionNCaret(int selection) const;
// Set the anchor position of the nth selection.
void SetSelectionNAnchor(int selection, int anchor);
// Return the anchor position of the nth selection.
int GetSelectionNAnchor(int selection) const;
// Set the virtual space of the caret of the nth selection.
void SetSelectionNCaretVirtualSpace(int selection, int space);
// Return the virtual space of the caret of the nth selection.
int GetSelectionNCaretVirtualSpace(int selection) const;
// Set the virtual space of the anchor of the nth selection.
void SetSelectionNAnchorVirtualSpace(int selection, int space);
// Return the virtual space of the anchor of the nth selection.
int GetSelectionNAnchorVirtualSpace(int selection) const;
// Sets the position that starts the selection - this becomes the anchor.
void SetSelectionNStart(int selection, int anchor);
// Returns the position at the start of the selection.
int GetSelectionNStart(int selection) const;
// Sets the position that ends the selection - this becomes the currentPosition.
void SetSelectionNEnd(int selection, int caret);
// Returns the position at the end of the selection.
int GetSelectionNEnd(int selection) const;
// Set the caret position of the rectangular selection.
void SetRectangularSelectionCaret(int caret);
// Return the caret position of the rectangular selection.
int GetRectangularSelectionCaret() const;
// Set the anchor position of the rectangular selection.
void SetRectangularSelectionAnchor(int anchor);
// Return the anchor position of the rectangular selection.
int GetRectangularSelectionAnchor() const;
// Set the virtual space of the caret of the rectangular selection.
void SetRectangularSelectionCaretVirtualSpace(int space);
// Return the virtual space of the caret of the rectangular selection.
int GetRectangularSelectionCaretVirtualSpace() const;
// Set the virtual space of the anchor of the rectangular selection.
void SetRectangularSelectionAnchorVirtualSpace(int space);
// Return the virtual space of the anchor of the rectangular selection.
int GetRectangularSelectionAnchorVirtualSpace() const;
// Set options for virtual space behaviour.
void SetVirtualSpaceOptions(int virtualSpaceOptions);
// Return options for virtual space behaviour.
int GetVirtualSpaceOptions() const;
// On GTK+, allow selecting the modifier key to use for mouse-based
// rectangular selection. Often the window manager requires Alt+Mouse Drag
// for moving windows.
// Valid values are wxSTC_KEYMOD_CTRL (default), wxSTC_KEYMOD_ALT, or wxSTC_KEYMOD_SUPER.
void SetRectangularSelectionModifier(int modifier);
// Get the modifier key used for rectangular selection.
int GetRectangularSelectionModifier() const;
// Set the foreground colour of additional selections.
// Must have previously called SetSelFore with non-zero first argument for this to have an effect.
void SetAdditionalSelForeground(const wxColour& fore);
// Set the background colour of additional selections.
// Must have previously called SetSelBack with non-zero first argument for this to have an effect.
void SetAdditionalSelBackground(const wxColour& back);
// Set the alpha of the selection.
void SetAdditionalSelAlpha(int alpha);
// Get the alpha of the selection.
int GetAdditionalSelAlpha() const;
// Set the foreground colour of additional carets.
void SetAdditionalCaretForeground(const wxColour& fore);
// Get the foreground colour of additional carets.
wxColour GetAdditionalCaretForeground() const;
// Set the main selection to the next selection.
void RotateSelection();
// Swap that caret and anchor of the main selection.
void SwapMainAnchorCaret();
// Add the next occurrence of the main selection to the set of selections as main.
// If the current selection is empty then select word around caret.
void MultipleSelectAddNext();
// Add each occurrence of the main selection in the target to the set of selections.
// If the current selection is empty then select word around caret.
void MultipleSelectAddEach();
// Indicate that the internal state of a lexer has changed over a range and therefore
// there may be a need to redraw.
int ChangeLexerState(int start, int end);
// Find the next line at or after lineStart that is a contracted fold header line.
// Return -1 when no more lines.
int ContractedFoldNext(int lineStart);
// Centre current line in window.
void VerticalCentreCaret();
// Move the selected lines up one line, shifting the line above after the selection
void MoveSelectedLinesUp();
// Move the selected lines down one line, shifting the line below before the selection
void MoveSelectedLinesDown();
// Set the identifier reported as idFrom in notification messages.
void SetIdentifier(int identifier);
// Get the identifier.
int GetIdentifier() const;
// Set the width for future RGBA image data.
void RGBAImageSetWidth(int width);
// Set the height for future RGBA image data.
void RGBAImageSetHeight(int height);
// Set the scale factor in percent for future RGBA image data.
void RGBAImageSetScale(int scalePercent);
// Define a marker from RGBA data.
// It has the width and height from RGBAImageSetWidth/Height
void MarkerDefineRGBAImage(int markerNumber, const unsigned char* pixels);
// Register an RGBA image for use in autocompletion lists.
// It has the width and height from RGBAImageSetWidth/Height
void RegisterRGBAImage(int type, const unsigned char* pixels);
// Scroll to start of document.
void ScrollToStart();
// Scroll to end of document.
void ScrollToEnd();
// Set the technology used.
void SetTechnology(int technology);
// Get the tech.
int GetTechnology() const;
// Create an ILoader*.
void* CreateLoader(int bytes) const;
// Move caret to before first visible character on display line.
// If already there move to first character on display line.
void VCHomeDisplay();
// Like VCHomeDisplay but extending selection to new caret position.
void VCHomeDisplayExtend();
// Is the caret line always visible?
bool GetCaretLineVisibleAlways() const;
// Sets the caret line to always visible.
void SetCaretLineVisibleAlways(bool alwaysVisible);
// Set the line end types that the application wants to use. May not be used if incompatible with lexer or encoding.
void SetLineEndTypesAllowed(int lineEndBitSet);
// Get the line end types currently allowed.
int GetLineEndTypesAllowed() const;
// Get the line end types currently recognised. May be a subset of the allowed types due to lexer limitation.
int GetLineEndTypesActive() const;
// Set the way a character is drawn.
void SetRepresentation(const wxString& encodedCharacter, const wxString& representation);
// Set the way a character is drawn.
wxString GetRepresentation(const wxString& encodedCharacter) const;
// Remove a character representation.
void ClearRepresentation(const wxString& encodedCharacter);
// Start notifying the container of all key presses and commands.
void StartRecord();
// Stop notifying the container of all key presses and commands.
void StopRecord();
// Set the lexing language of the document.
void SetLexer(int lexer);
// Retrieve the lexing language of the document.
int GetLexer() const;
// Colourise a segment of the document using the current lexing language.
void Colourise(int start, int end);
// Set up a value that may be used by a lexer for some optional feature.
void SetProperty(const wxString& key, const wxString& value);
// Set up the key words used by the lexer.
void SetKeyWords(int keyWordSet, const wxString& keyWords);
// Set the lexing language of the document based on string name.
void SetLexerLanguage(const wxString& language);
// Load a lexer library (dll / so).
void LoadLexerLibrary(const wxString& path);
// Retrieve a "property" value previously set with SetProperty.
wxString GetProperty(const wxString& key);
// Retrieve a "property" value previously set with SetProperty,
// with "$()" variable replacement on returned buffer.
wxString GetPropertyExpanded(const wxString& key);
// Retrieve a "property" value previously set with SetProperty,
// interpreted as an int AFTER any "$()" variable replacement.
int GetPropertyInt(const wxString &key, int defaultValue=0) const;
// Retrieve the number of bits the current lexer needs for styling.
wxDEPRECATED_MSG( "This method uses a function deprecated in the Scintilla library." )
int GetStyleBitsNeeded() const;
// Retrieve the lexing language of the document.
wxString GetLexerLanguage() const;
// For private communication between an application and a known lexer.
void* PrivateLexerCall(int operation, void* pointer);
// Retrieve a '\\n' separated list of properties understood by the current lexer.
wxString PropertyNames() const;
// Retrieve the type of a property.
int PropertyType(const wxString& name);
// Describe a property.
wxString DescribeProperty(const wxString& name) const;
// Retrieve a '\\n' separated list of descriptions of the keyword sets understood by the current lexer.
wxString DescribeKeyWordSets() const;
// Bit set of LineEndType enumertion for which line ends beyond the standard
// LF, CR, and CRLF are supported by the lexer.
int GetLineEndTypesSupported() const;
// Allocate a set of sub styles for a particular base style, returning start of range
int AllocateSubStyles(int styleBase, int numberStyles);
// The starting style number for the sub styles associated with a base style
int GetSubStylesStart(int styleBase) const;
// The number of sub styles associated with a base style
int GetSubStylesLength(int styleBase) const;
// For a sub style, return the base style, else return the argument.
int GetStyleFromSubStyle(int subStyle) const;
// For a secondary style, return the primary style, else return the argument.
int GetPrimaryStyleFromStyle(int style) const;
// Free allocated sub styles
void FreeSubStyles();
// Set the identifiers that are shown in a particular style
void SetIdentifiers(int style, const wxString& identifiers);
// Where styles are duplicated by a feature such as active/inactive code
// return the distance between the two types.
int DistanceToSecondaryStyles() const;
// Get the set of base styles that can be extended with sub styles
wxString GetSubStyleBases() const;
//}}}
//----------------------------------------------------------------------
// Manually declared methods
// Returns the line number of the line with the caret.
int GetCurrentLine();
// Extract style settings from a spec-string which is composed of one or
// more of the following comma separated elements:
//
// bold turns on bold
// italic turns on italics
// fore:[name or #RRGGBB] sets the foreground colour
// back:[name or #RRGGBB] sets the background colour
// face:[facename] sets the font face name to use
// size:[num] sets the font size in points
// eol turns on eol filling
// underline turns on underlining
//
void StyleSetSpec(int styleNum, const wxString& spec);
// Get the font of a style.
wxFont StyleGetFont(int style);
// Set style size, face, bold, italic, and underline attributes from
// a wxFont's attributes.
void StyleSetFont(int styleNum, const wxFont& font);
// Set all font style attributes at once.
void StyleSetFontAttr(int styleNum, int size,
const wxString& faceName,
bool bold, bool italic,
bool underline,
wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
// Set the font encoding to be used by a style.
void StyleSetFontEncoding(int style, wxFontEncoding encoding);
// Perform one of the operations defined by the wxSTC_CMD_* constants.
void CmdKeyExecute(int cmd);
// Set the left and right margin in the edit area, measured in pixels.
void SetMargins(int left, int right);
// Scroll enough to make the given line visible
void ScrollToLine(int line);
// Scroll enough to make the given column visible
void ScrollToColumn(int column);
// Send a message to Scintilla
//
// NB: this method is not really const as it can modify the control but it
// has to be declared as such as it's called from both const and
// non-const methods and we can't distinguish between the two
wxIntPtr SendMsg(int msg, wxUIntPtr wp=0, wxIntPtr lp=0) const;
// Set the vertical scrollbar to use instead of the one that's built-in.
void SetVScrollBar(wxScrollBar* bar);
// Set the horizontal scrollbar to use instead of the one that's built-in.
void SetHScrollBar(wxScrollBar* bar);
// Can be used to prevent the EVT_CHAR handler from adding the char
bool GetLastKeydownProcessed() { return m_lastKeyDownConsumed; }
void SetLastKeydownProcessed(bool val) { m_lastKeyDownConsumed = val; }
// if we derive from wxTextAreaBase it already provides these methods
#if !wxUSE_TEXTCTRL
// Write the contents of the editor to filename
bool SaveFile(const wxString& filename);
// Load the contents of filename into the editor
bool LoadFile(const wxString& filename);
#endif // !wxUSE_TEXTCTRL
#ifdef STC_USE_DND
// Allow for simulating a DnD DragEnter
wxDragResult DoDragEnter(wxCoord x, wxCoord y, wxDragResult def);
// Allow for simulating a DnD DragOver
wxDragResult DoDragOver(wxCoord x, wxCoord y, wxDragResult def);
// Allow for simulating a DnD DragLeave
void DoDragLeave();
// Allow for simulating a DnD DropText
bool DoDropText(long x, long y, const wxString& data);
#endif
// Specify whether anti-aliased fonts should be used. Will have no effect
// on some platforms, but on some (wxMac for example) can greatly improve
// performance.
void SetUseAntiAliasing(bool useAA);
// Returns the current UseAntiAliasing setting.
bool GetUseAntiAliasing();
// Clear annotations from the given line.
void AnnotationClearLine(int line);
// The following methods are nearly equivalent to their similarly named
// cousins above. The difference is that these methods bypass wxString
// and always use a char* even if used in a unicode build of wxWidgets.
// In that case the character data will be utf-8 encoded since that is
// what is used internally by Scintilla in unicode builds.
// Add text to the document at current position.
void AddTextRaw(const char* text, int length=-1);
// Insert string at a position.
void InsertTextRaw(int pos, const char* text);
// Retrieve the text of the line containing the caret.
// Returns the index of the caret on the line.
#ifdef SWIG
wxCharBuffer GetCurLineRaw(int* OUTPUT);
#else
wxCharBuffer GetCurLineRaw(int* linePos=NULL);
#endif
// Retrieve the contents of a line.
wxCharBuffer GetLineRaw(int line);
// Retrieve the selected text.
wxCharBuffer GetSelectedTextRaw();
// Retrieve the target text.
wxCharBuffer GetTargetTextRaw();
// Retrieve a range of text.
wxCharBuffer GetTextRangeRaw(int startPos, int endPos);
// Replace the contents of the document with the argument text.
void SetTextRaw(const char* text);
// Retrieve all the text in the document.
wxCharBuffer GetTextRaw();
// Append a string to the end of the document without changing the selection.
void AppendTextRaw(const char* text, int length=-1);
#ifdef SWIG
%pythoncode "_stc_utf8_methods.py"
#endif
// implement wxTextEntryBase pure virtual methods
// ----------------------------------------------
virtual void WriteText(const wxString& text) wxOVERRIDE
{
ReplaceSelection(text);
}
virtual void Remove(long from, long to) wxOVERRIDE
{
Replace(from, to, wxString());
}
virtual void Replace(long from, long to, const wxString& text) wxOVERRIDE
{
SetTargetStart((int)from);
SetTargetEnd((int)to);
ReplaceTarget(text);
}
/*
These functions are already declared in the generated section.
virtual void Copy();
virtual void Cut();
virtual void Paste();
virtual void Undo();
virtual void Redo();
virtual bool CanUndo() const;
virtual bool CanRedo() const;
*/
virtual void SetInsertionPoint(long pos) wxOVERRIDE
{
SetCurrentPos(int(pos == -1 ? GetLastPosition() : pos));
}
virtual long GetInsertionPoint() const wxOVERRIDE { return GetCurrentPos(); }
virtual long GetLastPosition() const wxOVERRIDE { return GetTextLength(); }
virtual void SetSelection(long from, long to) wxOVERRIDE
{
if ( from == -1 && to == -1 )
{
SelectAll();
}
else
{
SetSelectionStart((int)from);
SetSelectionEnd((int)to);
}
}
virtual void SelectNone() wxOVERRIDE
{
ClearSelections();
}
#ifdef SWIG
void GetSelection(long* OUTPUT, long* OUTPUT) const;
#else
virtual void GetSelection(long *from, long *to) const wxOVERRIDE
{
if ( from )
*from = GetSelectionStart();
if ( to )
*to = GetSelectionEnd();
}
// kept for compatibility only
void GetSelection(int *from, int *to)
{
long f, t;
GetSelection(&f, &t);
if ( from )
*from = (int)f;
if ( to )
*to = (int)t;
}
#endif
virtual bool IsEditable() const wxOVERRIDE { return !GetReadOnly(); }
virtual void SetEditable(bool editable) wxOVERRIDE { SetReadOnly(!editable); }
// implement wxTextAreaBase pure virtual methods
// ---------------------------------------------
virtual int GetLineLength(long lineNo) const wxOVERRIDE { return static_cast<int>(GetLineText(lineNo).length()); }
virtual wxString GetLineText(long lineNo) const wxOVERRIDE
{
wxString text = GetLine(static_cast<int>(lineNo));
size_t lastNewLine = text.find_last_not_of(wxS("\r\n"));
if ( lastNewLine != wxString::npos )
text.erase(lastNewLine + 1); // remove trailing cr+lf
else
text.clear();
return text;
}
virtual int GetNumberOfLines() const wxOVERRIDE { return GetLineCount(); }
virtual bool IsModified() const wxOVERRIDE { return GetModify(); }
virtual void MarkDirty() wxOVERRIDE { wxFAIL_MSG("not implemented"); }
virtual void DiscardEdits() wxOVERRIDE { SetSavePoint(); }
virtual bool SetStyle(long WXUNUSED(start), long WXUNUSED(end),
const wxTextAttr& WXUNUSED(style)) wxOVERRIDE
{
wxFAIL_MSG("not implemented");
return false;
}
virtual bool GetStyle(long WXUNUSED(position), wxTextAttr& WXUNUSED(style)) wxOVERRIDE
{
wxFAIL_MSG("not implemented");
return false;
}
virtual bool SetDefaultStyle(const wxTextAttr& WXUNUSED(style)) wxOVERRIDE
{
wxFAIL_MSG("not implemented");
return false;
}
virtual long XYToPosition(long x, long y) const wxOVERRIDE
{
long pos = PositionFromLine((int)y);
pos += x;
return pos;
}
virtual bool PositionToXY(long pos, long *x, long *y) const wxOVERRIDE
{
int l = LineFromPosition((int)pos);
if ( l == -1 )
return false;
if ( x )
*x = pos - PositionFromLine(l);
if ( y )
*y = l;
return true;
}
virtual void ShowPosition(long pos) wxOVERRIDE { GotoPos((int)pos); }
using wxWindow::HitTest;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const wxOVERRIDE
{
const long l = PositionFromPoint(pt);
if ( l == -1 )
return wxTE_HT_BELOW; // we don't really know where it was
if ( pos )
*pos = l;
return wxTE_HT_ON_TEXT;
}
// just unhide it
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
wxTextCoord *col,
wxTextCoord *row) const wxOVERRIDE
{
return wxTextAreaBase::HitTest(pt, col, row);
}
// methods deprecated due to changes in the scintilla library
// ---------------------------------------------
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_MSG("use UsePopUp(int) instead.")
void UsePopUp(bool allowPopUp);
wxDEPRECATED_MSG("use StartStyling(int start) instead.")
void StartStyling(int start, int unused);
#endif // WXWIN_COMPATIBILITY_3_0
static wxVersionInfo GetLibraryVersionInfo();
protected:
virtual void DoSetValue(const wxString& value, int flags) wxOVERRIDE;
virtual wxString DoGetValue() const wxOVERRIDE { return GetText(); }
virtual wxWindow *GetEditableWindow() wxOVERRIDE { return this; }
#ifndef SWIG
virtual bool DoLoadFile(const wxString& file, int fileType) wxOVERRIDE;
virtual bool DoSaveFile(const wxString& file, int fileType) wxOVERRIDE;
// Event handlers
void OnPaint(wxPaintEvent& evt);
void OnScrollWin(wxScrollWinEvent& evt);
void OnScroll(wxScrollEvent& evt);
void OnSize(wxSizeEvent& evt);
void OnMouseLeftDown(wxMouseEvent& evt);
void OnMouseRightDown(wxMouseEvent& evt);
void OnMouseMove(wxMouseEvent& evt);
void OnMouseLeftUp(wxMouseEvent& evt);
void OnMouseMiddleUp(wxMouseEvent& evt);
void OnContextMenu(wxContextMenuEvent& evt);
void OnMouseWheel(wxMouseEvent& evt);
void OnChar(wxKeyEvent& evt);
void OnKeyDown(wxKeyEvent& evt);
void OnLoseFocus(wxFocusEvent& evt);
void OnGainFocus(wxFocusEvent& evt);
void OnSysColourChanged(wxSysColourChangedEvent& evt);
void OnEraseBackground(wxEraseEvent& evt);
void OnMenu(wxCommandEvent& evt);
void OnListBox(wxCommandEvent& evt);
void OnIdle(wxIdleEvent& evt);
void OnMouseCaptureLost(wxMouseCaptureLostEvent& evt);
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// Turn notifications from Scintilla into events
void NotifyChange();
void NotifyParent(SCNotification* scn);
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxStyledTextCtrl);
protected:
ScintillaWX* m_swx;
wxStopWatch m_stopWatch;
wxScrollBar* m_vScrollBar;
wxScrollBar* m_hScrollBar;
bool m_lastKeyDownConsumed;
friend class ScintillaWX;
friend class Platform;
#endif // !SWIG
};
//----------------------------------------------------------------------
class WXDLLIMPEXP_STC wxStyledTextEvent : public wxCommandEvent {
public:
wxStyledTextEvent(wxEventType commandType=0, int id=0);
#ifndef SWIG
wxStyledTextEvent(const wxStyledTextEvent& event);
#endif
~wxStyledTextEvent() {}
void SetPosition(int pos) { m_position = pos; }
void SetKey(int k) { m_key = k; }
void SetModifiers(int m) { m_modifiers = m; }
void SetModificationType(int t) { m_modificationType = t; }
// Kept for backwards compatibility, use SetString().
void SetText(const wxString& t) { SetString(t); }
void SetLength(int len) { m_length = len; }
void SetLinesAdded(int num) { m_linesAdded = num; }
void SetLine(int val) { m_line = val; }
void SetFoldLevelNow(int val) { m_foldLevelNow = val; }
void SetFoldLevelPrev(int val) { m_foldLevelPrev = val; }
void SetMargin(int val) { m_margin = val; }
void SetMessage(int val) { m_message = val; }
void SetWParam(int val) { m_wParam = val; }
void SetLParam(int val) { m_lParam = val; }
void SetListType(int val) { m_listType = val; }
void SetX(int val) { m_x = val; }
void SetY(int val) { m_y = val; }
void SetToken(int val) { m_token = val; }
void SetAnnotationLinesAdded(int val) { m_annotationLinesAdded = val; }
void SetUpdated(int val) { m_updated = val; }
void SetListCompletionMethod(int val) { m_listCompletionMethod = val; }
#ifdef STC_USE_DND
// Kept for backwards compatibility, use SetString().
void SetDragText(const wxString& val) { SetString(val); }
void SetDragFlags(int flags) { m_dragFlags = flags; }
void SetDragResult(wxDragResult val) { m_dragResult = val; }
// This method is kept mainly for backwards compatibility, use
// SetDragFlags() in the new code.
void SetDragAllowMove(bool allow)
{
if ( allow )
m_dragFlags |= wxDrag_AllowMove;
else
m_dragFlags &= ~(wxDrag_AllowMove | wxDrag_DefaultMove);
}
#endif
int GetPosition() const { return m_position; }
int GetKey() const { return m_key; }
int GetModifiers() const { return m_modifiers; }
int GetModificationType() const { return m_modificationType; }
// Kept for backwards compatibility, use GetString().
wxString GetText() const { return GetString(); }
int GetLength() const { return m_length; }
int GetLinesAdded() const { return m_linesAdded; }
int GetLine() const { return m_line; }
int GetFoldLevelNow() const { return m_foldLevelNow; }
int GetFoldLevelPrev() const { return m_foldLevelPrev; }
int GetMargin() const { return m_margin; }
int GetMessage() const { return m_message; }
int GetWParam() const { return m_wParam; }
int GetLParam() const { return m_lParam; }
int GetListType() const { return m_listType; }
int GetX() const { return m_x; }
int GetY() const { return m_y; }
int GetToken() const { return m_token; }
int GetAnnotationsLinesAdded() const { return m_annotationLinesAdded; }
int GetUpdated() const { return m_updated; }
int GetListCompletionMethod() const { return m_listCompletionMethod; }
#ifdef STC_USE_DND
// Kept for backwards compatibility, use GetString().
wxString GetDragText() { return GetString(); }
int GetDragFlags() { return m_dragFlags; }
wxDragResult GetDragResult() { return m_dragResult; }
bool GetDragAllowMove() { return (GetDragFlags() & wxDrag_AllowMove) != 0; }
#endif
bool GetShift() const;
bool GetControl() const;
bool GetAlt() const;
virtual wxEvent* Clone() const wxOVERRIDE { return new wxStyledTextEvent(*this); }
#ifndef SWIG
private:
wxDECLARE_DYNAMIC_CLASS(wxStyledTextEvent);
int m_position;
int m_key;
int m_modifiers;
int m_modificationType; // wxEVT_STC_MODIFIED
int m_length;
int m_linesAdded;
int m_line;
int m_foldLevelNow;
int m_foldLevelPrev;
int m_margin; // wxEVT_STC_MARGINCLICK
int m_message; // wxEVT_STC_MACRORECORD
int m_wParam;
int m_lParam;
int m_listType;
int m_x;
int m_y;
int m_token; // wxEVT_STC__MODIFIED with SC_MOD_CONTAINER
int m_annotationLinesAdded; // wxEVT_STC_MODIFIED with SC_MOD_CHANGEANNOTATION
int m_updated; // wxEVT_STC_UPDATEUI
int m_listCompletionMethod;
#if wxUSE_DRAG_AND_DROP
int m_dragFlags; // wxEVT_STC_START_DRAG
wxDragResult m_dragResult; // wxEVT_STC_DRAG_OVER,wxEVT_STC_DO_DROP
#endif
#endif
};
#ifndef SWIG
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_CHANGE, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_STYLENEEDED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_CHARADDED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_SAVEPOINTREACHED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_SAVEPOINTLEFT, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_ROMODIFYATTEMPT, wxStyledTextEvent );
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_MSG( "Don't handle wxEVT_STC_KEY. It's never generated." ) \
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_KEY, wxStyledTextEvent );
#endif // WXWIN_COMPATIBILITY_3_0
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_DOUBLECLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_UPDATEUI, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_MODIFIED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_MACRORECORD, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_MARGINCLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_NEEDSHOWN, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_PAINTED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_USERLISTSELECTION, wxStyledTextEvent );
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_MSG( "Don't handle wxEVT_STC_URIDROPPED. It's never generated." ) \
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_URIDROPPED, wxStyledTextEvent );
#endif // WXWIN_COMPATIBILITY_3_0
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_DWELLSTART, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_DWELLEND, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_START_DRAG, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_DRAG_OVER, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_DO_DROP, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_ZOOM, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_HOTSPOT_CLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_HOTSPOT_DCLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_CALLTIP_CLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_AUTOCOMP_SELECTION, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_INDICATOR_CLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_INDICATOR_RELEASE, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_AUTOCOMP_CANCELLED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_AUTOCOMP_CHAR_DELETED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_HOTSPOT_RELEASE_CLICK, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_CLIPBOARD_COPY, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_CLIPBOARD_PASTE, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_AUTOCOMP_COMPLETED, wxStyledTextEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_STC, wxEVT_STC_MARGIN_RIGHT_CLICK, wxStyledTextEvent );
#else
enum {
wxEVT_STC_CHANGE,
wxEVT_STC_STYLENEEDED,
wxEVT_STC_CHARADDED,
wxEVT_STC_SAVEPOINTREACHED,
wxEVT_STC_SAVEPOINTLEFT,
wxEVT_STC_ROMODIFYATTEMPT,
#if WXWIN_COMPATIBILITY_3_0
wxEVT_STC_KEY, // deprecated
#endif // WXWIN_COMPATIBILITY_3_0
wxEVT_STC_DOUBLECLICK,
wxEVT_STC_UPDATEUI,
wxEVT_STC_MODIFIED,
wxEVT_STC_MACRORECORD,
wxEVT_STC_MARGINCLICK,
wxEVT_STC_NEEDSHOWN,
wxEVT_STC_PAINTED,
wxEVT_STC_USERLISTSELECTION,
#if WXWIN_COMPATIBILITY_3_0
wxEVT_STC_URIDROPPED, // deprecated
#endif // WXWIN_COMPATIBILITY_3_0
wxEVT_STC_DWELLSTART,
wxEVT_STC_DWELLEND,
wxEVT_STC_START_DRAG,
wxEVT_STC_DRAG_OVER,
wxEVT_STC_DO_DROP,
wxEVT_STC_ZOOM,
wxEVT_STC_HOTSPOT_CLICK,
wxEVT_STC_HOTSPOT_DCLICK,
wxEVT_STC_CALLTIP_CLICK,
wxEVT_STC_AUTOCOMP_SELECTION,
wxEVT_STC_INDICATOR_CLICK,
wxEVT_STC_INDICATOR_RELEASE,
wxEVT_STC_AUTOCOMP_CANCELLED,
wxEVT_STC_AUTOCOMP_CHAR_DELETED,
wxEVT_STC_HOTSPOT_RELEASE_CLICK,
wxEVT_STC_CLIPBOARD_COPY,
wxEVT_STC_CLIPBOARD_PASTE,
wxEVT_STC_AUTOCOMP_COMPLETED,
wxEVT_STC_MARGIN_RIGHT_CLICK
};
#endif
#ifndef SWIG
typedef void (wxEvtHandler::*wxStyledTextEventFunction)(wxStyledTextEvent&);
#define wxStyledTextEventHandler( func ) \
wxEVENT_HANDLER_CAST( wxStyledTextEventFunction, func )
#define EVT_STC_CHANGE(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CHANGE, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_STYLENEEDED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_STYLENEEDED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_CHARADDED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CHARADDED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_SAVEPOINTREACHED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_SAVEPOINTREACHED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_SAVEPOINTLEFT(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_SAVEPOINTLEFT, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_ROMODIFYATTEMPT(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_ROMODIFYATTEMPT, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_KEY(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_KEY, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DOUBLECLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DOUBLECLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_UPDATEUI(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_UPDATEUI, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_MODIFIED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MODIFIED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_MACRORECORD(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MACRORECORD, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_MARGINCLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MARGINCLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_NEEDSHOWN(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_NEEDSHOWN, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_PAINTED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_PAINTED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_USERLISTSELECTION(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_USERLISTSELECTION, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_URIDROPPED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_URIDROPPED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DWELLSTART(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DWELLSTART, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DWELLEND(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DWELLEND, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_START_DRAG(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_START_DRAG, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DRAG_OVER(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DRAG_OVER, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_DO_DROP(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DO_DROP, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_ZOOM(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_ZOOM, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_HOTSPOT_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_HOTSPOT_CLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_HOTSPOT_DCLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_HOTSPOT_DCLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_CALLTIP_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CALLTIP_CLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_AUTOCOMP_SELECTION(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_AUTOCOMP_SELECTION, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_INDICATOR_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_INDICATOR_CLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_INDICATOR_RELEASE(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_INDICATOR_RELEASE, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_AUTOCOMP_CANCELLED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_AUTOCOMP_CANCELLED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_AUTOCOMP_CHAR_DELETED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_AUTOCOMP_CHAR_DELETED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_HOTSPOT_RELEASE_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_HOTSPOT_RELEASE_CLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_CLIPBOARD_COPY(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CLIPBOARD_COPY, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_CLIPBOARD_PASTE(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CLIPBOARD_PASTE, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_AUTOCOMP_COMPLETED(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_AUTOCOMP_COMPLETED, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#define EVT_STC_MARGIN_RIGHT_CLICK(id, fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MARGIN_RIGHT_CLICK, id, wxID_ANY, wxStyledTextEventHandler( fn ), (wxObject *) NULL ),
#endif
#endif // wxUSE_STC
#endif // _WX_STC_STC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/lib/vc_dll/mswu/wx/setup.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/setup.h
// Purpose: Configuration for the library
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
/* --- start common options --- */
// ----------------------------------------------------------------------------
// global settings
// ----------------------------------------------------------------------------
// define this to 0 when building wxBase library - this can also be done from
// makefile/project file overriding the value here
#ifndef wxUSE_GUI
#define wxUSE_GUI 1
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// compatibility settings
// ----------------------------------------------------------------------------
// This setting determines the compatibility with 2.8 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_2_8 0
// This setting determines the compatibility with 3.0 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_3_0 1
// MSW-only: Set to 0 for accurate dialog units, else 1 for old behaviour when
// default system font is used for wxWindow::GetCharWidth/Height() instead of
// the current font.
//
// Default is 0
//
// Recommended setting: 0
#define wxDIALOG_UNIT_COMPATIBILITY 0
// Provide unsafe implicit conversions in wxString to "const char*" or
// "std::string" (depending on wxUSE_STD_STRING_CONV_IN_WXSTRING value).
//
// Default is 1 but only for compatibility reasons, it is recommended to set
// this to 0 because converting wxString to a narrow (non-Unicode) string may
// fail unless a locale using UTF-8 encoding is used, which is never the case
// under MSW, for example, hence such conversions can result in silent data
// loss.
//
// Recommended setting: 0
#define wxUSE_UNSAFE_WXSTRING_CONV 1
// If set to 1, enables "reproducible builds", i.e. build output should be
// exactly the same if the same build is redone again. As using __DATE__ and
// __TIME__ macros clearly makes the build irreproducible, setting this option
// to 1 disables their use in the library code.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_REPRODUCIBLE_BUILD 0
// ----------------------------------------------------------------------------
// debugging settings
// ----------------------------------------------------------------------------
// wxDEBUG_LEVEL will be defined as 1 in wx/debug.h so normally there is no
// need to define it here. You may do it for two reasons: either completely
// disable/compile out the asserts in release version (then do it inside #ifdef
// NDEBUG) or, on the contrary, enable more asserts, including the usually
// disabled ones, in the debug build (then do it inside #ifndef NDEBUG)
//
// #ifdef NDEBUG
// #define wxDEBUG_LEVEL 0
// #else
// #define wxDEBUG_LEVEL 2
// #endif
// wxHandleFatalExceptions() may be used to catch the program faults at run
// time and, instead of terminating the program with a usual GPF message box,
// call the user-defined wxApp::OnFatalException() function. If you set
// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
//
// This setting is for Win32 only and can only be enabled if your compiler
// supports Win32 structured exception handling (currently only VC++ does)
//
// Default is 1
//
// Recommended setting: 1 if your compiler supports it.
#define wxUSE_ON_FATAL_EXCEPTION 1
// Set this to 1 to be able to generate a human-readable (unlike
// machine-readable minidump created by wxCrashReport::Generate()) stack back
// trace when your program crashes using wxStackWalker
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_STACKWALKER 1
// Set this to 1 to compile in wxDebugReport class which allows you to create
// and optionally upload to your web site a debug report consisting of back
// trace of the crash (if wxUSE_STACKWALKER == 1) and other information.
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, it is compiled into a separate library so there
// is no overhead if you don't use it
#define wxUSE_DEBUGREPORT 1
// Generic comment about debugging settings: they are very useful if you don't
// use any other memory leak detection tools such as Purify/BoundsChecker, but
// are probably redundant otherwise. Also, Visual C++ CRT has the same features
// as wxWidgets memory debugging subsystem built in since version 5.0 and you
// may prefer to use it instead of built in memory debugging code because it is
// faster and more fool proof.
//
// Using VC++ CRT memory debugging is enabled by default in debug build (_DEBUG
// is defined) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
// and if __NO_VC_CRTDBG__ is not defined.
// The rest of the options in this section are obsolete and not supported,
// enable them at your own risk.
// If 1, enables wxDebugContext, for writing error messages to file, etc. If
// __WXDEBUG__ is not defined, will still use the normal memory operators.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_CONTEXT 0
// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
// __WXDEBUG__ is also defined.
//
// WARNING: this code may not work with all architectures, especially if
// alignment is an issue. This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 1 if you are not using a memory debugging tool, else 0
#define wxUSE_MEMORY_TRACING 0
// In debug mode, cause new and delete to be redefined globally.
// If this causes problems (e.g. link errors which is a common problem
// especially if you use another library which also redefines the global new
// and delete), set this to 0.
// This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
// this causes problems (e.g. link errors), set this to 0. You may need to set
// this to 0 if using templates (at least for VC++). This switch is currently
// ignored for MinGW/Cygwin.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_NEW_ALWAYS 0
// ----------------------------------------------------------------------------
// Unicode support
// ----------------------------------------------------------------------------
// These settings are obsolete: the library is always built in Unicode mode
// now, only set wxUSE_UNICODE to 0 to compile legacy code in ANSI mode if
// absolutely necessary -- updating it is strongly recommended as the ANSI mode
// will disappear completely in future wxWidgets releases.
#ifndef wxUSE_UNICODE
#define wxUSE_UNICODE 1
#endif
// wxUSE_WCHAR_T is required by wxWidgets now, don't change.
#define wxUSE_WCHAR_T 1
// ----------------------------------------------------------------------------
// global features
// ----------------------------------------------------------------------------
// Compile library in exception-safe mode? If set to 1, the library will try to
// behave correctly in presence of exceptions (even though it still will not
// use the exceptions itself) and notify the user code about any unhandled
// exceptions. If set to 0, propagation of the exceptions through the library
// code will lead to undefined behaviour -- but the code itself will be
// slightly smaller and faster.
//
// Note that like wxUSE_THREADS this option is automatically set to 0 if
// wxNO_EXCEPTIONS is defined.
//
// Default is 1
//
// Recommended setting: depends on whether you intend to use C++ exceptions
// in your own code (1 if you do, 0 if you don't)
#define wxUSE_EXCEPTIONS 1
// Set wxUSE_EXTENDED_RTTI to 1 to use extended RTTI
//
// Default is 0
//
// Recommended setting: 0 (this is still work in progress...)
#define wxUSE_EXTENDED_RTTI 0
// Support for message/error logging. This includes wxLogXXX() functions and
// wxLog and derived classes. Don't set this to 0 unless you really know what
// you are doing.
//
// Default is 1
//
// Recommended setting: 1 (always)
#define wxUSE_LOG 1
// Recommended setting: 1
#define wxUSE_LOGWINDOW 1
// Recommended setting: 1
#define wxUSE_LOGGUI 1
// Recommended setting: 1
#define wxUSE_LOG_DIALOG 1
// Support for command line parsing using wxCmdLineParser class.
//
// Default is 1
//
// Recommended setting: 1 (can be set to 0 if you don't use the cmd line)
#define wxUSE_CMDLINE_PARSER 1
// Support for multithreaded applications: if 1, compile in thread classes
// (thread.h) and make the library a bit more thread safe. Although thread
// support is quite stable by now, you may still consider recompiling the
// library without it if you have no use for it - this will result in a
// somewhat smaller and faster operation.
//
// Notice that if wxNO_THREADS is defined, wxUSE_THREADS is automatically reset
// to 0 in wx/chkconf.h, so, for example, if you set USE_THREADS to 0 in
// build/msw/config.* file this value will have no effect.
//
// Default is 1
//
// Recommended setting: 0 unless you do plan to develop MT applications
#define wxUSE_THREADS 1
// If enabled, compiles wxWidgets streams classes
//
// wx stream classes are used for image IO, process IO redirection, network
// protocols implementation and much more and so disabling this results in a
// lot of other functionality being lost.
//
// Default is 1
//
// Recommended setting: 1 as setting it to 0 disables many other things
#define wxUSE_STREAMS 1
// Support for positional parameters (e.g. %1$d, %2$s ...) in wxVsnprintf.
// Note that if the system's implementation does not support positional
// parameters, setting this to 1 forces the use of the wxWidgets implementation
// of wxVsnprintf. The standard vsnprintf() supports positional parameters on
// many Unix systems but usually doesn't under Windows.
//
// Positional parameters are very useful when translating a program since using
// them in formatting strings allow translators to correctly reorder the
// translated sentences.
//
// Default is 1
//
// Recommended setting: 1 if you want to support multiple languages
#define wxUSE_PRINTF_POS_PARAMS 1
// Enable the use of compiler-specific thread local storage keyword, if any.
// This is used for wxTLS_XXX() macros implementation and normally should use
// the compiler-provided support as it's simpler and more efficient, but is
// disabled under Windows in wx/msw/chkconf.h as it can't be used if wxWidgets
// is used in a dynamically loaded Win32 DLL (i.e. using LoadLibrary()) under
// XP as this triggers a bug in compiler TLS support that results in crashes
// when any TLS variables are used.
//
// If you're absolutely sure that your build of wxWidgets is never going to be
// used in such situation, either because it's not going to be linked from any
// kind of plugin or because you only target Vista or later systems, you can
// set this to 2 to force the use of compiler TLS even under MSW.
//
// Default is 1 meaning that compiler TLS is used only if it's 100% safe.
//
// Recommended setting: 2 if you want to have maximal performance and don't
// care about the scenario described above.
#define wxUSE_COMPILER_TLS 1
// ----------------------------------------------------------------------------
// Interoperability with the standard library.
// ----------------------------------------------------------------------------
// Set wxUSE_STL to 1 to enable maximal interoperability with the standard
// library, even at the cost of backwards compatibility.
//
// Default is 0
//
// Recommended setting: 0 as the options below already provide a relatively
// good level of interoperability and changing this option arguably isn't worth
// diverging from the official builds of the library.
#define wxUSE_STL 0
// This is not a real option but is used as the default value for
// wxUSE_STD_IOSTREAM, wxUSE_STD_STRING and wxUSE_STD_CONTAINERS_COMPATIBLY.
//
// Set it to 0 if you want to disable the use of all standard classes
// completely for some reason.
#define wxUSE_STD_DEFAULT 1
// Use standard C++ containers where it can be done without breaking backwards
// compatibility.
//
// This provides better interoperability with the standard library, e.g. with
// this option on it's possible to insert std::vector<> into many wxWidgets
// containers directly.
//
// Default is 1.
//
// Recommended setting is 1 unless you want to avoid all dependencies on the
// standard library.
#define wxUSE_STD_CONTAINERS_COMPATIBLY wxUSE_STD_DEFAULT
// Use standard C++ containers to implement wxVector<>, wxStack<>, wxDList<>
// and wxHashXXX<> classes. If disabled, wxWidgets own (mostly compatible but
// usually more limited) implementations are used which allows to avoid the
// dependency on the C++ run-time library.
//
// Default is 0 for compatibility reasons.
//
// Recommended setting: 1 unless compatibility with the official wxWidgets
// build and/or the existing code is a concern.
#define wxUSE_STD_CONTAINERS 0
// Use standard C++ streams if 1 instead of wx streams in some places. If
// disabled, wx streams are used everywhere and wxWidgets doesn't depend on the
// standard streams library.
//
// Notice that enabling this does not replace wx streams with std streams
// everywhere, in a lot of places wx streams are used no matter what.
//
// Default is 1 if compiler supports it.
//
// Recommended setting: 1 if you use the standard streams anyhow and so
// dependency on the standard streams library is not a
// problem
#define wxUSE_STD_IOSTREAM wxUSE_STD_DEFAULT
// Enable minimal interoperability with the standard C++ string class if 1.
// "Minimal" means that wxString can be constructed from std::string or
// std::wstring but can't be implicitly converted to them. You need to enable
// the option below for the latter.
//
// Default is 1 for most compilers.
//
// Recommended setting: 1 unless you want to ensure your program doesn't use
// the standard C++ library at all.
#define wxUSE_STD_STRING wxUSE_STD_DEFAULT
// Make wxString as much interchangeable with std::[w]string as possible, in
// particular allow implicit conversion of wxString to either of these classes.
// This comes at a price (or a benefit, depending on your point of view) of not
// allowing implicit conversion to "const char *" and "const wchar_t *".
//
// Because a lot of existing code relies on these conversions, this option is
// disabled by default but can be enabled for your build if you don't care
// about compatibility.
//
// Default is 0 if wxUSE_STL has its default value or 1 if it is enabled.
//
// Recommended setting: 0 to remain compatible with the official builds of
// wxWidgets.
#define wxUSE_STD_STRING_CONV_IN_WXSTRING wxUSE_STL
// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
// them. Set this option to 1 to use <iostream.h>, 0 to use <iostream>.
//
// Note that newer compilers (including VC++ 7.1 and later) don't support
// wxUSE_IOSTREAMH == 1 and so <iostream> will be used anyhow.
//
// Default is 0.
//
// Recommended setting: 0, only set to 1 if you use a really old compiler
#define wxUSE_IOSTREAMH 0
// ----------------------------------------------------------------------------
// non GUI features selection
// ----------------------------------------------------------------------------
// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
// integer which is implemented in terms of native 64 bit integers if any or
// uses emulation otherwise.
//
// This class is required by wxDateTime and so you should enable it if you want
// to use wxDateTime. For most modern platforms, it will use the native 64 bit
// integers in which case (almost) all of its functions are inline and it
// almost does not take any space, so there should be no reason to switch it
// off.
//
// Recommended setting: 1
#define wxUSE_LONGLONG 1
// Set wxUSE_BASE64 to 1, to compile in Base64 support. This is required for
// storing binary data in wxConfig on most platforms.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_BASE64 1
// Set this to 1 to be able to use wxEventLoop even in console applications
// (i.e. using base library only, without GUI). This is mostly useful for
// processing socket events but is also necessary to use timers in console
// applications
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_CONSOLE_EVENTLOOP 1
// Set wxUSE_(F)FILE to 1 to compile wx(F)File classes. wxFile uses low level
// POSIX functions for file access, wxFFile uses ANSI C stdio.h functions.
//
// Default is 1
//
// Recommended setting: 1 (wxFile is highly recommended as it is required by
// i18n code, wxFileConfig and others)
#define wxUSE_FILE 1
#define wxUSE_FFILE 1
// Use wxFSVolume class providing access to the configured/active mount points
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_FSVOLUME 1
// Use wxSecretStore class for storing passwords using OS-specific facilities.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_SECRETSTORE 1
// Use wxStandardPaths class which allows to retrieve some standard locations
// in the file system
//
// Default is 1
//
// Recommended setting: 1 (may be disabled to save space, but not much)
#define wxUSE_STDPATHS 1
// use wxTextBuffer class: required by wxTextFile
#define wxUSE_TEXTBUFFER 1
// use wxTextFile class: requires wxFile and wxTextBuffer, required by
// wxFileConfig
#define wxUSE_TEXTFILE 1
// i18n support: _() macro, wxLocale class. Requires wxTextFile.
#define wxUSE_INTL 1
// Provide wxFoo_l() functions similar to standard foo() functions but taking
// an extra locale parameter.
//
// Notice that this is fully implemented only for the systems providing POSIX
// xlocale support or Microsoft Visual C++ >= 8 (which provides proprietary
// almost-equivalent of xlocale functions), otherwise wxFoo_l() functions will
// only work for the current user locale and "C" locale. You can use
// wxHAS_XLOCALE_SUPPORT to test whether the full support is available.
//
// Default is 1
//
// Recommended setting: 1 but may be disabled if you are writing programs
// running only in C locale anyhow
#define wxUSE_XLOCALE 1
// Set wxUSE_DATETIME to 1 to compile the wxDateTime and related classes which
// allow to manipulate dates, times and time intervals.
//
// Requires: wxUSE_LONGLONG
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_DATETIME 1
// Set wxUSE_TIMER to 1 to compile wxTimer class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_TIMER 1
// Use wxStopWatch clas.
//
// Default is 1
//
// Recommended setting: 1 (needed by wxSocket)
#define wxUSE_STOPWATCH 1
// Set wxUSE_FSWATCHER to 1 if you want to enable wxFileSystemWatcher
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FSWATCHER 1
// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
// which allow the application to store its settings in the persistent
// storage. Setting this to 1 will also enable on-demand creation of the
// global config object in wxApp.
//
// See also wxUSE_CONFIG_NATIVE below.
//
// Recommended setting: 1
#define wxUSE_CONFIG 1
// If wxUSE_CONFIG is 1, you may choose to use either the native config
// classes under Windows (using .INI files under Win16 and the registry under
// Win32) or the portable text file format used by the config classes under
// Unix.
//
// Default is 1 to use native classes. Note that you may still use
// wxFileConfig even if you set this to 1 - just the config object created by
// default for the applications needs will be a wxRegConfig or wxIniConfig and
// not wxFileConfig.
//
// Recommended setting: 1
#define wxUSE_CONFIG_NATIVE 1
// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
// to connect/disconnect from the network and be notified whenever the dial-up
// network connection is established/terminated. Requires wxUSE_DYNAMIC_LOADER.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DIALUP_MANAGER 1
// Compile in classes for run-time DLL loading and function calling.
// Required by wxUSE_DIALUP_MANAGER.
//
// This setting is for Win32 only
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DYNLIB_CLASS 1
// experimental, don't use for now
#define wxUSE_DYNAMIC_LOADER 1
// Set to 1 to use socket classes
#define wxUSE_SOCKETS 1
// Set to 1 to use ipv6 socket classes (requires wxUSE_SOCKETS)
//
// Notice that currently setting this option under Windows will result in
// programs which can only run on recent OS versions (with ws2_32.dll
// installed) which is why it is disabled by default.
//
// Default is 1.
//
// Recommended setting: 1 if you need IPv6 support
#define wxUSE_IPV6 0
// Set to 1 to enable virtual file systems (required by wxHTML)
#define wxUSE_FILESYSTEM 1
// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ZIP 1
// Set to 1 to enable virtual archive filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ARCHIVE 1
// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_INET 1
// wxArchive classes for accessing archives such as zip and tar
#define wxUSE_ARCHIVE_STREAMS 1
// Set to 1 to compile wxZipInput/OutputStream classes.
#define wxUSE_ZIPSTREAM 1
// Set to 1 to compile wxTarInput/OutputStream classes.
#define wxUSE_TARSTREAM 1
// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
// wxUSE_LIBPNG
#define wxUSE_ZLIB 1
// Set to 1 if liblzma is available to enable wxLZMA{Input,Output}Stream
// classes.
//
// Notice that if you enable this build option when not using configure or
// CMake, you need to ensure that liblzma headers and libraries are available
// (i.e. by building the library yourself or downloading its binaries) and can
// be found, either by copying them to one of the locations searched by the
// compiler/linker by default (e.g. any of the directories in the INCLUDE or
// LIB environment variables, respectively, when using MSVC) or modify the
// make- or project files to add references to these directories.
//
// Default is 0 under MSW, auto-detected by configure.
//
// Recommended setting: 1 if you need LZMA compression.
#define wxUSE_LIBLZMA 0
// If enabled, the code written by Apple will be used to write, in a portable
// way, float on the disk. See extended.c for the license which is different
// from wxWidgets one.
//
// Default is 1.
//
// Recommended setting: 1 unless you don't like the license terms (unlikely)
#define wxUSE_APPLE_IEEE 1
// Joystick support class
#define wxUSE_JOYSTICK 1
// wxFontEnumerator class
#define wxUSE_FONTENUM 1
// wxFontMapper class
#define wxUSE_FONTMAP 1
// wxMimeTypesManager class
#define wxUSE_MIMETYPE 1
// wxProtocol and related classes: if you want to use either of wxFTP, wxHTTP
// or wxURL you need to set this to 1.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_PROTOCOL 1
// The settings for the individual URL schemes
#define wxUSE_PROTOCOL_FILE 1
#define wxUSE_PROTOCOL_FTP 1
#define wxUSE_PROTOCOL_HTTP 1
// Define this to use wxURL class.
#define wxUSE_URL 1
// Define this to use native platform url and protocol support.
// Currently valid only for MS-Windows.
// Note: if you set this to 1, you can open ftp/http/gopher sites
// and obtain a valid input stream for these sites
// even when you set wxUSE_PROTOCOL_FTP/HTTP to 0.
// Doing so reduces the code size.
//
// This code is experimental and subject to change.
#define wxUSE_URL_NATIVE 0
// Support for wxVariant class used in several places throughout the library,
// notably in wxDataViewCtrl API.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size as much as
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
// Support for wxAny class, the successor for wxVariant.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size by a small amount,
// or your compiler cannot for some reason cope with complexity of templates used.
#define wxUSE_ANY 1
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
//
// Default is 0
//
// Recommended setting: 1 if your compiler supports it, if it doesn't please
// contribute us a makefile for src/regex for it
#define wxUSE_REGEX 1
// wxSystemOptions class
#define wxUSE_SYSTEM_OPTIONS 1
// wxSound class
#define wxUSE_SOUND 1
// Use wxMediaCtrl
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_MEDIACTRL 1
// Use wxWidget's XRC XML-based resource system. Recommended.
//
// Default is 1
//
// Recommended setting: 1 (requires wxUSE_XML)
#define wxUSE_XRC 1
// XML parsing classes. Note that their API will change in the future, so
// using wxXmlDocument and wxXmlNode in your app is not recommended.
//
// Default is the same as wxUSE_XRC, i.e. 1 by default.
//
// Recommended setting: 1 (required by XRC)
#define wxUSE_XML wxUSE_XRC
// Use wxWidget's AUI docking system
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_AUI 1
// Use wxWidget's Ribbon classes for interfaces
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_RIBBON 1
// Use wxPropertyGrid.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_PROPGRID 1
// Use wxStyledTextCtrl, a wxWidgets implementation of Scintilla.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STC 1
// Use wxWidget's web viewing classes
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_WEBVIEW 1
// Use the IE wxWebView backend
//
// Default is 1 on MSW
//
// Recommended setting: 1
#ifdef __WXMSW__
#define wxUSE_WEBVIEW_IE 1
#else
#define wxUSE_WEBVIEW_IE 0
#endif
// Use the WebKit wxWebView backend
//
// Default is 1 on GTK and OSX
//
// Recommended setting: 1
#if (defined(__WXGTK__) && !defined(__WXGTK3__)) || defined(__WXOSX__)
#define wxUSE_WEBVIEW_WEBKIT 1
#else
#define wxUSE_WEBVIEW_WEBKIT 0
#endif
// Use the WebKit2 wxWebView backend
//
// Default is 1 on GTK3
//
// Recommended setting: 1
#if defined(__WXGTK3__)
#define wxUSE_WEBVIEW_WEBKIT2 1
#else
#define wxUSE_WEBVIEW_WEBKIT2 0
#endif
// Enable wxGraphicsContext and related classes for a modern 2D drawing API.
//
// Default is 1 except if you're using a compiler without support for GDI+
// under MSW, i.e. gdiplus.h and related headers (MSVC and MinGW >= 4.8 are
// known to have them). For other compilers (e.g. older mingw32) you may need
// to install the headers (and just the headers) yourself. If you do, change
// the setting below manually.
//
// Recommended setting: 1 if supported by the compilation environment
// Notice that we can't use wxCHECK_VISUALC_VERSION() nor wxCHECK_GCC_VERSION()
// here as this file is included from wx/platform.h before they're defined.
#if defined(_MSC_VER) || \
(defined(__MINGW32__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 8))
#define wxUSE_GRAPHICS_CONTEXT 1
#else
// Disable support for other Windows compilers, enable it if your compiler
// comes with new enough SDK or you installed the headers manually.
//
// Notice that this will be set by configure under non-Windows platforms
// anyhow so the value there is not important.
#define wxUSE_GRAPHICS_CONTEXT 0
#endif
// Enable wxGraphicsContext implementation using Cairo library.
//
// This is not needed under Windows and detected automatically by configure
// under other systems, however you may set this to 1 manually if you installed
// Cairo under Windows yourself and prefer to use it instead the native GDI+
// implementation.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_CAIRO 0
// ----------------------------------------------------------------------------
// Individual GUI controls
// ----------------------------------------------------------------------------
// You must set wxUSE_CONTROLS to 1 if you are using any controls at all
// (without it, wxControl class is not compiled)
//
// Default is 1
//
// Recommended setting: 1 (don't change except for very special programs)
#define wxUSE_CONTROLS 1
// Support markup in control labels, i.e. provide wxControl::SetLabelMarkup().
// Currently markup is supported only by a few controls and only some ports but
// their number will increase with time.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you want to save on code size)
#define wxUSE_MARKUP 1
// wxPopupWindow class is a top level transient window. It is currently used
// to implement wxTipWindow
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you don't wxUSE_TIPWINDOW)
#define wxUSE_POPUPWIN 1
// wxTipWindow allows to implement the custom tooltips, it is used by the
// context help classes. Requires wxUSE_POPUPWIN.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0)
#define wxUSE_TIPWINDOW 1
// Each of the settings below corresponds to one wxWidgets control. They are
// all switched on by default but may be disabled if you are sure that your
// program (including any standard dialogs it can show!) doesn't need them and
// if you desperately want to save some space. If you use any of these you must
// set wxUSE_CONTROLS as well.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_ACTIVITYINDICATOR 1 // wxActivityIndicator
#define wxUSE_ANIMATIONCTRL 1 // wxAnimationCtrl
#define wxUSE_BANNERWINDOW 1 // wxBannerWindow
#define wxUSE_BUTTON 1 // wxButton
#define wxUSE_BMPBUTTON 1 // wxBitmapButton
#define wxUSE_CALENDARCTRL 1 // wxCalendarCtrl
#define wxUSE_CHECKBOX 1 // wxCheckBox
#define wxUSE_CHECKLISTBOX 1 // wxCheckListBox (requires wxUSE_OWNER_DRAWN)
#define wxUSE_CHOICE 1 // wxChoice
#define wxUSE_COLLPANE 1 // wxCollapsiblePane
#define wxUSE_COLOURPICKERCTRL 1 // wxColourPickerCtrl
#define wxUSE_COMBOBOX 1 // wxComboBox
#define wxUSE_COMMANDLINKBUTTON 1 // wxCommandLinkButton
#define wxUSE_DATAVIEWCTRL 1 // wxDataViewCtrl
#define wxUSE_DATEPICKCTRL 1 // wxDatePickerCtrl
#define wxUSE_DIRPICKERCTRL 1 // wxDirPickerCtrl
#define wxUSE_EDITABLELISTBOX 1 // wxEditableListBox
#define wxUSE_FILECTRL 1 // wxFileCtrl
#define wxUSE_FILEPICKERCTRL 1 // wxFilePickerCtrl
#define wxUSE_FONTPICKERCTRL 1 // wxFontPickerCtrl
#define wxUSE_GAUGE 1 // wxGauge
#define wxUSE_HEADERCTRL 1 // wxHeaderCtrl
#define wxUSE_HYPERLINKCTRL 1 // wxHyperlinkCtrl
#define wxUSE_LISTBOX 1 // wxListBox
#define wxUSE_LISTCTRL 1 // wxListCtrl
#define wxUSE_RADIOBOX 1 // wxRadioBox
#define wxUSE_RADIOBTN 1 // wxRadioButton
#define wxUSE_RICHMSGDLG 1 // wxRichMessageDialog
#define wxUSE_SCROLLBAR 1 // wxScrollBar
#define wxUSE_SEARCHCTRL 1 // wxSearchCtrl
#define wxUSE_SLIDER 1 // wxSlider
#define wxUSE_SPINBTN 1 // wxSpinButton
#define wxUSE_SPINCTRL 1 // wxSpinCtrl
#define wxUSE_STATBOX 1 // wxStaticBox
#define wxUSE_STATLINE 1 // wxStaticLine
#define wxUSE_STATTEXT 1 // wxStaticText
#define wxUSE_STATBMP 1 // wxStaticBitmap
#define wxUSE_TEXTCTRL 1 // wxTextCtrl
#define wxUSE_TIMEPICKCTRL 1 // wxTimePickerCtrl
#define wxUSE_TOGGLEBTN 1 // requires wxButton
#define wxUSE_TREECTRL 1 // wxTreeCtrl
#define wxUSE_TREELISTCTRL 1 // wxTreeListCtrl
// Use a status bar class? Depending on the value of wxUSE_NATIVE_STATUSBAR
// below either wxStatusBar95 or a generic wxStatusBar will be used.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STATUSBAR 1
// Two status bar implementations are available under Win32: the generic one
// or the wrapper around native control. For native look and feel the native
// version should be used.
//
// Default is 1 for the platforms where native status bar is supported.
//
// Recommended setting: 1 (there is no advantage in using the generic one)
#define wxUSE_NATIVE_STATUSBAR 1
// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
// classes at all. Otherwise, use the native toolbar class unless
// wxUSE_TOOLBAR_NATIVE is 0.
//
// Default is 1 for all settings.
//
// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE.
#define wxUSE_TOOLBAR 1
#define wxUSE_TOOLBAR_NATIVE 1
// wxNotebook is a control with several "tabs" located on one of its sides. It
// may be used to logically organise the data presented to the user instead of
// putting everything in one huge dialog. It replaces wxTabControl and related
// classes of wxWin 1.6x.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTEBOOK 1
// wxListbook control is similar to wxNotebook but uses wxListCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_LISTBOOK 1
// wxChoicebook control is similar to wxNotebook but uses wxChoice instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CHOICEBOOK 1
// wxTreebook control is similar to wxNotebook but uses wxTreeCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TREEBOOK 1
// wxToolbook control is similar to wxNotebook but uses wxToolBar instead of
// tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLBOOK 1
// wxTaskBarIcon is a small notification icon shown in the system toolbar or
// dock.
//
// Default is 1.
//
// Recommended setting: 1 (but can be set to 0 if you don't need it)
#define wxUSE_TASKBARICON 1
// wxGrid class
//
// Default is 1, set to 0 to cut down compilation time and binaries size if you
// don't use it.
//
// Recommended setting: 1
//
#define wxUSE_GRID 1
// wxMiniFrame class: a frame with narrow title bar
//
// Default is 1.
//
// Recommended setting: 1 (it doesn't cost almost anything)
#define wxUSE_MINIFRAME 1
// wxComboCtrl and related classes: combobox with custom popup window and
// not necessarily a listbox.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 except for wxUniv where it
// it used by wxComboBox
#define wxUSE_COMBOCTRL 1
// wxOwnerDrawnComboBox is a custom combobox allowing to paint the combobox
// items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0, except where it is
// needed as a base class for generic wxBitmapComboBox.
#define wxUSE_ODCOMBOBOX 1
// wxBitmapComboBox is a combobox that can have images in front of text items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0
#define wxUSE_BITMAPCOMBOBOX 1
// wxRearrangeCtrl is a wxCheckListBox with two buttons allowing to move items
// up and down in it. It is also used as part of wxRearrangeDialog.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 (currently used only by
// wxHeaderCtrl)
#define wxUSE_REARRANGECTRL 1
// wxAddRemoveCtrl is a composite control containing a control showing some
// items (e.g. wxListBox, wxListCtrl, wxTreeCtrl, wxDataViewCtrl, ...) and "+"/
// "-" buttons allowing to add and remove items to/from the control.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 if you don't need it (not
// used by the library itself).
#define wxUSE_ADDREMOVECTRL 1
// ----------------------------------------------------------------------------
// Miscellaneous GUI stuff
// ----------------------------------------------------------------------------
// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
#define wxUSE_ACCEL 1
// Use the standard art provider. The icons returned by this provider are
// embedded into the library as XPMs so disabling it reduces the library size
// somewhat but this should only be done if you use your own custom art
// provider returning the icons or never use any icons not provided by the
// native art provider (which might not be implemented at all for some
// platforms) or by the Tango icons provider (if it's not itself disabled
// below).
//
// Default is 1.
//
// Recommended setting: 1 unless you use your own custom art provider.
#define wxUSE_ARTPROVIDER_STD 1
// Use art provider providing Tango icons: this art provider has higher quality
// icons than the default ones using smaller size XPM icons without
// transparency but the embedded PNG icons add to the library size.
//
// Default is 1 under non-GTK ports. Under wxGTK the native art provider using
// the GTK+ stock icons replaces it so it is normally not necessary.
//
// Recommended setting: 1 but can be turned off to reduce the library size.
#define wxUSE_ARTPROVIDER_TANGO 1
// Hotkey support (currently Windows only)
#define wxUSE_HOTKEY 1
// Use wxCaret: a class implementing a "cursor" in a text control (called caret
// under Windows).
//
// Default is 1.
//
// Recommended setting: 1 (can be safely set to 0, not used by the library)
#define wxUSE_CARET 1
// Use wxDisplay class: it allows enumerating all displays on a system and
// their geometries as well as finding the display on which the given point or
// window lies.
//
// Default is 1.
//
// Recommended setting: 1 if you need it, can be safely set to 0 otherwise
#define wxUSE_DISPLAY 1
// Miscellaneous geometry code: needed for Canvas library
#define wxUSE_GEOMETRY 1
// Use wxImageList. This class is needed by wxNotebook, wxTreeCtrl and
// wxListCtrl.
//
// Default is 1.
//
// Recommended setting: 1 (set it to 0 if you don't use any of the controls
// enumerated above, then this class is mostly useless too)
#define wxUSE_IMAGLIST 1
// Use wxInfoBar class.
//
// Default is 1.
//
// Recommended setting: 1 (but can be disabled without problems as nothing
// depends on it)
#define wxUSE_INFOBAR 1
// Use wxMenu, wxMenuBar, wxMenuItem.
//
// Default is 1.
//
// Recommended setting: 1 (can't be disabled under MSW)
#define wxUSE_MENUS 1
// Use wxNotificationMessage.
//
// wxNotificationMessage allows to show non-intrusive messages to the user
// using balloons, banners, popups or whatever is the appropriate method for
// the current platform.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTIFICATION_MESSAGE 1
// wxPreferencesEditor provides a common API for different ways of presenting
// the standard "Preferences" or "Properties" dialog under different platforms
// (e.g. some use modal dialogs, some use modeless ones; some apply the changes
// immediately while others require an explicit "Apply" button).
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_PREFERENCES_EDITOR 1
// wxFont::AddPrivateFont() allows to use fonts not installed on the system by
// loading them from font files during run-time.
//
// Default is 1 except under Unix where it will be turned off by configure if
// the required libraries are not available or not new enough.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it and
// want to avoid extra dependencies under Linux, for example).
#define wxUSE_PRIVATE_FONTS 1
// wxRichToolTip is a customizable tooltip class which has more functionality
// than the stock (but native, unlike this class) wxToolTip.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely set to 0 if you don't need it)
#define wxUSE_RICHTOOLTIP 1
// Use wxSashWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SASH 1
// Use wxSplitterWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SPLITTER 1
// Use wxToolTip and wxWindow::Set/GetToolTip() methods.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLTIPS 1
// wxValidator class and related methods
#define wxUSE_VALIDATORS 1
// Use reference counted ID management: this means that wxWidgets will track
// the automatically allocated ids (those used when you use wxID_ANY when
// creating a window, menu or toolbar item &c) instead of just supposing that
// the program never runs out of them. This is mostly useful only under wxMSW
// where the total ids range is limited to SHRT_MIN..SHRT_MAX and where
// long-running programs can run into problems with ids reuse without this. On
// the other platforms, where the ids have the full int range, this shouldn't
// be necessary.
#ifdef __WXMSW__
#define wxUSE_AUTOID_MANAGEMENT 1
#else
#define wxUSE_AUTOID_MANAGEMENT 0
#endif
// ----------------------------------------------------------------------------
// common dialogs
// ----------------------------------------------------------------------------
// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
// file selector, printer dialog). Switching this off also switches off the
// printing architecture and interactive wxPrinterDC.
//
// Default is 1
//
// Recommended setting: 1 (unless it really doesn't work)
#define wxUSE_COMMON_DIALOGS 1
// wxBusyInfo displays window with message when app is busy. Works in same way
// as wxBusyCursor
#define wxUSE_BUSYINFO 1
// Use single/multiple choice dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_CHOICEDLG 1
// Use colour picker dialog
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_COLOURDLG 1
// wxDirDlg class for getting a directory name from user
#define wxUSE_DIRDLG 1
// TODO: setting to choose the generic or native one
// Use file open/save dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in many places in the library itself)
#define wxUSE_FILEDLG 1
// Use find/replace dialogs.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely set to 0)
#define wxUSE_FINDREPLDLG 1
// Use font picker dialog
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_FONTDLG 1
// Use wxMessageDialog and wxMessageBox.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_MSGDLG 1
// progress dialog class for lengthy operations
#define wxUSE_PROGRESSDLG 1
// Set to 0 to disable the use of the native progress dialog (currently only
// available under MSW and suffering from some bugs there, hence this option).
#define wxUSE_NATIVE_PROGRESSDLG 1
// support for startup tips (wxShowTip &c)
#define wxUSE_STARTUP_TIPS 1
// text entry dialog and wxGetTextFromUser function
#define wxUSE_TEXTDLG 1
// number entry dialog
#define wxUSE_NUMBERDLG 1
// splash screen class
#define wxUSE_SPLASH 1
// wizards
#define wxUSE_WIZARDDLG 1
// Compile in wxAboutBox() function showing the standard "About" dialog.
//
// Default is 1
//
// Recommended setting: 1 but can be set to 0 to save some space if you don't
// use this function
#define wxUSE_ABOUTDLG 1
// wxFileHistory class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FILE_HISTORY 1
// ----------------------------------------------------------------------------
// Metafiles support
// ----------------------------------------------------------------------------
// Windows supports the graphics format known as metafile which, though not
// portable, is widely used under Windows and so is supported by wxWidgets
// (under Windows only, of course). Both the so-called "Window MetaFiles" or
// WMFs, and "Enhanced MetaFiles" or EMFs are supported in wxWin and, by
// default, EMFs will be used. This may be changed by setting
// wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting wxUSE_ENH_METAFILE to 0.
// You may also set wxUSE_METAFILE to 0 to not compile in any metafile
// related classes at all.
//
// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
//
// Recommended setting: default or 0 for everything for portable programs.
#define wxUSE_METAFILE 1
#define wxUSE_ENH_METAFILE 1
#define wxUSE_WIN_METAFILES_ALWAYS 0
// ----------------------------------------------------------------------------
// Big GUI components
// ----------------------------------------------------------------------------
// Set to 0 to disable MDI support.
//
// Requires wxUSE_NOTEBOOK under platforms other than MSW.
//
// Default is 1.
//
// Recommended setting: 1, can be safely set to 0.
#define wxUSE_MDI 1
// Set to 0 to disable document/view architecture
#define wxUSE_DOC_VIEW_ARCHITECTURE 1
// Set to 0 to disable MDI document/view architecture
//
// Requires wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 1
// Set to 0 to disable print/preview architecture code
#define wxUSE_PRINTING_ARCHITECTURE 1
// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
// much more.
//
// Default is 1.
//
// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
// smaller library.
#define wxUSE_HTML 1
// Setting wxUSE_GLCANVAS to 1 enables OpenGL support. You need to have OpenGL
// headers and libraries to be able to compile the library with wxUSE_GLCANVAS
// set to 1 and, under Windows, also to add opengl32.lib and glu32.lib to the
// list of libraries used to link your application (although this is done
// implicitly for Microsoft Visual C++ users).
//
// Default is 1.
//
// Recommended setting: 1 if you intend to use OpenGL, can be safely set to 0
// otherwise.
#define wxUSE_GLCANVAS 1
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 if you want compile a
// smaller library.
#define wxUSE_RICHTEXT 1
// ----------------------------------------------------------------------------
// Data transfer
// ----------------------------------------------------------------------------
// Use wxClipboard class for clipboard copy/paste.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CLIPBOARD 1
// Use wxDataObject and related classes. Needed for clipboard and OLE drag and
// drop
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DATAOBJ 1
// Use wxDropTarget and wxDropSource classes for drag and drop (this is
// different from "built in" drag and drop in wxTreeCtrl which is always
// available). Requires wxUSE_DATAOBJ.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DRAG_AND_DROP 1
// Use wxAccessible for enhanced and customisable accessibility.
// Depends on wxUSE_OLE on MSW.
//
// Default is 1 on MSW, 0 elsewhere.
//
// Recommended setting (at present): 1 (MSW-only)
#ifdef __WXMSW__
#define wxUSE_ACCESSIBILITY 1
#else
#define wxUSE_ACCESSIBILITY 0
#endif
// ----------------------------------------------------------------------------
// miscellaneous settings
// ----------------------------------------------------------------------------
// wxSingleInstanceChecker class allows to verify at startup if another program
// instance is running.
//
// Default is 1
//
// Recommended setting: 1 (the class is tiny, disabling it won't save much
// space)
#define wxUSE_SNGLINST_CHECKER 1
#define wxUSE_DRAGIMAGE 1
#define wxUSE_IPC 1
// 0 for no interprocess comms
#define wxUSE_HELP 1
// 0 for no help facility
// Should we use MS HTML help for wxHelpController? If disabled, neither
// wxCHMHelpController nor wxBestHelpController are available.
//
// Default is 1 under MSW, 0 is always used for the other platforms.
//
// Recommended setting: 1, only set to 0 if you have trouble compiling
// wxCHMHelpController (could be a problem with really ancient compilers)
#define wxUSE_MS_HTML_HELP 1
// Use wxHTML-based help controller?
#define wxUSE_WXHTML_HELP 1
#define wxUSE_CONSTRAINTS 1
// 0 for no window layout constraint system
#define wxUSE_SPLINES 1
// 0 for no splines
#define wxUSE_MOUSEWHEEL 1
// Include mouse wheel support
// Compile wxUIActionSimulator class?
#define wxUSE_UIACTIONSIMULATOR 1
// ----------------------------------------------------------------------------
// wxDC classes for various output formats
// ----------------------------------------------------------------------------
// Set to 1 for PostScript device context.
#define wxUSE_POSTSCRIPT 0
// Set to 1 to use font metric files in GetTextExtent
#define wxUSE_AFM_FOR_POSTSCRIPT 1
// Set to 1 to compile in support for wxSVGFileDC, a wxDC subclass which allows
// to create files in SVG (Scalable Vector Graphics) format.
#define wxUSE_SVG 1
// Should wxDC provide SetTransformMatrix() and related methods?
//
// Default is 1 but can be set to 0 if this functionality is not used. Notice
// that currently wxMSW, wxGTK3 support this for wxDC and all platforms support
// this for wxGCDC so setting this to 0 doesn't change much if neither of these
// is used (although it will still save a few bytes probably).
//
// Recommended setting: 1.
#define wxUSE_DC_TRANSFORM_MATRIX 1
// ----------------------------------------------------------------------------
// image format support
// ----------------------------------------------------------------------------
// wxImage supports many different image formats which can be configured at
// compile-time. BMP is always supported, others are optional and can be safely
// disabled if you don't plan to use images in such format sometimes saving
// substantial amount of code in the final library.
//
// Some formats require an extra library which is included in wxWin sources
// which is mentioned if it is the case.
// Set to 1 for wxImage support (recommended).
#define wxUSE_IMAGE 1
// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
#define wxUSE_LIBPNG 1
// Set to 1 for JPEG format support (requires libjpeg)
#define wxUSE_LIBJPEG 1
// Set to 1 for TIFF format support (requires libtiff)
#define wxUSE_LIBTIFF 1
// Set to 1 for TGA format support (loading only)
#define wxUSE_TGA 1
// Set to 1 for GIF format support
#define wxUSE_GIF 1
// Set to 1 for PNM format support
#define wxUSE_PNM 1
// Set to 1 for PCX format support
#define wxUSE_PCX 1
// Set to 1 for IFF format support (Amiga format)
#define wxUSE_IFF 0
// Set to 1 for XPM format support
#define wxUSE_XPM 1
// Set to 1 for MS Icons and Cursors format support
#define wxUSE_ICO_CUR 1
// Set to 1 to compile in wxPalette class
#define wxUSE_PALETTE 1
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
/* --- end common options --- */
/* --- start MSW options --- */
// ----------------------------------------------------------------------------
// Graphics backends choices for Windows
// ----------------------------------------------------------------------------
// The options here are only taken into account if wxUSE_GRAPHICS_CONTEXT is 1.
// Enable support for GDI+-based implementation of wxGraphicsContext.
//
// Default is 1.
//
// Recommended setting: 1 if you need to support XP, as Direct2D is not
// available there.
#define wxUSE_GRAPHICS_GDIPLUS wxUSE_GRAPHICS_CONTEXT
// Enable support for Direct2D-based implementation of wxGraphicsContext.
//
// Default is 1 for compilers which support it, i.e. VC10+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1 for faster and better quality graphics under Windows
// 7 and later systems (if wxUSE_GRAPHICS_GDIPLUS is also enabled, earlier
// systems will fall back on using GDI+).
#if defined(_MSC_VER) && _MSC_VER >= 1600
#define wxUSE_GRAPHICS_DIRECT2D wxUSE_GRAPHICS_CONTEXT
#else
#define wxUSE_GRAPHICS_DIRECT2D 0
#endif
// ----------------------------------------------------------------------------
// Windows-only settings
// ----------------------------------------------------------------------------
// Set this to 1 for generic OLE support: this is required for drag-and-drop,
// clipboard, OLE Automation. Only set it to 0 if your compiler is very old and
// can't compile/doesn't have the OLE headers.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_OLE 1
// Set this to 1 to enable wxAutomationObject class.
//
// Default is 1.
//
// Recommended setting: 1 if you need to control other applications via OLE
// Automation, can be safely set to 0 otherwise
#define wxUSE_OLE_AUTOMATION 1
// Set this to 1 to enable wxActiveXContainer class allowing to embed OLE
// controls in wx.
//
// Default is 1.
//
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
// Enable WinRT support
//
// Default is 1 for compilers which support it, i.e. VS2012+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1
#if defined(_MSC_VER) && _MSC_VER >= 1700 && !defined(_USING_V110_SDK71_)
#define wxUSE_WINRT 1
#else
#define wxUSE_WINRT 0
#endif
// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
// wxBitmap data.
//
// Default is 1, set it to 0 only if you don't use wxImage neither
//
// Recommended setting: 1 (without it conversion to/from wxImage won't work)
#define wxUSE_WXDIB 1
// Set to 0 to disable PostScript print/preview architecture code under Windows
// (just use Windows printing).
#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
// Set this to 1 to compile in wxRegKey class.
//
// Default is 1
//
// Recommended setting: 1, this is used internally by wx in a few places
#define wxUSE_REGKEY 1
// Set this to 1 to use RICHEDIT controls for wxTextCtrl with style wxTE_RICH
// which allows to put more than ~32Kb of text in it even under Win9x (NT
// doesn't have such limitation).
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1, only set it to 0 if your compiler doesn't have
// or can't compile <richedit.h>
#define wxUSE_RICHEDIT 1
// Set this to 1 to use extra features of richedit v2 and later controls
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1
#define wxUSE_RICHEDIT2 1
// Set this to 1 to enable support for the owner-drawn menu and listboxes. This
// is required by wxUSE_CHECKLISTBOX.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a small library size reduction
#define wxUSE_OWNER_DRAWN 1
// Set this to 1 to enable MSW-specific wxTaskBarIcon::ShowBalloon() method. It
// is required by native wxNotificationMessage implementation.
//
// Default is 1 but disabled in wx/msw/chkconf.h if SDK is too old to contain
// the necessary declarations.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARICON_BALLOONS 1
// Set this to 1 to enable following functionality added in Windows 7: thumbnail
// representations, thumbnail toolbars, notification and status overlays,
// progress indicators and jump lists.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARBUTTON 1
// Set to 1 to compile MS Windows XP theme engine support
#define wxUSE_UXTHEME 1
// Set to 1 to use InkEdit control (Tablet PC), if available
#define wxUSE_INKEDIT 0
// Set to 1 to enable .INI files based wxConfig implementation (wxIniConfig)
//
// Default is 0.
//
// Recommended setting: 0, nobody uses .INI files any more
#define wxUSE_INICONF 0
// ----------------------------------------------------------------------------
// Generic versions of native controls
// ----------------------------------------------------------------------------
// Set this to 1 to be able to use wxDatePickerCtrlGeneric in addition to the
// native wxDatePickerCtrl
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_DATEPICKCTRL_GENERIC 0
// Set this to 1 to be able to use wxTimePickerCtrlGeneric in addition to the
// native wxTimePickerCtrl for the platforms that have the latter (MSW).
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_TIMEPICKCTRL_GENERIC 0
// ----------------------------------------------------------------------------
// Crash debugging helpers
// ----------------------------------------------------------------------------
// Set this to 1 to use dbghelp.dll for providing stack traces in crash
// reports.
//
// Default is 1 if the compiler supports it, 0 for old MinGW.
//
// Recommended setting: 1, there is not much gain in disabling this
#if defined(__VISUALC__) || defined(__MINGW64_TOOLCHAIN__)
#define wxUSE_DBGHELP 1
#else
#define wxUSE_DBGHELP 0
#endif
// Set this to 1 to be able to use wxCrashReport::Generate() to create mini
// dumps of your program when it crashes (or at any other moment)
//
// Default is 1 if supported by the compiler (VC++ and recent BC++ only).
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_CRASHREPORT 1
/* --- end MSW options --- */
#endif // _WX_SETUP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/lib/vc_dll/mswu/wx/msw/rcdefs.h |
#ifndef _WX_RCDEFS_H
#define _WX_RCDEFS_H
#define WX_CPU_X86
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/lib/vc_dll/mswud/wx/setup.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/setup.h
// Purpose: Configuration for the library
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
/* --- start common options --- */
// ----------------------------------------------------------------------------
// global settings
// ----------------------------------------------------------------------------
// define this to 0 when building wxBase library - this can also be done from
// makefile/project file overriding the value here
#ifndef wxUSE_GUI
#define wxUSE_GUI 1
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// compatibility settings
// ----------------------------------------------------------------------------
// This setting determines the compatibility with 2.8 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_2_8 0
// This setting determines the compatibility with 3.0 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_3_0 1
// MSW-only: Set to 0 for accurate dialog units, else 1 for old behaviour when
// default system font is used for wxWindow::GetCharWidth/Height() instead of
// the current font.
//
// Default is 0
//
// Recommended setting: 0
#define wxDIALOG_UNIT_COMPATIBILITY 0
// Provide unsafe implicit conversions in wxString to "const char*" or
// "std::string" (depending on wxUSE_STD_STRING_CONV_IN_WXSTRING value).
//
// Default is 1 but only for compatibility reasons, it is recommended to set
// this to 0 because converting wxString to a narrow (non-Unicode) string may
// fail unless a locale using UTF-8 encoding is used, which is never the case
// under MSW, for example, hence such conversions can result in silent data
// loss.
//
// Recommended setting: 0
#define wxUSE_UNSAFE_WXSTRING_CONV 1
// If set to 1, enables "reproducible builds", i.e. build output should be
// exactly the same if the same build is redone again. As using __DATE__ and
// __TIME__ macros clearly makes the build irreproducible, setting this option
// to 1 disables their use in the library code.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_REPRODUCIBLE_BUILD 0
// ----------------------------------------------------------------------------
// debugging settings
// ----------------------------------------------------------------------------
// wxDEBUG_LEVEL will be defined as 1 in wx/debug.h so normally there is no
// need to define it here. You may do it for two reasons: either completely
// disable/compile out the asserts in release version (then do it inside #ifdef
// NDEBUG) or, on the contrary, enable more asserts, including the usually
// disabled ones, in the debug build (then do it inside #ifndef NDEBUG)
//
// #ifdef NDEBUG
// #define wxDEBUG_LEVEL 0
// #else
// #define wxDEBUG_LEVEL 2
// #endif
// wxHandleFatalExceptions() may be used to catch the program faults at run
// time and, instead of terminating the program with a usual GPF message box,
// call the user-defined wxApp::OnFatalException() function. If you set
// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
//
// This setting is for Win32 only and can only be enabled if your compiler
// supports Win32 structured exception handling (currently only VC++ does)
//
// Default is 1
//
// Recommended setting: 1 if your compiler supports it.
#define wxUSE_ON_FATAL_EXCEPTION 1
// Set this to 1 to be able to generate a human-readable (unlike
// machine-readable minidump created by wxCrashReport::Generate()) stack back
// trace when your program crashes using wxStackWalker
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_STACKWALKER 1
// Set this to 1 to compile in wxDebugReport class which allows you to create
// and optionally upload to your web site a debug report consisting of back
// trace of the crash (if wxUSE_STACKWALKER == 1) and other information.
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, it is compiled into a separate library so there
// is no overhead if you don't use it
#define wxUSE_DEBUGREPORT 1
// Generic comment about debugging settings: they are very useful if you don't
// use any other memory leak detection tools such as Purify/BoundsChecker, but
// are probably redundant otherwise. Also, Visual C++ CRT has the same features
// as wxWidgets memory debugging subsystem built in since version 5.0 and you
// may prefer to use it instead of built in memory debugging code because it is
// faster and more fool proof.
//
// Using VC++ CRT memory debugging is enabled by default in debug build (_DEBUG
// is defined) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
// and if __NO_VC_CRTDBG__ is not defined.
// The rest of the options in this section are obsolete and not supported,
// enable them at your own risk.
// If 1, enables wxDebugContext, for writing error messages to file, etc. If
// __WXDEBUG__ is not defined, will still use the normal memory operators.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_CONTEXT 0
// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
// __WXDEBUG__ is also defined.
//
// WARNING: this code may not work with all architectures, especially if
// alignment is an issue. This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 1 if you are not using a memory debugging tool, else 0
#define wxUSE_MEMORY_TRACING 0
// In debug mode, cause new and delete to be redefined globally.
// If this causes problems (e.g. link errors which is a common problem
// especially if you use another library which also redefines the global new
// and delete), set this to 0.
// This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
// this causes problems (e.g. link errors), set this to 0. You may need to set
// this to 0 if using templates (at least for VC++). This switch is currently
// ignored for MinGW/Cygwin.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_NEW_ALWAYS 0
// ----------------------------------------------------------------------------
// Unicode support
// ----------------------------------------------------------------------------
// These settings are obsolete: the library is always built in Unicode mode
// now, only set wxUSE_UNICODE to 0 to compile legacy code in ANSI mode if
// absolutely necessary -- updating it is strongly recommended as the ANSI mode
// will disappear completely in future wxWidgets releases.
#ifndef wxUSE_UNICODE
#define wxUSE_UNICODE 1
#endif
// wxUSE_WCHAR_T is required by wxWidgets now, don't change.
#define wxUSE_WCHAR_T 1
// ----------------------------------------------------------------------------
// global features
// ----------------------------------------------------------------------------
// Compile library in exception-safe mode? If set to 1, the library will try to
// behave correctly in presence of exceptions (even though it still will not
// use the exceptions itself) and notify the user code about any unhandled
// exceptions. If set to 0, propagation of the exceptions through the library
// code will lead to undefined behaviour -- but the code itself will be
// slightly smaller and faster.
//
// Note that like wxUSE_THREADS this option is automatically set to 0 if
// wxNO_EXCEPTIONS is defined.
//
// Default is 1
//
// Recommended setting: depends on whether you intend to use C++ exceptions
// in your own code (1 if you do, 0 if you don't)
#define wxUSE_EXCEPTIONS 1
// Set wxUSE_EXTENDED_RTTI to 1 to use extended RTTI
//
// Default is 0
//
// Recommended setting: 0 (this is still work in progress...)
#define wxUSE_EXTENDED_RTTI 0
// Support for message/error logging. This includes wxLogXXX() functions and
// wxLog and derived classes. Don't set this to 0 unless you really know what
// you are doing.
//
// Default is 1
//
// Recommended setting: 1 (always)
#define wxUSE_LOG 1
// Recommended setting: 1
#define wxUSE_LOGWINDOW 1
// Recommended setting: 1
#define wxUSE_LOGGUI 1
// Recommended setting: 1
#define wxUSE_LOG_DIALOG 1
// Support for command line parsing using wxCmdLineParser class.
//
// Default is 1
//
// Recommended setting: 1 (can be set to 0 if you don't use the cmd line)
#define wxUSE_CMDLINE_PARSER 1
// Support for multithreaded applications: if 1, compile in thread classes
// (thread.h) and make the library a bit more thread safe. Although thread
// support is quite stable by now, you may still consider recompiling the
// library without it if you have no use for it - this will result in a
// somewhat smaller and faster operation.
//
// Notice that if wxNO_THREADS is defined, wxUSE_THREADS is automatically reset
// to 0 in wx/chkconf.h, so, for example, if you set USE_THREADS to 0 in
// build/msw/config.* file this value will have no effect.
//
// Default is 1
//
// Recommended setting: 0 unless you do plan to develop MT applications
#define wxUSE_THREADS 1
// If enabled, compiles wxWidgets streams classes
//
// wx stream classes are used for image IO, process IO redirection, network
// protocols implementation and much more and so disabling this results in a
// lot of other functionality being lost.
//
// Default is 1
//
// Recommended setting: 1 as setting it to 0 disables many other things
#define wxUSE_STREAMS 1
// Support for positional parameters (e.g. %1$d, %2$s ...) in wxVsnprintf.
// Note that if the system's implementation does not support positional
// parameters, setting this to 1 forces the use of the wxWidgets implementation
// of wxVsnprintf. The standard vsnprintf() supports positional parameters on
// many Unix systems but usually doesn't under Windows.
//
// Positional parameters are very useful when translating a program since using
// them in formatting strings allow translators to correctly reorder the
// translated sentences.
//
// Default is 1
//
// Recommended setting: 1 if you want to support multiple languages
#define wxUSE_PRINTF_POS_PARAMS 1
// Enable the use of compiler-specific thread local storage keyword, if any.
// This is used for wxTLS_XXX() macros implementation and normally should use
// the compiler-provided support as it's simpler and more efficient, but is
// disabled under Windows in wx/msw/chkconf.h as it can't be used if wxWidgets
// is used in a dynamically loaded Win32 DLL (i.e. using LoadLibrary()) under
// XP as this triggers a bug in compiler TLS support that results in crashes
// when any TLS variables are used.
//
// If you're absolutely sure that your build of wxWidgets is never going to be
// used in such situation, either because it's not going to be linked from any
// kind of plugin or because you only target Vista or later systems, you can
// set this to 2 to force the use of compiler TLS even under MSW.
//
// Default is 1 meaning that compiler TLS is used only if it's 100% safe.
//
// Recommended setting: 2 if you want to have maximal performance and don't
// care about the scenario described above.
#define wxUSE_COMPILER_TLS 1
// ----------------------------------------------------------------------------
// Interoperability with the standard library.
// ----------------------------------------------------------------------------
// Set wxUSE_STL to 1 to enable maximal interoperability with the standard
// library, even at the cost of backwards compatibility.
//
// Default is 0
//
// Recommended setting: 0 as the options below already provide a relatively
// good level of interoperability and changing this option arguably isn't worth
// diverging from the official builds of the library.
#define wxUSE_STL 0
// This is not a real option but is used as the default value for
// wxUSE_STD_IOSTREAM, wxUSE_STD_STRING and wxUSE_STD_CONTAINERS_COMPATIBLY.
//
// Set it to 0 if you want to disable the use of all standard classes
// completely for some reason.
#define wxUSE_STD_DEFAULT 1
// Use standard C++ containers where it can be done without breaking backwards
// compatibility.
//
// This provides better interoperability with the standard library, e.g. with
// this option on it's possible to insert std::vector<> into many wxWidgets
// containers directly.
//
// Default is 1.
//
// Recommended setting is 1 unless you want to avoid all dependencies on the
// standard library.
#define wxUSE_STD_CONTAINERS_COMPATIBLY wxUSE_STD_DEFAULT
// Use standard C++ containers to implement wxVector<>, wxStack<>, wxDList<>
// and wxHashXXX<> classes. If disabled, wxWidgets own (mostly compatible but
// usually more limited) implementations are used which allows to avoid the
// dependency on the C++ run-time library.
//
// Default is 0 for compatibility reasons.
//
// Recommended setting: 1 unless compatibility with the official wxWidgets
// build and/or the existing code is a concern.
#define wxUSE_STD_CONTAINERS 0
// Use standard C++ streams if 1 instead of wx streams in some places. If
// disabled, wx streams are used everywhere and wxWidgets doesn't depend on the
// standard streams library.
//
// Notice that enabling this does not replace wx streams with std streams
// everywhere, in a lot of places wx streams are used no matter what.
//
// Default is 1 if compiler supports it.
//
// Recommended setting: 1 if you use the standard streams anyhow and so
// dependency on the standard streams library is not a
// problem
#define wxUSE_STD_IOSTREAM wxUSE_STD_DEFAULT
// Enable minimal interoperability with the standard C++ string class if 1.
// "Minimal" means that wxString can be constructed from std::string or
// std::wstring but can't be implicitly converted to them. You need to enable
// the option below for the latter.
//
// Default is 1 for most compilers.
//
// Recommended setting: 1 unless you want to ensure your program doesn't use
// the standard C++ library at all.
#define wxUSE_STD_STRING wxUSE_STD_DEFAULT
// Make wxString as much interchangeable with std::[w]string as possible, in
// particular allow implicit conversion of wxString to either of these classes.
// This comes at a price (or a benefit, depending on your point of view) of not
// allowing implicit conversion to "const char *" and "const wchar_t *".
//
// Because a lot of existing code relies on these conversions, this option is
// disabled by default but can be enabled for your build if you don't care
// about compatibility.
//
// Default is 0 if wxUSE_STL has its default value or 1 if it is enabled.
//
// Recommended setting: 0 to remain compatible with the official builds of
// wxWidgets.
#define wxUSE_STD_STRING_CONV_IN_WXSTRING wxUSE_STL
// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
// them. Set this option to 1 to use <iostream.h>, 0 to use <iostream>.
//
// Note that newer compilers (including VC++ 7.1 and later) don't support
// wxUSE_IOSTREAMH == 1 and so <iostream> will be used anyhow.
//
// Default is 0.
//
// Recommended setting: 0, only set to 1 if you use a really old compiler
#define wxUSE_IOSTREAMH 0
// ----------------------------------------------------------------------------
// non GUI features selection
// ----------------------------------------------------------------------------
// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
// integer which is implemented in terms of native 64 bit integers if any or
// uses emulation otherwise.
//
// This class is required by wxDateTime and so you should enable it if you want
// to use wxDateTime. For most modern platforms, it will use the native 64 bit
// integers in which case (almost) all of its functions are inline and it
// almost does not take any space, so there should be no reason to switch it
// off.
//
// Recommended setting: 1
#define wxUSE_LONGLONG 1
// Set wxUSE_BASE64 to 1, to compile in Base64 support. This is required for
// storing binary data in wxConfig on most platforms.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_BASE64 1
// Set this to 1 to be able to use wxEventLoop even in console applications
// (i.e. using base library only, without GUI). This is mostly useful for
// processing socket events but is also necessary to use timers in console
// applications
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_CONSOLE_EVENTLOOP 1
// Set wxUSE_(F)FILE to 1 to compile wx(F)File classes. wxFile uses low level
// POSIX functions for file access, wxFFile uses ANSI C stdio.h functions.
//
// Default is 1
//
// Recommended setting: 1 (wxFile is highly recommended as it is required by
// i18n code, wxFileConfig and others)
#define wxUSE_FILE 1
#define wxUSE_FFILE 1
// Use wxFSVolume class providing access to the configured/active mount points
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_FSVOLUME 1
// Use wxSecretStore class for storing passwords using OS-specific facilities.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_SECRETSTORE 1
// Use wxStandardPaths class which allows to retrieve some standard locations
// in the file system
//
// Default is 1
//
// Recommended setting: 1 (may be disabled to save space, but not much)
#define wxUSE_STDPATHS 1
// use wxTextBuffer class: required by wxTextFile
#define wxUSE_TEXTBUFFER 1
// use wxTextFile class: requires wxFile and wxTextBuffer, required by
// wxFileConfig
#define wxUSE_TEXTFILE 1
// i18n support: _() macro, wxLocale class. Requires wxTextFile.
#define wxUSE_INTL 1
// Provide wxFoo_l() functions similar to standard foo() functions but taking
// an extra locale parameter.
//
// Notice that this is fully implemented only for the systems providing POSIX
// xlocale support or Microsoft Visual C++ >= 8 (which provides proprietary
// almost-equivalent of xlocale functions), otherwise wxFoo_l() functions will
// only work for the current user locale and "C" locale. You can use
// wxHAS_XLOCALE_SUPPORT to test whether the full support is available.
//
// Default is 1
//
// Recommended setting: 1 but may be disabled if you are writing programs
// running only in C locale anyhow
#define wxUSE_XLOCALE 1
// Set wxUSE_DATETIME to 1 to compile the wxDateTime and related classes which
// allow to manipulate dates, times and time intervals.
//
// Requires: wxUSE_LONGLONG
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_DATETIME 1
// Set wxUSE_TIMER to 1 to compile wxTimer class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_TIMER 1
// Use wxStopWatch clas.
//
// Default is 1
//
// Recommended setting: 1 (needed by wxSocket)
#define wxUSE_STOPWATCH 1
// Set wxUSE_FSWATCHER to 1 if you want to enable wxFileSystemWatcher
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FSWATCHER 1
// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
// which allow the application to store its settings in the persistent
// storage. Setting this to 1 will also enable on-demand creation of the
// global config object in wxApp.
//
// See also wxUSE_CONFIG_NATIVE below.
//
// Recommended setting: 1
#define wxUSE_CONFIG 1
// If wxUSE_CONFIG is 1, you may choose to use either the native config
// classes under Windows (using .INI files under Win16 and the registry under
// Win32) or the portable text file format used by the config classes under
// Unix.
//
// Default is 1 to use native classes. Note that you may still use
// wxFileConfig even if you set this to 1 - just the config object created by
// default for the applications needs will be a wxRegConfig or wxIniConfig and
// not wxFileConfig.
//
// Recommended setting: 1
#define wxUSE_CONFIG_NATIVE 1
// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
// to connect/disconnect from the network and be notified whenever the dial-up
// network connection is established/terminated. Requires wxUSE_DYNAMIC_LOADER.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DIALUP_MANAGER 1
// Compile in classes for run-time DLL loading and function calling.
// Required by wxUSE_DIALUP_MANAGER.
//
// This setting is for Win32 only
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DYNLIB_CLASS 1
// experimental, don't use for now
#define wxUSE_DYNAMIC_LOADER 1
// Set to 1 to use socket classes
#define wxUSE_SOCKETS 1
// Set to 1 to use ipv6 socket classes (requires wxUSE_SOCKETS)
//
// Notice that currently setting this option under Windows will result in
// programs which can only run on recent OS versions (with ws2_32.dll
// installed) which is why it is disabled by default.
//
// Default is 1.
//
// Recommended setting: 1 if you need IPv6 support
#define wxUSE_IPV6 0
// Set to 1 to enable virtual file systems (required by wxHTML)
#define wxUSE_FILESYSTEM 1
// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ZIP 1
// Set to 1 to enable virtual archive filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ARCHIVE 1
// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_INET 1
// wxArchive classes for accessing archives such as zip and tar
#define wxUSE_ARCHIVE_STREAMS 1
// Set to 1 to compile wxZipInput/OutputStream classes.
#define wxUSE_ZIPSTREAM 1
// Set to 1 to compile wxTarInput/OutputStream classes.
#define wxUSE_TARSTREAM 1
// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
// wxUSE_LIBPNG
#define wxUSE_ZLIB 1
// Set to 1 if liblzma is available to enable wxLZMA{Input,Output}Stream
// classes.
//
// Notice that if you enable this build option when not using configure or
// CMake, you need to ensure that liblzma headers and libraries are available
// (i.e. by building the library yourself or downloading its binaries) and can
// be found, either by copying them to one of the locations searched by the
// compiler/linker by default (e.g. any of the directories in the INCLUDE or
// LIB environment variables, respectively, when using MSVC) or modify the
// make- or project files to add references to these directories.
//
// Default is 0 under MSW, auto-detected by configure.
//
// Recommended setting: 1 if you need LZMA compression.
#define wxUSE_LIBLZMA 0
// If enabled, the code written by Apple will be used to write, in a portable
// way, float on the disk. See extended.c for the license which is different
// from wxWidgets one.
//
// Default is 1.
//
// Recommended setting: 1 unless you don't like the license terms (unlikely)
#define wxUSE_APPLE_IEEE 1
// Joystick support class
#define wxUSE_JOYSTICK 1
// wxFontEnumerator class
#define wxUSE_FONTENUM 1
// wxFontMapper class
#define wxUSE_FONTMAP 1
// wxMimeTypesManager class
#define wxUSE_MIMETYPE 1
// wxProtocol and related classes: if you want to use either of wxFTP, wxHTTP
// or wxURL you need to set this to 1.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_PROTOCOL 1
// The settings for the individual URL schemes
#define wxUSE_PROTOCOL_FILE 1
#define wxUSE_PROTOCOL_FTP 1
#define wxUSE_PROTOCOL_HTTP 1
// Define this to use wxURL class.
#define wxUSE_URL 1
// Define this to use native platform url and protocol support.
// Currently valid only for MS-Windows.
// Note: if you set this to 1, you can open ftp/http/gopher sites
// and obtain a valid input stream for these sites
// even when you set wxUSE_PROTOCOL_FTP/HTTP to 0.
// Doing so reduces the code size.
//
// This code is experimental and subject to change.
#define wxUSE_URL_NATIVE 0
// Support for wxVariant class used in several places throughout the library,
// notably in wxDataViewCtrl API.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size as much as
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
// Support for wxAny class, the successor for wxVariant.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size by a small amount,
// or your compiler cannot for some reason cope with complexity of templates used.
#define wxUSE_ANY 1
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
//
// Default is 0
//
// Recommended setting: 1 if your compiler supports it, if it doesn't please
// contribute us a makefile for src/regex for it
#define wxUSE_REGEX 1
// wxSystemOptions class
#define wxUSE_SYSTEM_OPTIONS 1
// wxSound class
#define wxUSE_SOUND 1
// Use wxMediaCtrl
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_MEDIACTRL 1
// Use wxWidget's XRC XML-based resource system. Recommended.
//
// Default is 1
//
// Recommended setting: 1 (requires wxUSE_XML)
#define wxUSE_XRC 1
// XML parsing classes. Note that their API will change in the future, so
// using wxXmlDocument and wxXmlNode in your app is not recommended.
//
// Default is the same as wxUSE_XRC, i.e. 1 by default.
//
// Recommended setting: 1 (required by XRC)
#define wxUSE_XML wxUSE_XRC
// Use wxWidget's AUI docking system
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_AUI 1
// Use wxWidget's Ribbon classes for interfaces
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_RIBBON 1
// Use wxPropertyGrid.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_PROPGRID 1
// Use wxStyledTextCtrl, a wxWidgets implementation of Scintilla.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STC 1
// Use wxWidget's web viewing classes
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_WEBVIEW 1
// Use the IE wxWebView backend
//
// Default is 1 on MSW
//
// Recommended setting: 1
#ifdef __WXMSW__
#define wxUSE_WEBVIEW_IE 1
#else
#define wxUSE_WEBVIEW_IE 0
#endif
// Use the WebKit wxWebView backend
//
// Default is 1 on GTK and OSX
//
// Recommended setting: 1
#if (defined(__WXGTK__) && !defined(__WXGTK3__)) || defined(__WXOSX__)
#define wxUSE_WEBVIEW_WEBKIT 1
#else
#define wxUSE_WEBVIEW_WEBKIT 0
#endif
// Use the WebKit2 wxWebView backend
//
// Default is 1 on GTK3
//
// Recommended setting: 1
#if defined(__WXGTK3__)
#define wxUSE_WEBVIEW_WEBKIT2 1
#else
#define wxUSE_WEBVIEW_WEBKIT2 0
#endif
// Enable wxGraphicsContext and related classes for a modern 2D drawing API.
//
// Default is 1 except if you're using a compiler without support for GDI+
// under MSW, i.e. gdiplus.h and related headers (MSVC and MinGW >= 4.8 are
// known to have them). For other compilers (e.g. older mingw32) you may need
// to install the headers (and just the headers) yourself. If you do, change
// the setting below manually.
//
// Recommended setting: 1 if supported by the compilation environment
// Notice that we can't use wxCHECK_VISUALC_VERSION() nor wxCHECK_GCC_VERSION()
// here as this file is included from wx/platform.h before they're defined.
#if defined(_MSC_VER) || \
(defined(__MINGW32__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 8))
#define wxUSE_GRAPHICS_CONTEXT 1
#else
// Disable support for other Windows compilers, enable it if your compiler
// comes with new enough SDK or you installed the headers manually.
//
// Notice that this will be set by configure under non-Windows platforms
// anyhow so the value there is not important.
#define wxUSE_GRAPHICS_CONTEXT 0
#endif
// Enable wxGraphicsContext implementation using Cairo library.
//
// This is not needed under Windows and detected automatically by configure
// under other systems, however you may set this to 1 manually if you installed
// Cairo under Windows yourself and prefer to use it instead the native GDI+
// implementation.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_CAIRO 0
// ----------------------------------------------------------------------------
// Individual GUI controls
// ----------------------------------------------------------------------------
// You must set wxUSE_CONTROLS to 1 if you are using any controls at all
// (without it, wxControl class is not compiled)
//
// Default is 1
//
// Recommended setting: 1 (don't change except for very special programs)
#define wxUSE_CONTROLS 1
// Support markup in control labels, i.e. provide wxControl::SetLabelMarkup().
// Currently markup is supported only by a few controls and only some ports but
// their number will increase with time.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you want to save on code size)
#define wxUSE_MARKUP 1
// wxPopupWindow class is a top level transient window. It is currently used
// to implement wxTipWindow
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you don't wxUSE_TIPWINDOW)
#define wxUSE_POPUPWIN 1
// wxTipWindow allows to implement the custom tooltips, it is used by the
// context help classes. Requires wxUSE_POPUPWIN.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0)
#define wxUSE_TIPWINDOW 1
// Each of the settings below corresponds to one wxWidgets control. They are
// all switched on by default but may be disabled if you are sure that your
// program (including any standard dialogs it can show!) doesn't need them and
// if you desperately want to save some space. If you use any of these you must
// set wxUSE_CONTROLS as well.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_ACTIVITYINDICATOR 1 // wxActivityIndicator
#define wxUSE_ANIMATIONCTRL 1 // wxAnimationCtrl
#define wxUSE_BANNERWINDOW 1 // wxBannerWindow
#define wxUSE_BUTTON 1 // wxButton
#define wxUSE_BMPBUTTON 1 // wxBitmapButton
#define wxUSE_CALENDARCTRL 1 // wxCalendarCtrl
#define wxUSE_CHECKBOX 1 // wxCheckBox
#define wxUSE_CHECKLISTBOX 1 // wxCheckListBox (requires wxUSE_OWNER_DRAWN)
#define wxUSE_CHOICE 1 // wxChoice
#define wxUSE_COLLPANE 1 // wxCollapsiblePane
#define wxUSE_COLOURPICKERCTRL 1 // wxColourPickerCtrl
#define wxUSE_COMBOBOX 1 // wxComboBox
#define wxUSE_COMMANDLINKBUTTON 1 // wxCommandLinkButton
#define wxUSE_DATAVIEWCTRL 1 // wxDataViewCtrl
#define wxUSE_DATEPICKCTRL 1 // wxDatePickerCtrl
#define wxUSE_DIRPICKERCTRL 1 // wxDirPickerCtrl
#define wxUSE_EDITABLELISTBOX 1 // wxEditableListBox
#define wxUSE_FILECTRL 1 // wxFileCtrl
#define wxUSE_FILEPICKERCTRL 1 // wxFilePickerCtrl
#define wxUSE_FONTPICKERCTRL 1 // wxFontPickerCtrl
#define wxUSE_GAUGE 1 // wxGauge
#define wxUSE_HEADERCTRL 1 // wxHeaderCtrl
#define wxUSE_HYPERLINKCTRL 1 // wxHyperlinkCtrl
#define wxUSE_LISTBOX 1 // wxListBox
#define wxUSE_LISTCTRL 1 // wxListCtrl
#define wxUSE_RADIOBOX 1 // wxRadioBox
#define wxUSE_RADIOBTN 1 // wxRadioButton
#define wxUSE_RICHMSGDLG 1 // wxRichMessageDialog
#define wxUSE_SCROLLBAR 1 // wxScrollBar
#define wxUSE_SEARCHCTRL 1 // wxSearchCtrl
#define wxUSE_SLIDER 1 // wxSlider
#define wxUSE_SPINBTN 1 // wxSpinButton
#define wxUSE_SPINCTRL 1 // wxSpinCtrl
#define wxUSE_STATBOX 1 // wxStaticBox
#define wxUSE_STATLINE 1 // wxStaticLine
#define wxUSE_STATTEXT 1 // wxStaticText
#define wxUSE_STATBMP 1 // wxStaticBitmap
#define wxUSE_TEXTCTRL 1 // wxTextCtrl
#define wxUSE_TIMEPICKCTRL 1 // wxTimePickerCtrl
#define wxUSE_TOGGLEBTN 1 // requires wxButton
#define wxUSE_TREECTRL 1 // wxTreeCtrl
#define wxUSE_TREELISTCTRL 1 // wxTreeListCtrl
// Use a status bar class? Depending on the value of wxUSE_NATIVE_STATUSBAR
// below either wxStatusBar95 or a generic wxStatusBar will be used.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STATUSBAR 1
// Two status bar implementations are available under Win32: the generic one
// or the wrapper around native control. For native look and feel the native
// version should be used.
//
// Default is 1 for the platforms where native status bar is supported.
//
// Recommended setting: 1 (there is no advantage in using the generic one)
#define wxUSE_NATIVE_STATUSBAR 1
// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
// classes at all. Otherwise, use the native toolbar class unless
// wxUSE_TOOLBAR_NATIVE is 0.
//
// Default is 1 for all settings.
//
// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE.
#define wxUSE_TOOLBAR 1
#define wxUSE_TOOLBAR_NATIVE 1
// wxNotebook is a control with several "tabs" located on one of its sides. It
// may be used to logically organise the data presented to the user instead of
// putting everything in one huge dialog. It replaces wxTabControl and related
// classes of wxWin 1.6x.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTEBOOK 1
// wxListbook control is similar to wxNotebook but uses wxListCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_LISTBOOK 1
// wxChoicebook control is similar to wxNotebook but uses wxChoice instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CHOICEBOOK 1
// wxTreebook control is similar to wxNotebook but uses wxTreeCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TREEBOOK 1
// wxToolbook control is similar to wxNotebook but uses wxToolBar instead of
// tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLBOOK 1
// wxTaskBarIcon is a small notification icon shown in the system toolbar or
// dock.
//
// Default is 1.
//
// Recommended setting: 1 (but can be set to 0 if you don't need it)
#define wxUSE_TASKBARICON 1
// wxGrid class
//
// Default is 1, set to 0 to cut down compilation time and binaries size if you
// don't use it.
//
// Recommended setting: 1
//
#define wxUSE_GRID 1
// wxMiniFrame class: a frame with narrow title bar
//
// Default is 1.
//
// Recommended setting: 1 (it doesn't cost almost anything)
#define wxUSE_MINIFRAME 1
// wxComboCtrl and related classes: combobox with custom popup window and
// not necessarily a listbox.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 except for wxUniv where it
// it used by wxComboBox
#define wxUSE_COMBOCTRL 1
// wxOwnerDrawnComboBox is a custom combobox allowing to paint the combobox
// items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0, except where it is
// needed as a base class for generic wxBitmapComboBox.
#define wxUSE_ODCOMBOBOX 1
// wxBitmapComboBox is a combobox that can have images in front of text items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0
#define wxUSE_BITMAPCOMBOBOX 1
// wxRearrangeCtrl is a wxCheckListBox with two buttons allowing to move items
// up and down in it. It is also used as part of wxRearrangeDialog.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 (currently used only by
// wxHeaderCtrl)
#define wxUSE_REARRANGECTRL 1
// wxAddRemoveCtrl is a composite control containing a control showing some
// items (e.g. wxListBox, wxListCtrl, wxTreeCtrl, wxDataViewCtrl, ...) and "+"/
// "-" buttons allowing to add and remove items to/from the control.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 if you don't need it (not
// used by the library itself).
#define wxUSE_ADDREMOVECTRL 1
// ----------------------------------------------------------------------------
// Miscellaneous GUI stuff
// ----------------------------------------------------------------------------
// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
#define wxUSE_ACCEL 1
// Use the standard art provider. The icons returned by this provider are
// embedded into the library as XPMs so disabling it reduces the library size
// somewhat but this should only be done if you use your own custom art
// provider returning the icons or never use any icons not provided by the
// native art provider (which might not be implemented at all for some
// platforms) or by the Tango icons provider (if it's not itself disabled
// below).
//
// Default is 1.
//
// Recommended setting: 1 unless you use your own custom art provider.
#define wxUSE_ARTPROVIDER_STD 1
// Use art provider providing Tango icons: this art provider has higher quality
// icons than the default ones using smaller size XPM icons without
// transparency but the embedded PNG icons add to the library size.
//
// Default is 1 under non-GTK ports. Under wxGTK the native art provider using
// the GTK+ stock icons replaces it so it is normally not necessary.
//
// Recommended setting: 1 but can be turned off to reduce the library size.
#define wxUSE_ARTPROVIDER_TANGO 1
// Hotkey support (currently Windows only)
#define wxUSE_HOTKEY 1
// Use wxCaret: a class implementing a "cursor" in a text control (called caret
// under Windows).
//
// Default is 1.
//
// Recommended setting: 1 (can be safely set to 0, not used by the library)
#define wxUSE_CARET 1
// Use wxDisplay class: it allows enumerating all displays on a system and
// their geometries as well as finding the display on which the given point or
// window lies.
//
// Default is 1.
//
// Recommended setting: 1 if you need it, can be safely set to 0 otherwise
#define wxUSE_DISPLAY 1
// Miscellaneous geometry code: needed for Canvas library
#define wxUSE_GEOMETRY 1
// Use wxImageList. This class is needed by wxNotebook, wxTreeCtrl and
// wxListCtrl.
//
// Default is 1.
//
// Recommended setting: 1 (set it to 0 if you don't use any of the controls
// enumerated above, then this class is mostly useless too)
#define wxUSE_IMAGLIST 1
// Use wxInfoBar class.
//
// Default is 1.
//
// Recommended setting: 1 (but can be disabled without problems as nothing
// depends on it)
#define wxUSE_INFOBAR 1
// Use wxMenu, wxMenuBar, wxMenuItem.
//
// Default is 1.
//
// Recommended setting: 1 (can't be disabled under MSW)
#define wxUSE_MENUS 1
// Use wxNotificationMessage.
//
// wxNotificationMessage allows to show non-intrusive messages to the user
// using balloons, banners, popups or whatever is the appropriate method for
// the current platform.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTIFICATION_MESSAGE 1
// wxPreferencesEditor provides a common API for different ways of presenting
// the standard "Preferences" or "Properties" dialog under different platforms
// (e.g. some use modal dialogs, some use modeless ones; some apply the changes
// immediately while others require an explicit "Apply" button).
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_PREFERENCES_EDITOR 1
// wxFont::AddPrivateFont() allows to use fonts not installed on the system by
// loading them from font files during run-time.
//
// Default is 1 except under Unix where it will be turned off by configure if
// the required libraries are not available or not new enough.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it and
// want to avoid extra dependencies under Linux, for example).
#define wxUSE_PRIVATE_FONTS 1
// wxRichToolTip is a customizable tooltip class which has more functionality
// than the stock (but native, unlike this class) wxToolTip.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely set to 0 if you don't need it)
#define wxUSE_RICHTOOLTIP 1
// Use wxSashWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SASH 1
// Use wxSplitterWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SPLITTER 1
// Use wxToolTip and wxWindow::Set/GetToolTip() methods.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLTIPS 1
// wxValidator class and related methods
#define wxUSE_VALIDATORS 1
// Use reference counted ID management: this means that wxWidgets will track
// the automatically allocated ids (those used when you use wxID_ANY when
// creating a window, menu or toolbar item &c) instead of just supposing that
// the program never runs out of them. This is mostly useful only under wxMSW
// where the total ids range is limited to SHRT_MIN..SHRT_MAX and where
// long-running programs can run into problems with ids reuse without this. On
// the other platforms, where the ids have the full int range, this shouldn't
// be necessary.
#ifdef __WXMSW__
#define wxUSE_AUTOID_MANAGEMENT 1
#else
#define wxUSE_AUTOID_MANAGEMENT 0
#endif
// ----------------------------------------------------------------------------
// common dialogs
// ----------------------------------------------------------------------------
// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
// file selector, printer dialog). Switching this off also switches off the
// printing architecture and interactive wxPrinterDC.
//
// Default is 1
//
// Recommended setting: 1 (unless it really doesn't work)
#define wxUSE_COMMON_DIALOGS 1
// wxBusyInfo displays window with message when app is busy. Works in same way
// as wxBusyCursor
#define wxUSE_BUSYINFO 1
// Use single/multiple choice dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_CHOICEDLG 1
// Use colour picker dialog
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_COLOURDLG 1
// wxDirDlg class for getting a directory name from user
#define wxUSE_DIRDLG 1
// TODO: setting to choose the generic or native one
// Use file open/save dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in many places in the library itself)
#define wxUSE_FILEDLG 1
// Use find/replace dialogs.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely set to 0)
#define wxUSE_FINDREPLDLG 1
// Use font picker dialog
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_FONTDLG 1
// Use wxMessageDialog and wxMessageBox.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_MSGDLG 1
// progress dialog class for lengthy operations
#define wxUSE_PROGRESSDLG 1
// Set to 0 to disable the use of the native progress dialog (currently only
// available under MSW and suffering from some bugs there, hence this option).
#define wxUSE_NATIVE_PROGRESSDLG 1
// support for startup tips (wxShowTip &c)
#define wxUSE_STARTUP_TIPS 1
// text entry dialog and wxGetTextFromUser function
#define wxUSE_TEXTDLG 1
// number entry dialog
#define wxUSE_NUMBERDLG 1
// splash screen class
#define wxUSE_SPLASH 1
// wizards
#define wxUSE_WIZARDDLG 1
// Compile in wxAboutBox() function showing the standard "About" dialog.
//
// Default is 1
//
// Recommended setting: 1 but can be set to 0 to save some space if you don't
// use this function
#define wxUSE_ABOUTDLG 1
// wxFileHistory class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FILE_HISTORY 1
// ----------------------------------------------------------------------------
// Metafiles support
// ----------------------------------------------------------------------------
// Windows supports the graphics format known as metafile which, though not
// portable, is widely used under Windows and so is supported by wxWidgets
// (under Windows only, of course). Both the so-called "Window MetaFiles" or
// WMFs, and "Enhanced MetaFiles" or EMFs are supported in wxWin and, by
// default, EMFs will be used. This may be changed by setting
// wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting wxUSE_ENH_METAFILE to 0.
// You may also set wxUSE_METAFILE to 0 to not compile in any metafile
// related classes at all.
//
// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
//
// Recommended setting: default or 0 for everything for portable programs.
#define wxUSE_METAFILE 1
#define wxUSE_ENH_METAFILE 1
#define wxUSE_WIN_METAFILES_ALWAYS 0
// ----------------------------------------------------------------------------
// Big GUI components
// ----------------------------------------------------------------------------
// Set to 0 to disable MDI support.
//
// Requires wxUSE_NOTEBOOK under platforms other than MSW.
//
// Default is 1.
//
// Recommended setting: 1, can be safely set to 0.
#define wxUSE_MDI 1
// Set to 0 to disable document/view architecture
#define wxUSE_DOC_VIEW_ARCHITECTURE 1
// Set to 0 to disable MDI document/view architecture
//
// Requires wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 1
// Set to 0 to disable print/preview architecture code
#define wxUSE_PRINTING_ARCHITECTURE 1
// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
// much more.
//
// Default is 1.
//
// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
// smaller library.
#define wxUSE_HTML 1
// Setting wxUSE_GLCANVAS to 1 enables OpenGL support. You need to have OpenGL
// headers and libraries to be able to compile the library with wxUSE_GLCANVAS
// set to 1 and, under Windows, also to add opengl32.lib and glu32.lib to the
// list of libraries used to link your application (although this is done
// implicitly for Microsoft Visual C++ users).
//
// Default is 1.
//
// Recommended setting: 1 if you intend to use OpenGL, can be safely set to 0
// otherwise.
#define wxUSE_GLCANVAS 1
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 if you want compile a
// smaller library.
#define wxUSE_RICHTEXT 1
// ----------------------------------------------------------------------------
// Data transfer
// ----------------------------------------------------------------------------
// Use wxClipboard class for clipboard copy/paste.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CLIPBOARD 1
// Use wxDataObject and related classes. Needed for clipboard and OLE drag and
// drop
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DATAOBJ 1
// Use wxDropTarget and wxDropSource classes for drag and drop (this is
// different from "built in" drag and drop in wxTreeCtrl which is always
// available). Requires wxUSE_DATAOBJ.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DRAG_AND_DROP 1
// Use wxAccessible for enhanced and customisable accessibility.
// Depends on wxUSE_OLE on MSW.
//
// Default is 1 on MSW, 0 elsewhere.
//
// Recommended setting (at present): 1 (MSW-only)
#ifdef __WXMSW__
#define wxUSE_ACCESSIBILITY 1
#else
#define wxUSE_ACCESSIBILITY 0
#endif
// ----------------------------------------------------------------------------
// miscellaneous settings
// ----------------------------------------------------------------------------
// wxSingleInstanceChecker class allows to verify at startup if another program
// instance is running.
//
// Default is 1
//
// Recommended setting: 1 (the class is tiny, disabling it won't save much
// space)
#define wxUSE_SNGLINST_CHECKER 1
#define wxUSE_DRAGIMAGE 1
#define wxUSE_IPC 1
// 0 for no interprocess comms
#define wxUSE_HELP 1
// 0 for no help facility
// Should we use MS HTML help for wxHelpController? If disabled, neither
// wxCHMHelpController nor wxBestHelpController are available.
//
// Default is 1 under MSW, 0 is always used for the other platforms.
//
// Recommended setting: 1, only set to 0 if you have trouble compiling
// wxCHMHelpController (could be a problem with really ancient compilers)
#define wxUSE_MS_HTML_HELP 1
// Use wxHTML-based help controller?
#define wxUSE_WXHTML_HELP 1
#define wxUSE_CONSTRAINTS 1
// 0 for no window layout constraint system
#define wxUSE_SPLINES 1
// 0 for no splines
#define wxUSE_MOUSEWHEEL 1
// Include mouse wheel support
// Compile wxUIActionSimulator class?
#define wxUSE_UIACTIONSIMULATOR 1
// ----------------------------------------------------------------------------
// wxDC classes for various output formats
// ----------------------------------------------------------------------------
// Set to 1 for PostScript device context.
#define wxUSE_POSTSCRIPT 0
// Set to 1 to use font metric files in GetTextExtent
#define wxUSE_AFM_FOR_POSTSCRIPT 1
// Set to 1 to compile in support for wxSVGFileDC, a wxDC subclass which allows
// to create files in SVG (Scalable Vector Graphics) format.
#define wxUSE_SVG 1
// Should wxDC provide SetTransformMatrix() and related methods?
//
// Default is 1 but can be set to 0 if this functionality is not used. Notice
// that currently wxMSW, wxGTK3 support this for wxDC and all platforms support
// this for wxGCDC so setting this to 0 doesn't change much if neither of these
// is used (although it will still save a few bytes probably).
//
// Recommended setting: 1.
#define wxUSE_DC_TRANSFORM_MATRIX 1
// ----------------------------------------------------------------------------
// image format support
// ----------------------------------------------------------------------------
// wxImage supports many different image formats which can be configured at
// compile-time. BMP is always supported, others are optional and can be safely
// disabled if you don't plan to use images in such format sometimes saving
// substantial amount of code in the final library.
//
// Some formats require an extra library which is included in wxWin sources
// which is mentioned if it is the case.
// Set to 1 for wxImage support (recommended).
#define wxUSE_IMAGE 1
// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
#define wxUSE_LIBPNG 1
// Set to 1 for JPEG format support (requires libjpeg)
#define wxUSE_LIBJPEG 1
// Set to 1 for TIFF format support (requires libtiff)
#define wxUSE_LIBTIFF 1
// Set to 1 for TGA format support (loading only)
#define wxUSE_TGA 1
// Set to 1 for GIF format support
#define wxUSE_GIF 1
// Set to 1 for PNM format support
#define wxUSE_PNM 1
// Set to 1 for PCX format support
#define wxUSE_PCX 1
// Set to 1 for IFF format support (Amiga format)
#define wxUSE_IFF 0
// Set to 1 for XPM format support
#define wxUSE_XPM 1
// Set to 1 for MS Icons and Cursors format support
#define wxUSE_ICO_CUR 1
// Set to 1 to compile in wxPalette class
#define wxUSE_PALETTE 1
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
/* --- end common options --- */
/* --- start MSW options --- */
// ----------------------------------------------------------------------------
// Graphics backends choices for Windows
// ----------------------------------------------------------------------------
// The options here are only taken into account if wxUSE_GRAPHICS_CONTEXT is 1.
// Enable support for GDI+-based implementation of wxGraphicsContext.
//
// Default is 1.
//
// Recommended setting: 1 if you need to support XP, as Direct2D is not
// available there.
#define wxUSE_GRAPHICS_GDIPLUS wxUSE_GRAPHICS_CONTEXT
// Enable support for Direct2D-based implementation of wxGraphicsContext.
//
// Default is 1 for compilers which support it, i.e. VC10+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1 for faster and better quality graphics under Windows
// 7 and later systems (if wxUSE_GRAPHICS_GDIPLUS is also enabled, earlier
// systems will fall back on using GDI+).
#if defined(_MSC_VER) && _MSC_VER >= 1600
#define wxUSE_GRAPHICS_DIRECT2D wxUSE_GRAPHICS_CONTEXT
#else
#define wxUSE_GRAPHICS_DIRECT2D 0
#endif
// ----------------------------------------------------------------------------
// Windows-only settings
// ----------------------------------------------------------------------------
// Set this to 1 for generic OLE support: this is required for drag-and-drop,
// clipboard, OLE Automation. Only set it to 0 if your compiler is very old and
// can't compile/doesn't have the OLE headers.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_OLE 1
// Set this to 1 to enable wxAutomationObject class.
//
// Default is 1.
//
// Recommended setting: 1 if you need to control other applications via OLE
// Automation, can be safely set to 0 otherwise
#define wxUSE_OLE_AUTOMATION 1
// Set this to 1 to enable wxActiveXContainer class allowing to embed OLE
// controls in wx.
//
// Default is 1.
//
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
// Enable WinRT support
//
// Default is 1 for compilers which support it, i.e. VS2012+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1
#if defined(_MSC_VER) && _MSC_VER >= 1700 && !defined(_USING_V110_SDK71_)
#define wxUSE_WINRT 1
#else
#define wxUSE_WINRT 0
#endif
// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
// wxBitmap data.
//
// Default is 1, set it to 0 only if you don't use wxImage neither
//
// Recommended setting: 1 (without it conversion to/from wxImage won't work)
#define wxUSE_WXDIB 1
// Set to 0 to disable PostScript print/preview architecture code under Windows
// (just use Windows printing).
#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
// Set this to 1 to compile in wxRegKey class.
//
// Default is 1
//
// Recommended setting: 1, this is used internally by wx in a few places
#define wxUSE_REGKEY 1
// Set this to 1 to use RICHEDIT controls for wxTextCtrl with style wxTE_RICH
// which allows to put more than ~32Kb of text in it even under Win9x (NT
// doesn't have such limitation).
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1, only set it to 0 if your compiler doesn't have
// or can't compile <richedit.h>
#define wxUSE_RICHEDIT 1
// Set this to 1 to use extra features of richedit v2 and later controls
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1
#define wxUSE_RICHEDIT2 1
// Set this to 1 to enable support for the owner-drawn menu and listboxes. This
// is required by wxUSE_CHECKLISTBOX.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a small library size reduction
#define wxUSE_OWNER_DRAWN 1
// Set this to 1 to enable MSW-specific wxTaskBarIcon::ShowBalloon() method. It
// is required by native wxNotificationMessage implementation.
//
// Default is 1 but disabled in wx/msw/chkconf.h if SDK is too old to contain
// the necessary declarations.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARICON_BALLOONS 1
// Set this to 1 to enable following functionality added in Windows 7: thumbnail
// representations, thumbnail toolbars, notification and status overlays,
// progress indicators and jump lists.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARBUTTON 1
// Set to 1 to compile MS Windows XP theme engine support
#define wxUSE_UXTHEME 1
// Set to 1 to use InkEdit control (Tablet PC), if available
#define wxUSE_INKEDIT 0
// Set to 1 to enable .INI files based wxConfig implementation (wxIniConfig)
//
// Default is 0.
//
// Recommended setting: 0, nobody uses .INI files any more
#define wxUSE_INICONF 0
// ----------------------------------------------------------------------------
// Generic versions of native controls
// ----------------------------------------------------------------------------
// Set this to 1 to be able to use wxDatePickerCtrlGeneric in addition to the
// native wxDatePickerCtrl
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_DATEPICKCTRL_GENERIC 0
// Set this to 1 to be able to use wxTimePickerCtrlGeneric in addition to the
// native wxTimePickerCtrl for the platforms that have the latter (MSW).
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_TIMEPICKCTRL_GENERIC 0
// ----------------------------------------------------------------------------
// Crash debugging helpers
// ----------------------------------------------------------------------------
// Set this to 1 to use dbghelp.dll for providing stack traces in crash
// reports.
//
// Default is 1 if the compiler supports it, 0 for old MinGW.
//
// Recommended setting: 1, there is not much gain in disabling this
#if defined(__VISUALC__) || defined(__MINGW64_TOOLCHAIN__)
#define wxUSE_DBGHELP 1
#else
#define wxUSE_DBGHELP 0
#endif
// Set this to 1 to be able to use wxCrashReport::Generate() to create mini
// dumps of your program when it crashes (or at any other moment)
//
// Default is 1 if supported by the compiler (VC++ and recent BC++ only).
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_CRASHREPORT 1
/* --- end MSW options --- */
#endif // _WX_SETUP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/lib/vc_dll/mswud/wx/msw/rcdefs.h |
#ifndef _WX_RCDEFS_H
#define _WX_RCDEFS_H
#define WX_CPU_X86
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/msvc/wx/setup.h | /////////////////////////////////////////////////////////////////////////////
// Name: msvc/wx/setup.h
// Purpose: wrapper around the real wx/setup.h for Visual C++
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-12-12
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _MSC_VER
#error "This file should only be included when using Microsoft Visual C++"
#endif
// VC++ IDE predefines _DEBUG and _UNICODE for the new projects itself, but
// the other symbols (WXUSINGDLL, __WXUNIVERSAL__, ...) should be defined
// explicitly!
#include "wx/version.h"
#include "wx/cpp.h"
// notice that wxSUFFIX_DEBUG is a string but wxSUFFIX itself must be an
// identifier as string concatenation is not done inside #include where we
// need it
#ifdef _DEBUG
#define wxSUFFIX_DEBUG "d"
#ifdef _UNICODE
#define wxSUFFIX ud
#else // !_UNICODE
#define wxSUFFIX d
#endif // _UNICODE/!_UNICODE
#else
#define wxSUFFIX_DEBUG ""
#ifdef _UNICODE
#define wxSUFFIX u
#else // !_UNICODE
// don't define wxSUFFIX at all as preprocessor operations don't work
// with empty values so we need to check for this case specially below
#endif // _UNICODE/!_UNICODE
#endif
// compiler-specific prefix: by default it's always just "vc" for compatibility
// reasons but if you use multiple MSVC versions you probably build them with
// COMPILER_PREFIX=vcXX and in this case you may want to either predefine
// wxMSVC_VERSION as "XX" or define wxMSVC_VERSION_AUTO to use the appropriate
// version depending on the compiler used
#ifdef wxMSVC_VERSION
#define wxCOMPILER_PREFIX wxCONCAT(vc, wxMSVC_VERSION)
#elif defined(wxMSVC_VERSION_AUTO)
#if _MSC_VER == 1200
#define wxCOMPILER_PREFIX vc60
#elif _MSC_VER == 1300
#define wxCOMPILER_PREFIX vc70
#elif _MSC_VER == 1310
#define wxCOMPILER_PREFIX vc71
#elif _MSC_VER == 1400
#define wxCOMPILER_PREFIX vc80
#elif _MSC_VER == 1500
#define wxCOMPILER_PREFIX vc90
#elif _MSC_VER == 1600
#define wxCOMPILER_PREFIX vc100
#elif _MSC_VER == 1700
#define wxCOMPILER_PREFIX vc110
#elif _MSC_VER == 1800
#define wxCOMPILER_PREFIX vc120
#elif _MSC_VER == 1900
#define wxCOMPILER_PREFIX vc140
#elif _MSC_VER >= 1910 && _MSC_VER < 2000
#define wxCOMPILER_PREFIX vc141
#else
#error "Unknown MSVC compiler version, please report to wx-dev."
#endif
#else
#define wxCOMPILER_PREFIX vc
#endif
// architecture-specific part: not used (again, for compatibility), for x86
#if defined(_M_X64)
#define wxARCH_SUFFIX _x64
#elif defined(_M_ARM64)
#define wxARCH_SUFFIX _arm64
#elif defined(_M_IA64)
#define wxARCH_SUFFIX _ia64
#else // assume _M_IX86
#define wxARCH_SUFFIX
#endif
// Ensure the library configuration is defined
#ifndef wxCFG
#define wxCFG
#endif
// Construct the path for the subdirectory under /lib/ that the included setup.h
// will be used from
#ifdef WXUSINGDLL
#define wxLIB_SUBDIR \
wxCONCAT4(wxCOMPILER_PREFIX, wxARCH_SUFFIX, _dll, wxCFG)
#else // !DLL
#define wxLIB_SUBDIR \
wxCONCAT4(wxCOMPILER_PREFIX, wxARCH_SUFFIX, _lib, wxCFG)
#endif // DLL/!DLL
// The user can predefine a different prefix if not using the default MSW port
// with MSVC.
#ifndef wxTOOLKIT_PREFIX
#if defined(__WXGTK__)
#define wxTOOLKIT_PREFIX gtk2
#else
#define wxTOOLKIT_PREFIX msw
#endif
#endif // wxTOOLKIT_PREFIX
// the real setup.h header file we need is in the build-specific directory,
// construct the path to it
#ifdef wxSUFFIX
#define wxSETUPH_PATH \
wxCONCAT6(../../../lib/, wxLIB_SUBDIR, /, wxTOOLKIT_PREFIX, wxSUFFIX, /wx/setup.h)
#else // suffix is empty
#define wxSETUPH_PATH \
wxCONCAT5(../../../lib/, wxLIB_SUBDIR, /, wxTOOLKIT_PREFIX, /wx/setup.h)
#endif
#define wxSETUPH_PATH_STR wxSTRINGIZE(wxSETUPH_PATH)
#include wxSETUPH_PATH_STR
// the library names depend on the build, these macro builds the correct
// library name for the given base name
#ifdef wxSUFFIX
#define wxSUFFIX_STR wxSTRINGIZE(wxSUFFIX)
#else // suffix is empty
#define wxSUFFIX_STR ""
#endif
#define wxSHORT_VERSION_STRING \
wxSTRINGIZE(wxMAJOR_VERSION) wxSTRINGIZE(wxMINOR_VERSION)
#define wxWX_LIB_NAME(name, subname) \
"wx" name wxSHORT_VERSION_STRING wxSUFFIX_STR subname
#define wxBASE_LIB_NAME(name) wxWX_LIB_NAME("base", "_" name)
#define wxTOOLKIT_LIB_NAME(name) wxWX_LIB_NAME(wxSTRINGIZE(wxTOOLKIT_PREFIX), "_" name)
// This one is for 3rd party libraries: they don't have the version number
// in their names and usually exist in ANSI version only (except for regex)
//
// 3rd party libraries are also are not linked in when using DLLs as they're
// embedded inside our own DLLs and don't need to be linked with the user code.
#define wx3RD_PARTY_LIB_NAME(name) "wx" name wxSUFFIX_DEBUG
// special version for regex as it does have a Unicode version
#define wx3RD_PARTY_LIB_NAME_U(name) "wx" name wxSUFFIX_STR
#if defined(wxMONOLITHIC) && wxMONOLITHIC == 1
#pragma comment(lib, wxWX_LIB_NAME("msw", ""))
#else
#pragma comment(lib, wxWX_LIB_NAME("base", ""))
#ifndef wxNO_NET_LIB
#pragma comment(lib, wxBASE_LIB_NAME("net"))
#endif
#if wxUSE_XML && !defined(wxNO_XML_LIB)
#pragma comment(lib, wxBASE_LIB_NAME("xml"))
#endif
#endif // defined(wxMONOLITHIC) && wxMONOLITHIC == 1
#if !defined(WXUSINGDLL)
#if !defined(wxNO_NET_LIB)
#pragma comment(lib, "wsock32")
#endif
#if wxUSE_XML && !defined(wxNO_XML_LIB) && !defined(wxNO_EXPAT_LIB)
#pragma comment(lib, wx3RD_PARTY_LIB_NAME("expat"))
#endif
#if wxUSE_REGEX && !defined(wxNO_REGEX_LIB)
#pragma comment(lib, wx3RD_PARTY_LIB_NAME_U("regex"))
#endif
#if wxUSE_ZLIB && !defined(wxNO_ZLIB_LIB)
#pragma comment(lib, wx3RD_PARTY_LIB_NAME("zlib"))
#endif
#endif // !defined(WXUSINGDLL)
#if wxUSE_GUI
#if !defined(WXUSINGDLL)
#if wxUSE_LIBJPEG && !defined(wxNO_JPEG_LIB)
#pragma comment(lib, wx3RD_PARTY_LIB_NAME("jpeg"))
#endif
#if wxUSE_LIBPNG && !defined(wxNO_PNG_LIB)
#pragma comment(lib, wx3RD_PARTY_LIB_NAME("png"))
#endif
#if wxUSE_LIBTIFF && !defined(wxNO_TIFF_LIB)
#pragma comment(lib, wx3RD_PARTY_LIB_NAME("tiff"))
#endif
#if wxUSE_STC && !defined(wxNO_STC_LIB)
#pragma comment(lib, wx3RD_PARTY_LIB_NAME("scintilla"))
#endif
#endif // !defined(WXUSINGDLL)
#if !defined(wxMONOLITHIC) || wxMONOLITHIC == 0
#pragma comment(lib, wxTOOLKIT_LIB_NAME("core"))
#if wxUSE_HTML && !defined(wxNO_HTML_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("html"))
#endif
#if wxUSE_DEBUGREPORT && !defined(wxNO_QA_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("qa"))
#endif
#if wxUSE_XRC && !defined(wxNO_XRC_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("xrc"))
#endif
#if wxUSE_AUI && !defined(wxNO_AUI_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("aui"))
#endif
#if wxUSE_PROPGRID && !defined(wxNO_PROPGRID_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("propgrid"))
#endif
#if wxUSE_RIBBON && !defined(wxNO_RIBBON_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("ribbon"))
#endif
#if wxUSE_RICHTEXT && !defined(wxNO_RICHTEXT_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("richtext"))
#endif
#if wxUSE_MEDIACTRL && !defined(wxNO_MEDIA_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("media"))
#endif
#if wxUSE_STC && !defined(wxNO_STC_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("stc"))
#endif
#if wxUSE_WEBVIEW && !defined(wxNO_WEBVIEW_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("webview"))
#endif
#endif // !defined(wxMONOLITHIC) || wxMONOLITHIC == 0
#if wxUSE_GLCANVAS && !defined(wxNO_GL_LIB)
#pragma comment(lib, wxTOOLKIT_LIB_NAME("gl"))
#endif
#endif // wxUSE_GUI
#ifndef WXUSINGDLL
// Make sure all required system libraries are added to the linker too when
// using static libraries.
#pragma comment(lib, "kernel32")
#pragma comment(lib, "user32")
#pragma comment(lib, "gdi32")
#pragma comment(lib, "comdlg32")
#pragma comment(lib, "winspool")
#pragma comment(lib, "winmm")
#pragma comment(lib, "shell32")
#pragma comment(lib, "comctl32")
#pragma comment(lib, "ole32")
#pragma comment(lib, "oleaut32")
#pragma comment(lib, "uuid")
#pragma comment(lib, "rpcrt4")
#pragma comment(lib, "advapi32")
#if wxUSE_URL_NATIVE
#pragma comment(lib, "wininet")
#endif
#ifdef __WXGTK__
#ifdef __WXGTK3__
#pragma comment(lib, "libgtk-3.dll.a")
#pragma comment(lib, "libgdk-3.dll.a")
#else
#pragma comment(lib, "gtk-win32-2.0.lib")
#pragma comment(lib, "gdk-win32-2.0.lib")
#endif
#pragma comment(lib, "pangocairo-1.0.lib")
#pragma comment(lib, "gdk_pixbuf-2.0.lib")
#pragma comment(lib, "cairo.lib")
#pragma comment(lib, "pango-1.0.lib")
#pragma comment(lib, "gobject-2.0.lib")
#pragma comment(lib, "gthread-2.0.lib")
#pragma comment(lib, "glib-2.0.lib")
#endif
#endif // !WXUSINGDLL
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/metafile.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/metafile.h
// Purpose: wxMetaFile class declaration
// Author: wxWidgets team
// Modified by:
// Created: 13.01.00
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_METAFILE_H_BASE_
#define _WX_METAFILE_H_BASE_
#include "wx/defs.h"
#if wxUSE_METAFILE
// provide synonyms for all metafile classes
#define wxMetaFile wxMetafile
#define wxMetaFileDC wxMetafileDC
#define wxMetaFileDataObject wxMetafileDataObject
#define wxMakeMetaFilePlaceable wxMakeMetafilePlaceable
#if defined(__WXMSW__)
#if wxUSE_ENH_METAFILE
#include "wx/msw/enhmeta.h"
#if wxUSE_WIN_METAFILES_ALWAYS
// use normal metafiles as well
#include "wx/msw/metafile.h"
#else // also map all metafile classes to enh metafile
typedef wxEnhMetaFile wxMetafile;
typedef wxEnhMetaFileDC wxMetafileDC;
#if wxUSE_DATAOBJ
typedef wxEnhMetaFileDataObject wxMetafileDataObject;
#endif
// this flag will be set if wxMetafile class is wxEnhMetaFile
#define wxMETAFILE_IS_ENH
#endif // wxUSE_WIN_METAFILES_ALWAYS
#else // !wxUSE_ENH_METAFILE
#include "wx/msw/metafile.h"
#endif
#elif defined(__WXMAC__)
#include "wx/osx/metafile.h"
#endif
#endif // wxUSE_METAFILE
#endif // _WX_METAFILE_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/fs_zip.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/fs_zip.h
// Purpose: wxZipFSHandler typedef for compatibility
// Author: Mike Wetherell
// Copyright: (c) 2006 Mike Wetherell
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FS_ZIP_H_
#define _WX_FS_ZIP_H_
#include "wx/defs.h"
#if wxUSE_FS_ZIP
#include "wx/fs_arc.h"
typedef wxArchiveFSHandler wxZipFSHandler;
#endif // wxUSE_FS_ZIP
#endif // _WX_FS_ZIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/imagbmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/imagbmp.h
// Purpose: wxImage BMP, ICO, CUR and ANI handlers
// Author: Robert Roebling, Chris Elliott
// Copyright: (c) Robert Roebling, Chris Elliott
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGBMP_H_
#define _WX_IMAGBMP_H_
#include "wx/image.h"
// defines for saving the BMP file in different formats, Bits Per Pixel
// USE: wximage.SetOption( wxIMAGE_OPTION_BMP_FORMAT, wxBMP_xBPP );
#define wxIMAGE_OPTION_BMP_FORMAT wxString(wxT("wxBMP_FORMAT"))
// These two options are filled in upon reading CUR file and can (should) be
// specified when saving a CUR file - they define the hotspot of the cursor:
#define wxIMAGE_OPTION_CUR_HOTSPOT_X wxT("HotSpotX")
#define wxIMAGE_OPTION_CUR_HOTSPOT_Y wxT("HotSpotY")
enum
{
wxBMP_24BPP = 24, // default, do not need to set
//wxBMP_16BPP = 16, // wxQuantize can only do 236 colors?
wxBMP_8BPP = 8, // 8bpp, quantized colors
wxBMP_8BPP_GREY = 9, // 8bpp, rgb averaged to greys
wxBMP_8BPP_GRAY = wxBMP_8BPP_GREY,
wxBMP_8BPP_RED = 10, // 8bpp, red used as greyscale
wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
wxBMP_4BPP = 4, // 4bpp, quantized colors
wxBMP_1BPP = 1, // 1bpp, quantized "colors"
wxBMP_1BPP_BW = 2 // 1bpp, black & white from red
};
// ----------------------------------------------------------------------------
// wxBMPHandler
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBMPHandler : public wxImageHandler
{
public:
wxBMPHandler()
{
m_name = wxT("Windows bitmap file");
m_extension = wxT("bmp");
m_type = wxBITMAP_TYPE_BMP;
m_mime = wxT("image/x-bmp");
}
#if wxUSE_STREAMS
virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=true ) wxOVERRIDE;
virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=true, int index=-1 ) wxOVERRIDE;
protected:
virtual bool DoCanRead( wxInputStream& stream ) wxOVERRIDE;
bool SaveDib(wxImage *image, wxOutputStream& stream, bool verbose,
bool IsBmp, bool IsMask);
bool DoLoadDib(wxImage *image, int width, int height, int bpp, int ncolors,
int comp, wxFileOffset bmpOffset, wxInputStream& stream,
bool verbose, bool IsBmp, bool hasPalette, int colEntrySize = 4);
bool LoadDib(wxImage *image, wxInputStream& stream, bool verbose, bool IsBmp);
#endif // wxUSE_STREAMS
private:
wxDECLARE_DYNAMIC_CLASS(wxBMPHandler);
};
#if wxUSE_ICO_CUR
// ----------------------------------------------------------------------------
// wxICOHandler
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxICOHandler : public wxBMPHandler
{
public:
wxICOHandler()
{
m_name = wxT("Windows icon file");
m_extension = wxT("ico");
m_type = wxBITMAP_TYPE_ICO;
m_mime = wxT("image/x-ico");
}
#if wxUSE_STREAMS
virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=true ) wxOVERRIDE;
virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=true, int index=-1 ) wxOVERRIDE;
virtual bool DoLoadFile( wxImage *image, wxInputStream& stream, bool verbose, int index );
protected:
virtual int DoGetImageCount( wxInputStream& stream ) wxOVERRIDE;
virtual bool DoCanRead( wxInputStream& stream ) wxOVERRIDE;
#endif // wxUSE_STREAMS
private:
wxDECLARE_DYNAMIC_CLASS(wxICOHandler);
};
// ----------------------------------------------------------------------------
// wxCURHandler
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxCURHandler : public wxICOHandler
{
public:
wxCURHandler()
{
m_name = wxT("Windows cursor file");
m_extension = wxT("cur");
m_type = wxBITMAP_TYPE_CUR;
m_mime = wxT("image/x-cur");
}
// VS: This handler's meat is implemented inside wxICOHandler (the two
// formats are almost identical), but we hide this fact at
// the API level, since it is a mere implementation detail.
protected:
#if wxUSE_STREAMS
virtual bool DoCanRead( wxInputStream& stream ) wxOVERRIDE;
#endif // wxUSE_STREAMS
private:
wxDECLARE_DYNAMIC_CLASS(wxCURHandler);
};
// ----------------------------------------------------------------------------
// wxANIHandler
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxANIHandler : public wxCURHandler
{
public:
wxANIHandler()
{
m_name = wxT("Windows animated cursor file");
m_extension = wxT("ani");
m_type = wxBITMAP_TYPE_ANI;
m_mime = wxT("image/x-ani");
}
#if wxUSE_STREAMS
virtual bool SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose=true) ) wxOVERRIDE{return false ;}
virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=true, int index=-1 ) wxOVERRIDE;
protected:
virtual int DoGetImageCount( wxInputStream& stream ) wxOVERRIDE;
virtual bool DoCanRead( wxInputStream& stream ) wxOVERRIDE;
#endif // wxUSE_STREAMS
private:
wxDECLARE_DYNAMIC_CLASS(wxANIHandler);
};
#endif // wxUSE_ICO_CUR
#endif // _WX_IMAGBMP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/cpp.h | /*
* Name: wx/cpp.h
* Purpose: Various preprocessor helpers
* Author: Vadim Zeitlin
* Created: 2006-09-30
* Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_CPP_H_
#define _WX_CPP_H_
#include "wx/compiler.h" /* wxCHECK_XXX_VERSION() macros */
/* wxCONCAT works like preprocessor ## operator but also works with macros */
#define wxCONCAT_HELPER(text, line) text ## line
#define wxCONCAT(x1, x2) \
wxCONCAT_HELPER(x1, x2)
#define wxCONCAT3(x1, x2, x3) \
wxCONCAT(wxCONCAT(x1, x2), x3)
#define wxCONCAT4(x1, x2, x3, x4) \
wxCONCAT(wxCONCAT3(x1, x2, x3), x4)
#define wxCONCAT5(x1, x2, x3, x4, x5) \
wxCONCAT(wxCONCAT4(x1, x2, x3, x4), x5)
#define wxCONCAT6(x1, x2, x3, x4, x5, x6) \
wxCONCAT(wxCONCAT5(x1, x2, x3, x4, x5), x6)
#define wxCONCAT7(x1, x2, x3, x4, x5, x6, x7) \
wxCONCAT(wxCONCAT6(x1, x2, x3, x4, x5, x6), x7)
#define wxCONCAT8(x1, x2, x3, x4, x5, x6, x7, x8) \
wxCONCAT(wxCONCAT7(x1, x2, x3, x4, x5, x6, x7), x8)
#define wxCONCAT9(x1, x2, x3, x4, x5, x6, x7, x8, x9) \
wxCONCAT(wxCONCAT8(x1, x2, x3, x4, x5, x6, x7, x8), x9)
/* wxSTRINGIZE works as the preprocessor # operator but also works with macros */
#define wxSTRINGIZE_HELPER(x) #x
#define wxSTRINGIZE(x) wxSTRINGIZE_HELPER(x)
/* a Unicode-friendly version of wxSTRINGIZE_T */
#define wxSTRINGIZE_T(x) wxAPPLY_T(wxSTRINGIZE(x))
/*
Special workarounds for compilers with broken "##" operator. For all the
other ones we can just use it directly.
*/
#ifdef wxCOMPILER_BROKEN_CONCAT_OPER
#define wxPREPEND_L(x) L ## x
#define wxAPPEND_i64(x) x ## i64
#define wxAPPEND_ui64(x) x ## ui64
#endif /* wxCOMPILER_BROKEN_CONCAT_OPER */
/*
Helper macros for wxMAKE_UNIQUE_NAME: normally this works by appending the
current line number to the given identifier to reduce the probability of the
conflict (it may still happen if this is used in the headers, hence you
should avoid doing it or provide unique prefixes then) but we have to do it
differently for VC++
*/
#if defined(__VISUALC__)
/*
__LINE__ handling is completely broken in VC++ when using "Edit and
Continue" (/ZI option) and results in preprocessor errors if we use it
inside the macros. Luckily VC7 has another standard macro which can be
used like this and is even better than __LINE__ because it is globally
unique.
*/
# define wxCONCAT_LINE(text) wxCONCAT(text, __COUNTER__)
#else /* normal compilers */
# define wxCONCAT_LINE(text) wxCONCAT(text, __LINE__)
#endif
/* Create a "unique" name with the given prefix */
#define wxMAKE_UNIQUE_NAME(text) wxCONCAT_LINE(text)
/*
This macro can be passed as argument to another macro when you don't have
anything to pass in fact.
*/
#define wxEMPTY_PARAMETER_VALUE /* Fake macro parameter value */
/*
Helpers for defining macros that expand into a single statement.
The standard solution is to use "do { ... } while (0)" statement but MSVC
generates a C4127 "condition expression is constant" warning for it so we
use something which is just complicated enough to not be recognized as a
constant but still simple enough to be optimized away.
Another solution would be to use __pragma() to temporarily disable C4127.
Notice that wxASSERT_ARG_TYPE in wx/strvargarg.h relies on these macros
creating some kind of a loop because it uses "break".
*/
#define wxSTATEMENT_MACRO_BEGIN do {
#define wxSTATEMENT_MACRO_END } while ( (void)0, 0 )
/*
Define __WXFUNCTION__ which is like standard __FUNCTION__ but defined as
NULL for the compilers which don't support the latter.
*/
#ifndef __WXFUNCTION__
#if defined(__GNUC__) || \
defined(__VISUALC__) || \
defined(__FUNCTION__)
#define __WXFUNCTION__ __FUNCTION__
#else
/* still define __WXFUNCTION__ to avoid #ifdefs elsewhere */
#define __WXFUNCTION__ (NULL)
#endif
#endif /* __WXFUNCTION__ already defined */
/* Auto-detect variadic macros support unless explicitly disabled. */
#if !defined(HAVE_VARIADIC_MACROS) && !defined(wxNO_VARIADIC_MACROS)
/* Any C99 or C++11 compiler should have them. */
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \
(defined(__cplusplus) && __cplusplus >= 201103L)
#define HAVE_VARIADIC_MACROS 1
#elif defined(__GNUC__)
#define HAVE_VARIADIC_MACROS 1
#elif wxCHECK_VISUALC_VERSION(8)
#define HAVE_VARIADIC_MACROS 1
#endif
#endif /* !HAVE_VARIADIC_MACROS */
#ifdef HAVE_VARIADIC_MACROS
/*
This is a hack to make it possible to use variadic macros with g++ 3.x even
when using -pedantic[-errors] option: without this, it would complain that
"anonymous variadic macros were introduced in C99"
and the option disabling this warning (-Wno-variadic-macros) is only
available in gcc 4.0 and later, so until then this hack is the only thing we
can do.
*/
#if defined(__GNUC__) && __GNUC__ == 3
#pragma GCC system_header
#endif /* gcc-3.x */
/*
wxCALL_FOR_EACH(what, ...) calls the macro from its first argument, what(pos, x),
for every remaining argument 'x', with 'pos' being its 1-based index in
*reverse* order (with the last argument being numbered 1).
For example, wxCALL_FOR_EACH(test, a, b, c) expands into this:
test(3, a) \
test(2, b) \
test(1, c)
Up to eight arguments are supported.
(With thanks to https://groups.google.com/d/topic/comp.std.c/d-6Mj5Lko_s/discussion
and https://stackoverflow.com/questions/1872220/is-it-possible-to-iterate-over-arguments-in-variadic-macros)
*/
#define wxCALL_FOR_EACH_NARG(...) wxCALL_FOR_EACH_NARG_((__VA_ARGS__, wxCALL_FOR_EACH_RSEQ_N()))
#define wxCALL_FOR_EACH_NARG_(args) wxCALL_FOR_EACH_ARG_N args
#define wxCALL_FOR_EACH_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, N, ...) N
#define wxCALL_FOR_EACH_RSEQ_N() 8, 7, 6, 5, 4, 3, 2, 1, 0
#define wxCALL_FOR_EACH_1_(args) wxCALL_FOR_EACH_1 args
#define wxCALL_FOR_EACH_2_(args) wxCALL_FOR_EACH_2 args
#define wxCALL_FOR_EACH_3_(args) wxCALL_FOR_EACH_3 args
#define wxCALL_FOR_EACH_4_(args) wxCALL_FOR_EACH_4 args
#define wxCALL_FOR_EACH_5_(args) wxCALL_FOR_EACH_5 args
#define wxCALL_FOR_EACH_6_(args) wxCALL_FOR_EACH_6 args
#define wxCALL_FOR_EACH_7_(args) wxCALL_FOR_EACH_7 args
#define wxCALL_FOR_EACH_8_(args) wxCALL_FOR_EACH_8 args
#define wxCALL_FOR_EACH_1(what, x) what(1, x)
#define wxCALL_FOR_EACH_2(what, x, ...) what(2, x) wxCALL_FOR_EACH_1_((what, __VA_ARGS__))
#define wxCALL_FOR_EACH_3(what, x, ...) what(3, x) wxCALL_FOR_EACH_2_((what, __VA_ARGS__))
#define wxCALL_FOR_EACH_4(what, x, ...) what(4, x) wxCALL_FOR_EACH_3_((what, __VA_ARGS__))
#define wxCALL_FOR_EACH_5(what, x, ...) what(5, x) wxCALL_FOR_EACH_4_((what, __VA_ARGS__))
#define wxCALL_FOR_EACH_6(what, x, ...) what(6, x) wxCALL_FOR_EACH_5_((what, __VA_ARGS__))
#define wxCALL_FOR_EACH_7(what, x, ...) what(7, x) wxCALL_FOR_EACH_6_((what, __VA_ARGS__))
#define wxCALL_FOR_EACH_8(what, x, ...) what(8, x) wxCALL_FOR_EACH_7_((what, __VA_ARGS__))
#define wxCALL_FOR_EACH_(N, args) \
wxCONCAT(wxCALL_FOR_EACH_, N) args
#define wxCALL_FOR_EACH(what, ...) \
wxCALL_FOR_EACH_(wxCALL_FOR_EACH_NARG(__VA_ARGS__), (what, __VA_ARGS__))
#else
#define wxCALL_FOR_EACH Error_wx_CALL_FOR_EACH_requires_variadic_macros_support
#endif /* HAVE_VARIADIC_MACROS */
#endif /* _WX_CPP_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/dcps.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dcps.h
// Purpose: wxPostScriptDC base header
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCPS_H_BASE_
#define _WX_DCPS_H_BASE_
#include "wx/generic/dcpsg.h"
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/helpwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/helpwin.h
// Purpose: Includes Windows help
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPWIN_H_BASE_
#define _WX_HELPWIN_H_BASE_
#if defined(__WXMSW__)
#include "wx/msw/helpwin.h"
#endif
#endif
// _WX_HELPWIN_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/dcclient.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dcclient.h
// Purpose: wxClientDC base header
// Author: Julian Smart
// Copyright: (c) Julian Smart
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCCLIENT_H_BASE_
#define _WX_DCCLIENT_H_BASE_
#include "wx/dc.h"
//-----------------------------------------------------------------------------
// wxWindowDC
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDC : public wxDC
{
public:
wxWindowDC(wxWindow *win);
protected:
wxWindowDC(wxDCImpl *impl) : wxDC(impl) { }
private:
wxDECLARE_ABSTRACT_CLASS(wxWindowDC);
};
//-----------------------------------------------------------------------------
// wxClientDC
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClientDC : public wxWindowDC
{
public:
wxClientDC(wxWindow *win);
protected:
wxClientDC(wxDCImpl *impl) : wxWindowDC(impl) { }
private:
wxDECLARE_ABSTRACT_CLASS(wxClientDC);
};
//-----------------------------------------------------------------------------
// wxPaintDC
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPaintDC : public wxClientDC
{
public:
wxPaintDC(wxWindow *win);
protected:
wxPaintDC(wxDCImpl *impl) : wxClientDC(impl) { }
private:
wxDECLARE_ABSTRACT_CLASS(wxPaintDC);
};
#endif // _WX_DCCLIENT_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/platinfo.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/platinfo.h
// Purpose: declaration of the wxPlatformInfo class
// Author: Francesco Montorsi
// Modified by:
// Created: 07.07.2006 (based on wxToolkitInfo)
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PLATINFO_H_
#define _WX_PLATINFO_H_
#include "wx/string.h"
// ----------------------------------------------------------------------------
// wxPlatformInfo enums & structs
// ----------------------------------------------------------------------------
// VERY IMPORTANT: when changing these enum values, also change the relative
// string tables in src/common/platinfo.cpp
// families & sub-families of operating systems
enum wxOperatingSystemId
{
wxOS_UNKNOWN = 0, // returned on error
wxOS_MAC_OS = 1 << 0, // Apple Mac OS 8/9/X with Mac paths
wxOS_MAC_OSX_DARWIN = 1 << 1, // Apple Mac OS X with Unix paths
wxOS_MAC = wxOS_MAC_OS|wxOS_MAC_OSX_DARWIN,
wxOS_WINDOWS_9X = 1 << 2, // obsolete
wxOS_WINDOWS_NT = 1 << 3, // obsolete
wxOS_WINDOWS_MICRO = 1 << 4, // obsolete
wxOS_WINDOWS_CE = 1 << 5, // obsolete
wxOS_WINDOWS = wxOS_WINDOWS_9X |
wxOS_WINDOWS_NT |
wxOS_WINDOWS_MICRO |
wxOS_WINDOWS_CE,
wxOS_UNIX_LINUX = 1 << 6, // Linux
wxOS_UNIX_FREEBSD = 1 << 7, // FreeBSD
wxOS_UNIX_OPENBSD = 1 << 8, // OpenBSD
wxOS_UNIX_NETBSD = 1 << 9, // NetBSD
wxOS_UNIX_SOLARIS = 1 << 10, // SunOS
wxOS_UNIX_AIX = 1 << 11, // AIX
wxOS_UNIX_HPUX = 1 << 12, // HP/UX
wxOS_UNIX = wxOS_UNIX_LINUX |
wxOS_UNIX_FREEBSD |
wxOS_UNIX_OPENBSD |
wxOS_UNIX_NETBSD |
wxOS_UNIX_SOLARIS |
wxOS_UNIX_AIX |
wxOS_UNIX_HPUX,
// 1<<13 and 1<<14 available for other Unix flavours
wxOS_DOS = 1 << 15, // obsolete
wxOS_OS2 = 1 << 16 // obsolete
};
// list of wxWidgets ports - some of them can be used with more than
// a single toolkit.
enum wxPortId
{
wxPORT_UNKNOWN = 0, // returned on error
wxPORT_BASE = 1 << 0, // wxBase, no native toolkit used
wxPORT_MSW = 1 << 1, // wxMSW, native toolkit is Windows API
wxPORT_MOTIF = 1 << 2, // wxMotif, using [Open]Motif or Lesstif
wxPORT_GTK = 1 << 3, // wxGTK, using GTK+ 1.x, 2.x, 3.x
wxPORT_DFB = 1 << 4, // wxDFB, using wxUniversal
wxPORT_X11 = 1 << 5, // wxX11, using wxUniversal
wxPORT_PM = 1 << 6, // obsolete
wxPORT_OS2 = wxPORT_PM, // obsolete
wxPORT_MAC = 1 << 7, // wxOSX (former wxMac), using Cocoa or iPhone API
wxPORT_OSX = wxPORT_MAC, // wxOSX, using Cocoa or iPhone API
wxPORT_COCOA = 1 << 8, // wxCocoa, using Cocoa NextStep/Mac API
wxPORT_WINCE = 1 << 9, // obsolete
wxPORT_QT = 1 << 10 // wxQT, using QT4
};
// architecture of the operating system
// (regardless of the build environment of wxWidgets library - see
// wxIsPlatform64bit documentation for more info)
enum wxArchitecture
{
wxARCH_INVALID = -1, // returned on error
wxARCH_32, // 32 bit
wxARCH_64,
wxARCH_MAX
};
// endian-ness of the machine
enum wxEndianness
{
wxENDIAN_INVALID = -1, // returned on error
wxENDIAN_BIG, // 4321
wxENDIAN_LITTLE, // 1234
wxENDIAN_PDP, // 3412
wxENDIAN_MAX
};
// information about a linux distro returned by the lsb_release utility
struct wxLinuxDistributionInfo
{
wxString Id;
wxString Release;
wxString CodeName;
wxString Description;
bool operator==(const wxLinuxDistributionInfo& ldi) const
{
return Id == ldi.Id &&
Release == ldi.Release &&
CodeName == ldi.CodeName &&
Description == ldi.Description;
}
bool operator!=(const wxLinuxDistributionInfo& ldi) const
{ return !(*this == ldi); }
};
// ----------------------------------------------------------------------------
// wxPlatformInfo
// ----------------------------------------------------------------------------
// Information about the toolkit that the app is running under and some basic
// platform and architecture info
class WXDLLIMPEXP_BASE wxPlatformInfo
{
public:
wxPlatformInfo();
wxPlatformInfo(wxPortId pid,
int tkMajor = -1, int tkMinor = -1,
wxOperatingSystemId id = wxOS_UNKNOWN,
int osMajor = -1, int osMinor = -1,
wxArchitecture arch = wxARCH_INVALID,
wxEndianness endian = wxENDIAN_INVALID,
bool usingUniversal = false);
// default copy ctor, assignment operator and dtor are ok
bool operator==(const wxPlatformInfo &t) const;
bool operator!=(const wxPlatformInfo &t) const
{ return !(*this == t); }
// Gets a wxPlatformInfo already initialized with the values for
// the currently running platform.
static const wxPlatformInfo& Get();
// string -> enum conversions
// ---------------------------------
static wxOperatingSystemId GetOperatingSystemId(const wxString &name);
static wxPortId GetPortId(const wxString &portname);
static wxArchitecture GetArch(const wxString &arch);
static wxEndianness GetEndianness(const wxString &end);
// enum -> string conversions
// ---------------------------------
static wxString GetOperatingSystemFamilyName(wxOperatingSystemId os);
static wxString GetOperatingSystemIdName(wxOperatingSystemId os);
static wxString GetPortIdName(wxPortId port, bool usingUniversal);
static wxString GetPortIdShortName(wxPortId port, bool usingUniversal);
static wxString GetArchName(wxArchitecture arch);
static wxString GetEndiannessName(wxEndianness end);
// getters
// -----------------
int GetOSMajorVersion() const
{ return m_osVersionMajor; }
int GetOSMinorVersion() const
{ return m_osVersionMinor; }
int GetOSMicroVersion() const
{ return m_osVersionMicro; }
// return true if the OS version >= major.minor
bool CheckOSVersion(int major, int minor, int micro = 0) const;
int GetToolkitMajorVersion() const
{ return m_tkVersionMajor; }
int GetToolkitMinorVersion() const
{ return m_tkVersionMinor; }
int GetToolkitMicroVersion() const
{ return m_tkVersionMicro; }
bool CheckToolkitVersion(int major, int minor, int micro = 0) const
{
return DoCheckVersion(GetToolkitMajorVersion(),
GetToolkitMinorVersion(),
GetToolkitMicroVersion(),
major,
minor,
micro);
}
bool IsUsingUniversalWidgets() const
{ return m_usingUniversal; }
wxOperatingSystemId GetOperatingSystemId() const
{ return m_os; }
wxLinuxDistributionInfo GetLinuxDistributionInfo() const
{ return m_ldi; }
wxPortId GetPortId() const
{ return m_port; }
wxArchitecture GetArchitecture() const
{ return m_arch; }
wxEndianness GetEndianness() const
{ return m_endian; }
// string getters
// -----------------
wxString GetOperatingSystemFamilyName() const
{ return GetOperatingSystemFamilyName(m_os); }
wxString GetOperatingSystemIdName() const
{ return GetOperatingSystemIdName(m_os); }
wxString GetPortIdName() const
{ return GetPortIdName(m_port, m_usingUniversal); }
wxString GetPortIdShortName() const
{ return GetPortIdShortName(m_port, m_usingUniversal); }
wxString GetArchName() const
{ return GetArchName(m_arch); }
wxString GetEndiannessName() const
{ return GetEndiannessName(m_endian); }
wxString GetOperatingSystemDescription() const
{ return m_osDesc; }
wxString GetDesktopEnvironment() const
{ return m_desktopEnv; }
static wxString GetOperatingSystemDirectory();
// doesn't make sense to store inside wxPlatformInfo the OS directory,
// thus this function is static; note that this function simply calls
// wxGetOSDirectory() and is here just to make it easier for the user to
// find it that feature (global functions can be difficult to find in the docs)
// setters
// -----------------
void SetOSVersion(int major, int minor, int micro = 0)
{
m_osVersionMajor = major;
m_osVersionMinor = minor;
m_osVersionMicro = micro;
}
void SetToolkitVersion(int major, int minor, int micro = 0)
{
m_tkVersionMajor = major;
m_tkVersionMinor = minor;
m_tkVersionMicro = micro;
}
void SetOperatingSystemId(wxOperatingSystemId n)
{ m_os = n; }
void SetOperatingSystemDescription(const wxString& desc)
{ m_osDesc = desc; }
void SetPortId(wxPortId n)
{ m_port = n; }
void SetArchitecture(wxArchitecture n)
{ m_arch = n; }
void SetEndianness(wxEndianness n)
{ m_endian = n; }
void SetDesktopEnvironment(const wxString& de)
{ m_desktopEnv = de; }
void SetLinuxDistributionInfo(const wxLinuxDistributionInfo& di)
{ m_ldi = di; }
// miscellaneous
// -----------------
bool IsOk() const
{
return m_osVersionMajor != -1 && m_osVersionMinor != -1 &&
m_osVersionMicro != -1 &&
m_os != wxOS_UNKNOWN &&
!m_osDesc.IsEmpty() &&
m_tkVersionMajor != -1 && m_tkVersionMinor != -1 &&
m_tkVersionMicro != -1 &&
m_port != wxPORT_UNKNOWN &&
m_arch != wxARCH_INVALID &&
m_endian != wxENDIAN_INVALID;
// do not check linux-specific info; it's ok to have them empty
}
protected:
static bool DoCheckVersion(int majorCur, int minorCur, int microCur,
int major, int minor, int micro)
{
return majorCur > major
|| (majorCur == major && minorCur > minor)
|| (majorCur == major && minorCur == minor && microCur >= micro);
}
bool m_initializedForCurrentPlatform;
void InitForCurrentPlatform();
// OS stuff
// -----------------
// Version of the OS; valid if m_os != wxOS_UNKNOWN
// (-1 means not initialized yet).
int m_osVersionMajor,
m_osVersionMinor,
m_osVersionMicro;
// Operating system ID.
wxOperatingSystemId m_os;
// Operating system description.
wxString m_osDesc;
// linux-specific
// -----------------
wxString m_desktopEnv;
wxLinuxDistributionInfo m_ldi;
// toolkit
// -----------------
// Version of the underlying toolkit
// (-1 means not initialized yet; zero means no toolkit).
int m_tkVersionMajor, m_tkVersionMinor, m_tkVersionMicro;
// name of the wxWidgets port
wxPortId m_port;
// is using wxUniversal widgets?
bool m_usingUniversal;
// others
// -----------------
// architecture of the OS/machine
wxArchitecture m_arch;
// endianness of the machine
wxEndianness m_endian;
};
#endif // _WX_PLATINFO_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/datetimectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/timectrl.h
// Purpose: Declaration of wxDateTimePickerCtrl class.
// Author: Vadim Zeitlin
// Created: 2011-09-22
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DATETIME_CTRL_H_
#define _WX_DATETIME_CTRL_H_
#include "wx/defs.h"
#if wxUSE_DATEPICKCTRL || wxUSE_TIMEPICKCTRL
#define wxNEEDS_DATETIMEPICKCTRL
#include "wx/control.h" // the base class
#include "wx/datetime.h"
// ----------------------------------------------------------------------------
// wxDateTimePickerCtrl: Private common base class of wx{Date,Time}PickerCtrl.
// ----------------------------------------------------------------------------
// This class is an implementation detail and should not be used directly, only
// use the documented API of wxDateTimePickerCtrl and wxTimePickerCtrl.
class WXDLLIMPEXP_ADV wxDateTimePickerCtrlBase : public wxControl
{
public:
// Set/get the date or time (in the latter case, time part is ignored).
virtual void SetValue(const wxDateTime& dt) = 0;
virtual wxDateTime GetValue() const = 0;
};
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
#include "wx/msw/datetimectrl.h"
#elif defined(__WXOSX_COCOA__) && !defined(__WXUNIVERSAL__)
#include "wx/osx/datetimectrl.h"
#else
typedef wxDateTimePickerCtrlBase wxDateTimePickerCtrl;
#endif
#endif // wxUSE_DATEPICKCTRL || wxUSE_TIMEPICKCTRL
#endif // _WX_DATETIME_CTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/collheaderctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/collheaderctrl.h
// Purpose: wxCollapsibleHeaderCtrl
// Author: Tobias Taschner
// Created: 2015-09-19
// Copyright: (c) 2015 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COLLAPSIBLEHEADER_CTRL_H_
#define _WX_COLLAPSIBLEHEADER_CTRL_H_
#include "wx/defs.h"
#if wxUSE_COLLPANE
#include "wx/control.h"
// class name
extern WXDLLIMPEXP_DATA_CORE(const char) wxCollapsibleHeaderCtrlNameStr[];
//
// wxGenericCollapsibleHeaderCtrl
//
class WXDLLIMPEXP_CORE wxCollapsibleHeaderCtrlBase : public wxControl
{
public:
wxCollapsibleHeaderCtrlBase() { }
wxCollapsibleHeaderCtrlBase(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBORDER_NONE,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCollapsibleHeaderCtrlNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBORDER_NONE,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCollapsibleHeaderCtrlNameStr)
{
if ( !wxControl::Create(parent, id, pos, size, style, validator, name) )
return false;
SetLabel(label);
return true;
}
virtual void SetCollapsed(bool collapsed = true) = 0;
virtual bool IsCollapsed() const = 0;
private:
wxDECLARE_NO_COPY_CLASS(wxCollapsibleHeaderCtrlBase);
};
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_CORE, wxEVT_COLLAPSIBLEHEADER_CHANGED, wxCommandEvent);
#define wxCollapsibleHeaderChangedHandler(func) \
wxEVENT_HANDLER_CAST(wxCommandEventFunction, func)
#define EVT_COLLAPSIBLEHEADER_CHANGED(id, fn) \
wx__DECLARE_EVT1(wxEVT_COLLAPSIBLEHEADER_CHANGED, id, wxCollapsibleHeaderChangedHandler(fn))
// Currently there is only the native implementation, use it for all ports.
#include "wx/generic/collheaderctrl.h"
class WXDLLIMPEXP_CORE wxCollapsibleHeaderCtrl
: public wxGenericCollapsibleHeaderCtrl
{
public:
wxCollapsibleHeaderCtrl() { }
wxCollapsibleHeaderCtrl(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxBORDER_NONE,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCollapsibleHeaderCtrlNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
private:
wxDECLARE_NO_COPY_CLASS(wxCollapsibleHeaderCtrl);
};
#endif // wxUSE_COLLPANE
#endif // _WX_COLLAPSIBLEHEADER_CTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/withimages.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/withimages.h
// Purpose: Declaration of a simple wxWithImages class.
// Author: Vadim Zeitlin
// Created: 2011-08-17
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WITHIMAGES_H_
#define _WX_WITHIMAGES_H_
#include "wx/defs.h"
#include "wx/icon.h"
#include "wx/imaglist.h"
// ----------------------------------------------------------------------------
// wxWithImages: mix-in class providing access to wxImageList.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWithImages
{
public:
enum
{
NO_IMAGE = -1
};
wxWithImages()
{
m_imageList = NULL;
m_ownsImageList = false;
}
virtual ~wxWithImages()
{
FreeIfNeeded();
}
// Sets the image list to use, it is *not* deleted by the control.
virtual void SetImageList(wxImageList* imageList)
{
FreeIfNeeded();
m_imageList = imageList;
}
// As SetImageList() but we will delete the image list ourselves.
void AssignImageList(wxImageList* imageList)
{
SetImageList(imageList);
m_ownsImageList = true;
}
// Get pointer (may be NULL) to the associated image list.
wxImageList* GetImageList() const { return m_imageList; }
protected:
// Return true if we have a valid image list.
bool HasImageList() const { return m_imageList != NULL; }
// Return the image with the given index from the image list.
//
// If there is no image list or if index == NO_IMAGE, silently returns
// wxNullIcon.
wxIcon GetImage(int iconIndex) const
{
return m_imageList && iconIndex != NO_IMAGE
? m_imageList->GetIcon(iconIndex)
: wxNullIcon;
}
private:
// Free the image list if necessary, i.e. if we own it.
void FreeIfNeeded()
{
if ( m_ownsImageList )
{
delete m_imageList;
m_imageList = NULL;
// We don't own it any more.
m_ownsImageList = false;
}
}
// The associated image list or NULL.
wxImageList* m_imageList;
// False by default, if true then we delete m_imageList.
bool m_ownsImageList;
wxDECLARE_NO_COPY_CLASS(wxWithImages);
};
#endif // _WX_WITHIMAGES_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/listctrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/listctrl.h
// Purpose: wxListCtrl class
// Author: Vadim Zeitlin
// Modified by:
// Created: 04.12.99
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTCTRL_H_BASE_
#define _WX_LISTCTRL_H_BASE_
#include "wx/defs.h" // headers should include this before first wxUSE_XXX check
#if wxUSE_LISTCTRL
#include "wx/listbase.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
extern WXDLLIMPEXP_DATA_CORE(const char) wxListCtrlNameStr[];
// ----------------------------------------------------------------------------
// include the wxListCtrl class declaration
// ----------------------------------------------------------------------------
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
#include "wx/msw/listctrl.h"
#elif defined(__WXQT__) && !defined(__WXUNIVERSAL__)
#include "wx/qt/listctrl.h"
#else
#include "wx/generic/listctrl.h"
#endif
// ----------------------------------------------------------------------------
// wxListView: a class which provides a better API for list control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxListView : public wxListCtrl
{
public:
wxListView() { }
wxListView( wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_REPORT,
const wxValidator& validator = wxDefaultValidator,
const wxString &name = wxListCtrlNameStr)
{
Create(parent, winid, pos, size, style, validator, name);
}
// focus/selection stuff
// ---------------------
// [de]select an item
void Select(long n, bool on = true)
{
SetItemState(n, on ? wxLIST_STATE_SELECTED : 0, wxLIST_STATE_SELECTED);
}
// focus and show the given item
void Focus(long index)
{
SetItemState(index, wxLIST_STATE_FOCUSED, wxLIST_STATE_FOCUSED);
EnsureVisible(index);
}
// get the currently focused item or -1 if none
long GetFocusedItem() const
{
return GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_FOCUSED);
}
// get first and subsequent selected items, return -1 when no more
long GetNextSelected(long item) const
{ return GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); }
long GetFirstSelected() const
{ return GetNextSelected(-1); }
// return true if the item is selected
bool IsSelected(long index) const
{ return GetItemState(index, wxLIST_STATE_SELECTED) != 0; }
// columns
// -------
void SetColumnImage(int col, int image)
{
wxListItem item;
item.SetMask(wxLIST_MASK_IMAGE);
item.SetImage(image);
SetColumn(col, item);
}
void ClearColumnImage(int col) { SetColumnImage(col, -1); }
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxListView);
};
#endif // wxUSE_LISTCTRL
#endif
// _WX_LISTCTRL_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/progdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/progdlg.h
// Purpose: Base header for wxProgressDialog
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PROGDLG_H_BASE_
#define _WX_PROGDLG_H_BASE_
#include "wx/defs.h"
#if wxUSE_PROGRESSDLG
/*
* wxProgressDialog flags
*/
#define wxPD_CAN_ABORT 0x0001
#define wxPD_APP_MODAL 0x0002
#define wxPD_AUTO_HIDE 0x0004
#define wxPD_ELAPSED_TIME 0x0008
#define wxPD_ESTIMATED_TIME 0x0010
#define wxPD_SMOOTH 0x0020
#define wxPD_REMAINING_TIME 0x0040
#define wxPD_CAN_SKIP 0x0080
#include "wx/generic/progdlgg.h"
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
// The native implementation requires the use of threads and still has some
// problems, so it can be explicitly disabled.
#if wxUSE_THREADS && wxUSE_NATIVE_PROGRESSDLG
#define wxHAS_NATIVE_PROGRESSDIALOG
#include "wx/msw/progdlg.h"
#endif
#endif
// If there is no native one, just use the generic version.
#ifndef wxHAS_NATIVE_PROGRESSDIALOG
class WXDLLIMPEXP_CORE wxProgressDialog
: public wxGenericProgressDialog
{
public:
wxProgressDialog( const wxString& title, const wxString& message,
int maximum = 100,
wxWindow *parent = NULL,
int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE )
: wxGenericProgressDialog( title, message, maximum,
parent, style )
{ }
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY( wxProgressDialog );
};
#endif // !wxHAS_NATIVE_PROGRESSDIALOG
#endif // wxUSE_PROGRESSDLG
#endif // _WX_PROGDLG_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/font.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/font.h
// Purpose: wxFontBase class: the interface of wxFont
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.09.99
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONT_H_BASE_
#define _WX_FONT_H_BASE_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/defs.h" // for wxDEFAULT &c
#include "wx/fontenc.h" // the font encoding constants
#include "wx/gdiobj.h" // the base class
#include "wx/gdicmn.h" // for wxGDIObjListBase
#include "wx/math.h" // for wxRound()
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxFont;
// ----------------------------------------------------------------------------
// font constants
// ----------------------------------------------------------------------------
// standard font families: these may be used only for the font creation, it
// doesn't make sense to query an existing font for its font family as,
// especially if the font had been created from a native font description, it
// may be unknown
enum wxFontFamily
{
wxFONTFAMILY_DEFAULT = wxDEFAULT,
wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
wxFONTFAMILY_ROMAN = wxROMAN,
wxFONTFAMILY_SCRIPT = wxSCRIPT,
wxFONTFAMILY_SWISS = wxSWISS,
wxFONTFAMILY_MODERN = wxMODERN,
wxFONTFAMILY_TELETYPE = wxTELETYPE,
wxFONTFAMILY_MAX,
wxFONTFAMILY_UNKNOWN = wxFONTFAMILY_MAX
};
// font styles
enum wxFontStyle
{
wxFONTSTYLE_NORMAL = wxNORMAL,
wxFONTSTYLE_ITALIC = wxITALIC,
wxFONTSTYLE_SLANT = wxSLANT,
wxFONTSTYLE_MAX
};
// font weights
enum wxFontWeight
{
wxFONTWEIGHT_INVALID = 0,
wxFONTWEIGHT_THIN = 100,
wxFONTWEIGHT_EXTRALIGHT = 200,
wxFONTWEIGHT_LIGHT = 300,
wxFONTWEIGHT_NORMAL = 400,
wxFONTWEIGHT_MEDIUM = 500,
wxFONTWEIGHT_SEMIBOLD = 600,
wxFONTWEIGHT_BOLD = 700,
wxFONTWEIGHT_EXTRABOLD = 800,
wxFONTWEIGHT_HEAVY = 900,
wxFONTWEIGHT_EXTRAHEAVY = 1000,
wxFONTWEIGHT_MAX = wxFONTWEIGHT_EXTRAHEAVY
};
// Symbolic font sizes as defined in CSS specification.
enum wxFontSymbolicSize
{
wxFONTSIZE_XX_SMALL = -3,
wxFONTSIZE_X_SMALL,
wxFONTSIZE_SMALL,
wxFONTSIZE_MEDIUM,
wxFONTSIZE_LARGE,
wxFONTSIZE_X_LARGE,
wxFONTSIZE_XX_LARGE
};
// the font flag bits for the new font ctor accepting one combined flags word
enum wxFontFlag
{
// no special flags: font with default weight/slant/anti-aliasing
wxFONTFLAG_DEFAULT = 0,
// slant flags (default: no slant)
wxFONTFLAG_ITALIC = 1 << 0,
wxFONTFLAG_SLANT = 1 << 1,
// weight flags (default: medium):
wxFONTFLAG_LIGHT = 1 << 2,
wxFONTFLAG_BOLD = 1 << 3,
// anti-aliasing flag: force on or off (default: the current system default)
wxFONTFLAG_ANTIALIASED = 1 << 4,
wxFONTFLAG_NOT_ANTIALIASED = 1 << 5,
// underlined/strikethrough flags (default: no lines)
wxFONTFLAG_UNDERLINED = 1 << 6,
wxFONTFLAG_STRIKETHROUGH = 1 << 7,
// the mask of all currently used flags
wxFONTFLAG_MASK = wxFONTFLAG_ITALIC |
wxFONTFLAG_SLANT |
wxFONTFLAG_LIGHT |
wxFONTFLAG_BOLD |
wxFONTFLAG_ANTIALIASED |
wxFONTFLAG_NOT_ANTIALIASED |
wxFONTFLAG_UNDERLINED |
wxFONTFLAG_STRIKETHROUGH
};
// ----------------------------------------------------------------------------
// wxFontInfo describes a wxFont
// ----------------------------------------------------------------------------
class wxFontInfo
{
public:
// Default ctor uses the default font size appropriate for the current
// platform.
wxFontInfo()
{ InitPointSize(-1.0f); }
// These ctors specify the font size, either in points or in pixels.
// Point size is a floating point number, however we also accept all
// integer sizes using the simple template ctor below.
explicit wxFontInfo(float pointSize)
{ InitPointSize(pointSize); }
explicit wxFontInfo(const wxSize& pixelSize) : m_pixelSize(pixelSize)
{ Init(); }
// Need to define this one to avoid casting double to int too.
explicit wxFontInfo(double pointSize)
{ InitPointSize(static_cast<float>(pointSize)); }
template <typename T>
explicit wxFontInfo(T pointSize)
{ InitPointSize(ToFloatPointSize(pointSize)); }
// Setters for the various attributes. All of them return the object itself
// so that the calls to them could be chained.
wxFontInfo& Family(wxFontFamily family)
{ m_family = family; return *this; }
wxFontInfo& FaceName(const wxString& faceName)
{ m_faceName = faceName; return *this; }
wxFontInfo& Weight(int weight)
{ m_weight = weight; return *this; }
wxFontInfo& Bold(bool bold = true)
{ return Weight(bold ? wxFONTWEIGHT_BOLD : wxFONTWEIGHT_NORMAL); }
wxFontInfo& Light(bool light = true)
{ return Weight(light ? wxFONTWEIGHT_LIGHT : wxFONTWEIGHT_NORMAL); }
wxFontInfo& Italic(bool italic = true)
{ SetFlag(wxFONTFLAG_ITALIC, italic); return *this; }
wxFontInfo& Slant(bool slant = true)
{ SetFlag(wxFONTFLAG_SLANT, slant); return *this; }
wxFontInfo& Style(wxFontStyle style)
{
if ( style == wxFONTSTYLE_ITALIC )
return Italic();
if ( style == wxFONTSTYLE_SLANT )
return Slant();
return *this;
}
wxFontInfo& AntiAliased(bool antiAliased = true)
{ SetFlag(wxFONTFLAG_ANTIALIASED, antiAliased); return *this; }
wxFontInfo& Underlined(bool underlined = true)
{ SetFlag(wxFONTFLAG_UNDERLINED, underlined); return *this; }
wxFontInfo& Strikethrough(bool strikethrough = true)
{ SetFlag(wxFONTFLAG_STRIKETHROUGH, strikethrough); return *this; }
wxFontInfo& Encoding(wxFontEncoding encoding)
{ m_encoding = encoding; return *this; }
// Set all flags at once.
wxFontInfo& AllFlags(int flags)
{
m_flags = flags;
m_weight = m_flags & wxFONTFLAG_BOLD
? wxFONTWEIGHT_BOLD
: m_flags & wxFONTFLAG_LIGHT
? wxFONTWEIGHT_LIGHT
: wxFONTWEIGHT_NORMAL;
return *this;
}
// Accessors are mostly meant to be used by wxFont itself to extract the
// various pieces of the font description.
bool IsUsingSizeInPixels() const { return m_pixelSize != wxDefaultSize; }
float GetFractionalPointSize() const { return m_pointSize; }
int GetPointSize() const { return ToIntPointSize(m_pointSize); }
wxSize GetPixelSize() const { return m_pixelSize; }
// If face name is not empty, it has priority, otherwise use family.
bool HasFaceName() const { return !m_faceName.empty(); }
wxFontFamily GetFamily() const { return m_family; }
const wxString& GetFaceName() const { return m_faceName; }
wxFontStyle GetStyle() const
{
return m_flags & wxFONTFLAG_ITALIC
? wxFONTSTYLE_ITALIC
: m_flags & wxFONTFLAG_SLANT
? wxFONTSTYLE_SLANT
: wxFONTSTYLE_NORMAL;
}
int GetNumericWeight() const
{
return m_weight;
}
wxFontWeight GetWeight() const
{
return GetWeightClosestToNumericValue(m_weight);
}
bool IsAntiAliased() const
{
return (m_flags & wxFONTFLAG_ANTIALIASED) != 0;
}
bool IsUnderlined() const
{
return (m_flags & wxFONTFLAG_UNDERLINED) != 0;
}
bool IsStrikethrough() const
{
return (m_flags & wxFONTFLAG_STRIKETHROUGH) != 0;
}
wxFontEncoding GetEncoding() const { return m_encoding; }
// Default copy ctor, assignment operator and dtor are OK.
// Helper functions for converting between integer and fractional sizes.
static int ToIntPointSize(float pointSize) { return wxRound(pointSize); }
static float ToFloatPointSize(int pointSize)
{
wxCHECK_MSG( pointSize == -1 || pointSize >= 0,
-1, "Invalid font point size" );
// Huge values are not exactly representable as floats, so don't accept
// those neither as they can only be due to a mistake anyhow: nobody
// could possibly need a font of size 16777217pt (which is the first
// value for which this fails).
const float f = static_cast<float>(pointSize);
wxCHECK_MSG( static_cast<int>(f) == pointSize,
-1, "Font point size out of range" );
return f;
}
// Another helper for converting arbitrary numeric weight to the closest
// value of wxFontWeight enum. It should be avoided in the new code (also
// note that the function for the conversion in the other direction is
// trivial and so is not provided, we only have GetNumericWeightOf() which
// contains backwards compatibility hacks, but we don't need it here).
static wxFontWeight GetWeightClosestToNumericValue(int numWeight)
{
wxASSERT(numWeight > 0);
wxASSERT(numWeight <= 1000);
// round to nearest hundredth = wxFONTWEIGHT_ constant
int weight = ((numWeight + 50) / 100) * 100;
if (weight < wxFONTWEIGHT_THIN)
weight = wxFONTWEIGHT_THIN;
if (weight > wxFONTWEIGHT_MAX)
weight = wxFONTWEIGHT_MAX;
return static_cast<wxFontWeight>(weight);
}
private:
void Init()
{
m_pointSize = -1;
m_family = wxFONTFAMILY_DEFAULT;
m_flags = wxFONTFLAG_DEFAULT;
m_weight = wxFONTWEIGHT_NORMAL;
m_encoding = wxFONTENCODING_DEFAULT;
}
void InitPointSize(float pointSize)
{
Init();
m_pointSize = pointSize;
m_pixelSize = wxDefaultSize;
}
// Turn on or off the given bit in m_flags depending on the value of the
// boolean argument.
void SetFlag(int flag, bool on)
{
if ( on )
m_flags |= flag;
else
m_flags &= ~flag;
}
// The size information: if m_pixelSize is valid (!= wxDefaultSize), then
// it is used. Otherwise m_pointSize is used, except if it is < 0, which
// means that the platform dependent font size should be used instead.
float m_pointSize;
wxSize m_pixelSize;
wxFontFamily m_family;
wxString m_faceName;
int m_flags;
int m_weight;
wxFontEncoding m_encoding;
};
// ----------------------------------------------------------------------------
// wxFontBase represents a font object
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxNativeFontInfo;
class WXDLLIMPEXP_CORE wxFontBase : public wxGDIObject
{
public:
/*
derived classes should provide the following ctors:
wxFont();
wxFont(const wxFontInfo& info);
wxFont(const wxString& nativeFontInfoString);
wxFont(const wxNativeFontInfo& info);
wxFont(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
wxFont(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
*/
// creator function
virtual ~wxFontBase();
// from the font components
static wxFont *New(
int pointSize, // size of the font in points
wxFontFamily family, // see wxFontFamily enum
wxFontStyle style, // see wxFontStyle enum
wxFontWeight weight, // see wxFontWeight enum
bool underlined = false, // not underlined by default
const wxString& face = wxEmptyString, // facename
wxFontEncoding encoding = wxFONTENCODING_DEFAULT); // ISO8859-X, ...
// from the font components
static wxFont *New(
const wxSize& pixelSize, // size of the font in pixels
wxFontFamily family, // see wxFontFamily enum
wxFontStyle style, // see wxFontStyle enum
wxFontWeight weight, // see wxFontWeight enum
bool underlined = false, // not underlined by default
const wxString& face = wxEmptyString, // facename
wxFontEncoding encoding = wxFONTENCODING_DEFAULT); // ISO8859-X, ...
// from the font components but using the font flags instead of separate
// parameters for each flag
static wxFont *New(int pointSize,
wxFontFamily family,
int flags = wxFONTFLAG_DEFAULT,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
// from the font components but using the font flags instead of separate
// parameters for each flag
static wxFont *New(const wxSize& pixelSize,
wxFontFamily family,
int flags = wxFONTFLAG_DEFAULT,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
// from the (opaque) native font description object
static wxFont *New(const wxNativeFontInfo& nativeFontDesc);
// from the string representation of wxNativeFontInfo
static wxFont *New(const wxString& strNativeFontDesc);
// Load the font from the given file and return true on success or false on
// error (an error message will be logged in this case).
#if wxUSE_PRIVATE_FONTS
static bool AddPrivateFont(const wxString& filename);
#endif // wxUSE_PRIVATE_FONTS
// comparison
bool operator==(const wxFont& font) const;
bool operator!=(const wxFont& font) const { return !(*this == font); }
// accessors: get the font characteristics
virtual int GetPointSize() const;
virtual float GetFractionalPointSize() const = 0;
virtual wxSize GetPixelSize() const;
virtual bool IsUsingSizeInPixels() const;
wxFontFamily GetFamily() const;
virtual wxFontStyle GetStyle() const = 0;
virtual int GetNumericWeight() const = 0;
virtual bool GetUnderlined() const = 0;
virtual bool GetStrikethrough() const { return false; }
virtual wxString GetFaceName() const = 0;
virtual wxFontEncoding GetEncoding() const = 0;
virtual const wxNativeFontInfo *GetNativeFontInfo() const = 0;
// Accessors that can be overridden in the platform-specific code but for
// which we provide a reasonable default implementation in the base class.
virtual wxFontWeight GetWeight() const;
virtual bool IsFixedWidth() const;
wxString GetNativeFontInfoDesc() const;
wxString GetNativeFontInfoUserDesc() const;
// change the font characteristics
virtual void SetPointSize( int pointSize );
virtual void SetFractionalPointSize( float pointSize ) = 0;
virtual void SetPixelSize( const wxSize& pixelSize );
virtual void SetFamily( wxFontFamily family ) = 0;
virtual void SetStyle( wxFontStyle style ) = 0;
virtual void SetNumericWeight( int weight ) = 0;
virtual void SetUnderlined( bool underlined ) = 0;
virtual void SetStrikethrough( bool WXUNUSED(strikethrough) ) {}
virtual void SetEncoding(wxFontEncoding encoding) = 0;
virtual bool SetFaceName( const wxString& faceName );
void SetNativeFontInfo(const wxNativeFontInfo& info)
{ DoSetNativeFontInfo(info); }
// Similarly to the accessors above, the functions in this group have a
// reasonable default implementation in the base class.
virtual void SetWeight( wxFontWeight weight );
bool SetNativeFontInfo(const wxString& info);
bool SetNativeFontInfoUserDesc(const wxString& info);
// Symbolic font sizes support: set the font size to "large" or "very
// small" either absolutely (i.e. compared to the default font size) or
// relatively to the given font size.
void SetSymbolicSize(wxFontSymbolicSize size);
void SetSymbolicSizeRelativeTo(wxFontSymbolicSize size, int base)
{
SetPointSize(AdjustToSymbolicSize(size, base));
}
// Adjust the base size in points according to symbolic size.
static int AdjustToSymbolicSize(wxFontSymbolicSize size, int base);
// translate the fonts into human-readable string (i.e. GetStyleString()
// will return "wxITALIC" for an italic font, ...)
wxString GetFamilyString() const;
wxString GetStyleString() const;
wxString GetWeightString() const;
// the default encoding is used for creating all fonts with default
// encoding parameter
static wxFontEncoding GetDefaultEncoding() { return ms_encodingDefault; }
static void SetDefaultEncoding(wxFontEncoding encoding);
// Account for legacy font weight values: if the argument is one of
// wxNORMAL, wxLIGHT or wxBOLD, return the corresponding wxFONTWEIGHT_XXX
// enum value. Otherwise just return it unchanged.
static int ConvertFromLegacyWeightIfNecessary(int weight);
// Convert between symbolic and numeric font weights. This function uses
// ConvertFromLegacyWeightIfNecessary(), so takes legacy values into
// account as well.
static int GetNumericWeightOf(wxFontWeight weight);
// this doesn't do anything and is kept for compatibility only
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_INLINE(void SetNoAntiAliasing(bool no = true), wxUnusedVar(no);)
wxDEPRECATED_INLINE(bool GetNoAntiAliasing() const, return false;)
#endif // WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_MSG("use wxFONTWEIGHT_XXX constants instead of raw values")
void SetWeight(int weight)
{ SetWeight(static_cast<wxFontWeight>(weight)); }
wxDEPRECATED_MSG("use wxFONTWEIGHT_XXX constants instead of wxLIGHT/wxNORMAL/wxBOLD")
void SetWeight(wxDeprecatedGUIConstants weight)
{ SetWeight(static_cast<wxFontWeight>(weight)); }
// from the font components
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants")
static wxFont *New(
int pointSize, // size of the font in points
int family, // see wxFontFamily enum
int style, // see wxFontStyle enum
int weight, // see wxFontWeight enum
bool underlined = false, // not underlined by default
const wxString& face = wxEmptyString, // facename
wxFontEncoding encoding = wxFONTENCODING_DEFAULT) // ISO8859-X, ...
{ return New(pointSize, (wxFontFamily)family, (wxFontStyle)style,
(wxFontWeight)weight, underlined, face, encoding); }
// from the font components
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants")
static wxFont *New(
const wxSize& pixelSize, // size of the font in pixels
int family, // see wxFontFamily enum
int style, // see wxFontStyle enum
int weight, // see wxFontWeight enum
bool underlined = false, // not underlined by default
const wxString& face = wxEmptyString, // facename
wxFontEncoding encoding = wxFONTENCODING_DEFAULT) // ISO8859-X, ...
{ return New(pixelSize, (wxFontFamily)family, (wxFontStyle)style,
(wxFontWeight)weight, underlined, face, encoding); }
protected:
// the function called by both overloads of SetNativeFontInfo()
virtual void DoSetNativeFontInfo(const wxNativeFontInfo& info);
// The function called by public GetFamily(): it can return
// wxFONTFAMILY_UNKNOWN unlike the public method (see comment there).
virtual wxFontFamily DoGetFamily() const = 0;
// Helper functions to recover wxFONTSTYLE/wxFONTWEIGHT and underlined flag
// values from flags containing a combination of wxFONTFLAG_XXX.
static wxFontStyle GetStyleFromFlags(int flags)
{
return flags & wxFONTFLAG_ITALIC
? wxFONTSTYLE_ITALIC
: flags & wxFONTFLAG_SLANT
? wxFONTSTYLE_SLANT
: wxFONTSTYLE_NORMAL;
}
static wxFontWeight GetWeightFromFlags(int flags)
{
return flags & wxFONTFLAG_LIGHT
? wxFONTWEIGHT_LIGHT
: flags & wxFONTFLAG_BOLD
? wxFONTWEIGHT_BOLD
: wxFONTWEIGHT_NORMAL;
}
static bool GetUnderlinedFromFlags(int flags)
{
return (flags & wxFONTFLAG_UNDERLINED) != 0;
}
static bool GetStrikethroughFromFlags(int flags)
{
return (flags & wxFONTFLAG_STRIKETHROUGH) != 0;
}
// Create wxFontInfo object from the parameters passed to the legacy wxFont
// ctor/Create() overload. This function implements the compatibility hack
// which interprets wxDEFAULT value of size as meaning -1 and also supports
// specifying wxNORMAL, wxLIGHT and wxBOLD as weight values.
static wxFontInfo InfoFromLegacyParams(int pointSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding);
static wxFontInfo InfoFromLegacyParams(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined,
const wxString& face,
wxFontEncoding encoding);
private:
// the currently default encoding: by default, it's the default system
// encoding, but may be changed by the application using
// SetDefaultEncoding() to make all subsequent fonts created without
// specifying encoding parameter using this encoding
static wxFontEncoding ms_encodingDefault;
};
// wxFontBase <-> wxString utilities, used by wxConfig
WXDLLIMPEXP_CORE wxString wxToString(const wxFontBase& font);
WXDLLIMPEXP_CORE bool wxFromString(const wxString& str, wxFontBase* font);
// this macro must be used in all derived wxFont classes declarations
#define wxDECLARE_COMMON_FONT_METHODS() \
wxDEPRECATED_MSG("use wxFONTFAMILY_XXX constants") \
void SetFamily(int family) \
{ SetFamily((wxFontFamily)family); } \
wxDEPRECATED_MSG("use wxFONTSTYLE_XXX constants") \
void SetStyle(int style) \
{ SetStyle((wxFontStyle)style); } \
wxDEPRECATED_MSG("use wxFONTFAMILY_XXX constants") \
void SetFamily(wxDeprecatedGUIConstants family) \
{ SetFamily((wxFontFamily)family); } \
wxDEPRECATED_MSG("use wxFONTSTYLE_XXX constants") \
void SetStyle(wxDeprecatedGUIConstants style) \
{ SetStyle((wxFontStyle)style); } \
\
/* functions for modifying font in place */ \
wxFont& MakeBold(); \
wxFont& MakeItalic(); \
wxFont& MakeUnderlined(); \
wxFont& MakeStrikethrough(); \
wxFont& MakeLarger() { return Scale(1.2f); } \
wxFont& MakeSmaller() { return Scale(1/1.2f); } \
wxFont& Scale(float x); \
/* functions for creating fonts based on this one */ \
wxFont Bold() const; \
wxFont GetBaseFont() const; \
wxFont Italic() const; \
wxFont Underlined() const; \
wxFont Strikethrough() const; \
wxFont Larger() const { return Scaled(1.2f); } \
wxFont Smaller() const { return Scaled(1/1.2f); } \
wxFont Scaled(float x) const
// include the real class declaration
#if defined(__WXMSW__)
#include "wx/msw/font.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/font.h"
#elif defined(__WXGTK20__)
#include "wx/gtk/font.h"
#elif defined(__WXGTK__)
#include "wx/gtk1/font.h"
#elif defined(__WXX11__)
#include "wx/x11/font.h"
#elif defined(__WXDFB__)
#include "wx/dfb/font.h"
#elif defined(__WXMAC__)
#include "wx/osx/font.h"
#elif defined(__WXQT__)
#include "wx/qt/font.h"
#endif
class WXDLLIMPEXP_CORE wxFontList: public wxGDIObjListBase
{
public:
wxFont *FindOrCreateFont(int pointSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underline = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants")
wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
bool underline = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{ return FindOrCreateFont(pointSize, (wxFontFamily)family, (wxFontStyle)style,
(wxFontWeight)weight, underline, face, encoding); }
wxFont *FindOrCreateFont(const wxFontInfo& fontInfo)
{ return FindOrCreateFont(fontInfo.GetPointSize(), fontInfo.GetFamily(),
fontInfo.GetStyle(), fontInfo.GetWeight(),
fontInfo.IsUnderlined(), fontInfo.GetFaceName(),
fontInfo.GetEncoding()); }
};
extern WXDLLIMPEXP_DATA_CORE(wxFontList*) wxTheFontList;
// provide comparison operators to allow code such as
//
// if ( font.GetStyle() == wxFONTSTYLE_SLANT )
//
// to compile without warnings which it would otherwise provoke from some
// compilers as it compares elements of different enums
// Unfortunately some compilers have ambiguity issues when enum comparisons are
// overloaded so we have to disable the overloads in this case, see
// wxCOMPILER_NO_OVERLOAD_ON_ENUM definition in wx/platform.h for more details.
#ifndef wxCOMPILER_NO_OVERLOAD_ON_ENUM
wxDEPRECATED_MSG("use wxFONTFAMILY_XXX constants") \
inline bool operator==(wxFontFamily s, wxDeprecatedGUIConstants t)
{ return static_cast<int>(s) == static_cast<int>(t); }
wxDEPRECATED_MSG("use wxFONTFAMILY_XXX constants") \
inline bool operator!=(wxFontFamily s, wxDeprecatedGUIConstants t)
{ return static_cast<int>(s) != static_cast<int>(t); }
wxDEPRECATED_MSG("use wxFONTSTYLE_XXX constants") \
inline bool operator==(wxFontStyle s, wxDeprecatedGUIConstants t)
{ return static_cast<int>(s) == static_cast<int>(t); }
wxDEPRECATED_MSG("use wxFONTSTYLE_XXX constants") \
inline bool operator!=(wxFontStyle s, wxDeprecatedGUIConstants t)
{ return static_cast<int>(s) != static_cast<int>(t); }
wxDEPRECATED_MSG("use wxFONTWEIGHT_XXX constants") \
inline bool operator==(wxFontWeight s, wxDeprecatedGUIConstants t)
{ return static_cast<int>(s) == static_cast<int>(t); }
wxDEPRECATED_MSG("use wxFONTWEIGHT_XXX constants") \
inline bool operator!=(wxFontWeight s, wxDeprecatedGUIConstants t)
{ return static_cast<int>(s) != static_cast<int>(t); }
#endif // // wxCOMPILER_NO_OVERLOAD_ON_ENUM
#endif // _WX_FONT_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msgqueue.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msqqueue.h
// Purpose: Message queues for inter-thread communication
// Author: Evgeniy Tarassov
// Created: 2007-10-31
// Copyright: (C) 2007 TT-Solutions SARL
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSGQUEUE_H_
#define _WX_MSGQUEUE_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/thread.h"
#if wxUSE_THREADS
#include "wx/stopwatch.h"
#include "wx/beforestd.h"
#include <queue>
#include "wx/afterstd.h"
enum wxMessageQueueError
{
wxMSGQUEUE_NO_ERROR = 0, // operation completed successfully
wxMSGQUEUE_TIMEOUT, // no messages received before timeout expired
wxMSGQUEUE_MISC_ERROR // some unexpected (and fatal) error has occurred
};
// ---------------------------------------------------------------------------
// Message queue allows passing message between threads.
//
// This class is typically used for communicating between the main and worker
// threads. The main thread calls Post() and the worker thread calls Receive().
//
// For this class a message is an object of arbitrary type T. Notice that
// typically there must be some special message indicating that the thread
// should terminate as there is no other way to gracefully shutdown a thread
// waiting on the message queue.
// ---------------------------------------------------------------------------
template <typename T>
class wxMessageQueue
{
public:
// The type of the messages transported by this queue
typedef T Message;
// Default ctor creates an initially empty queue
wxMessageQueue()
: m_conditionNotEmpty(m_mutex)
{
}
// Add a message to this queue and signal the threads waiting for messages.
//
// This method is safe to call from multiple threads in parallel.
wxMessageQueueError Post(const Message& msg)
{
wxMutexLocker locker(m_mutex);
wxCHECK( locker.IsOk(), wxMSGQUEUE_MISC_ERROR );
m_messages.push(msg);
m_conditionNotEmpty.Signal();
return wxMSGQUEUE_NO_ERROR;
}
// Remove all messages from the queue.
//
// This method is meant to be called from the same thread(s) that call
// Post() to discard any still pending requests if they became unnecessary.
wxMessageQueueError Clear()
{
wxCHECK( IsOk(), wxMSGQUEUE_MISC_ERROR );
wxMutexLocker locker(m_mutex);
std::queue<T> empty;
std::swap(m_messages, empty);
return wxMSGQUEUE_NO_ERROR;
}
// Wait no more than timeout milliseconds until a message becomes available.
//
// Setting timeout to 0 is equivalent to an infinite timeout. See Receive().
wxMessageQueueError ReceiveTimeout(long timeout, T& msg)
{
wxCHECK( IsOk(), wxMSGQUEUE_MISC_ERROR );
wxMutexLocker locker(m_mutex);
wxCHECK( locker.IsOk(), wxMSGQUEUE_MISC_ERROR );
const wxMilliClock_t waitUntil = wxGetLocalTimeMillis() + timeout;
while ( m_messages.empty() )
{
wxCondError result = m_conditionNotEmpty.WaitTimeout(timeout);
if ( result == wxCOND_NO_ERROR )
continue;
wxCHECK( result == wxCOND_TIMEOUT, wxMSGQUEUE_MISC_ERROR );
const wxMilliClock_t now = wxGetLocalTimeMillis();
if ( now >= waitUntil )
return wxMSGQUEUE_TIMEOUT;
timeout = (waitUntil - now).ToLong();
wxASSERT(timeout > 0);
}
msg = m_messages.front();
m_messages.pop();
return wxMSGQUEUE_NO_ERROR;
}
// Same as ReceiveTimeout() but waits for as long as it takes for a message
// to become available (so it can't return wxMSGQUEUE_TIMEOUT)
wxMessageQueueError Receive(T& msg)
{
wxCHECK( IsOk(), wxMSGQUEUE_MISC_ERROR );
wxMutexLocker locker(m_mutex);
wxCHECK( locker.IsOk(), wxMSGQUEUE_MISC_ERROR );
while ( m_messages.empty() )
{
wxCondError result = m_conditionNotEmpty.Wait();
wxCHECK( result == wxCOND_NO_ERROR, wxMSGQUEUE_MISC_ERROR );
}
msg = m_messages.front();
m_messages.pop();
return wxMSGQUEUE_NO_ERROR;
}
// Return false only if there was a fatal error in ctor
bool IsOk() const
{
return m_conditionNotEmpty.IsOk();
}
private:
// Disable copy ctor and assignment operator
wxMessageQueue(const wxMessageQueue<T>& rhs);
wxMessageQueue<T>& operator=(const wxMessageQueue<T>& rhs);
mutable wxMutex m_mutex;
wxCondition m_conditionNotEmpty;
std::queue<T> m_messages;
};
#endif // wxUSE_THREADS
#endif // _WX_MSGQUEUE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/tokenzr.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/tokenzr.h
// Purpose: String tokenizer - a C++ replacement for strtok(3)
// Author: Guilhem Lavaux
// Modified by: (or rather rewritten by) Vadim Zeitlin
// Created: 04/22/98
// Copyright: (c) Guilhem Lavaux
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOKENZRH
#define _WX_TOKENZRH
#include "wx/object.h"
#include "wx/string.h"
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// default: delimiters are usual white space characters
#define wxDEFAULT_DELIMITERS (wxT(" \t\r\n"))
// wxStringTokenizer mode flags which determine its behaviour
enum wxStringTokenizerMode
{
wxTOKEN_INVALID = -1, // set by def ctor until SetString() is called
wxTOKEN_DEFAULT, // strtok() for whitespace delims, RET_EMPTY else
wxTOKEN_RET_EMPTY, // return empty token in the middle of the string
wxTOKEN_RET_EMPTY_ALL, // return trailing empty tokens too
wxTOKEN_RET_DELIMS, // return the delim with token (implies RET_EMPTY)
wxTOKEN_STRTOK // behave exactly like strtok(3)
};
// ----------------------------------------------------------------------------
// wxStringTokenizer: replaces infamous strtok() and has some other features
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStringTokenizer : public wxObject
{
public:
// ctors and initializers
// default ctor, call SetString() later
wxStringTokenizer() { m_mode = wxTOKEN_INVALID; }
// ctor which gives us the string
wxStringTokenizer(const wxString& str,
const wxString& delims = wxDEFAULT_DELIMITERS,
wxStringTokenizerMode mode = wxTOKEN_DEFAULT);
// copy ctor and assignment operator
wxStringTokenizer(const wxStringTokenizer& src);
wxStringTokenizer& operator=(const wxStringTokenizer& src);
// args are same as for the non default ctor above
void SetString(const wxString& str,
const wxString& delims = wxDEFAULT_DELIMITERS,
wxStringTokenizerMode mode = wxTOKEN_DEFAULT);
// reinitialize the tokenizer with the same delimiters/mode
void Reinit(const wxString& str);
// tokens access
// return the number of remaining tokens
size_t CountTokens() const;
// did we reach the end of the string?
bool HasMoreTokens() const;
// get the next token, will return empty string if !HasMoreTokens()
wxString GetNextToken();
// get the delimiter which terminated the token last retrieved by
// GetNextToken() or NUL if there had been no tokens yet or the last
// one wasn't terminated (but ran to the end of the string)
wxChar GetLastDelimiter() const { return m_lastDelim; }
// get current tokenizer state
// returns the part of the string which remains to tokenize (*not* the
// initial string)
wxString GetString() const { return wxString(m_pos, m_string.end()); }
// returns the current position (i.e. one index after the last
// returned token or 0 if GetNextToken() has never been called) in the
// original string
size_t GetPosition() const { return m_pos - m_string.begin(); }
// misc
// get the current mode - can be different from the one passed to the
// ctor if it was wxTOKEN_DEFAULT
wxStringTokenizerMode GetMode() const { return m_mode; }
// do we return empty tokens?
bool AllowEmpty() const { return m_mode != wxTOKEN_STRTOK; }
// backwards compatibility section from now on
// -------------------------------------------
// for compatibility only, use GetNextToken() instead
wxString NextToken() { return GetNextToken(); }
// compatibility only, don't use
void SetString(const wxString& to_tokenize,
const wxString& delims,
bool WXUNUSED(ret_delim))
{
SetString(to_tokenize, delims, wxTOKEN_RET_DELIMS);
}
wxStringTokenizer(const wxString& to_tokenize,
const wxString& delims,
bool ret_delim)
{
SetString(to_tokenize, delims, ret_delim);
}
protected:
bool IsOk() const { return m_mode != wxTOKEN_INVALID; }
bool DoHasMoreTokens() const;
void DoCopyFrom(const wxStringTokenizer& src);
enum MoreTokensState
{
MoreTokens_Unknown,
MoreTokens_Yes,
MoreTokens_No
};
MoreTokensState m_hasMoreTokens;
wxString m_string; // the string we tokenize
wxString::const_iterator m_stringEnd;
// FIXME-UTF8: use wxWcharBuffer
wxWxCharBuffer m_delims; // all possible delimiters
size_t m_delimsLen;
wxString::const_iterator m_pos; // the current position in m_string
wxStringTokenizerMode m_mode; // see wxTOKEN_XXX values
wxChar m_lastDelim; // delimiter after last token or '\0'
};
// ----------------------------------------------------------------------------
// convenience function which returns all tokens at once
// ----------------------------------------------------------------------------
// the function takes the same parameters as wxStringTokenizer ctor and returns
// the array containing all tokens
wxArrayString WXDLLIMPEXP_BASE
wxStringTokenize(const wxString& str,
const wxString& delims = wxDEFAULT_DELIMITERS,
wxStringTokenizerMode mode = wxTOKEN_DEFAULT);
#endif // _WX_TOKENZRH
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/filectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/filectrl.h
// Purpose: Header for wxFileCtrlBase and other common functions used by
// platform-specific wxFileCtrl's
// Author: Diaa M. Sami
// Modified by:
// Created: Jul-07-2007
// Copyright: (c) Diaa M. Sami
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FILECTRL_H_BASE_
#define _WX_FILECTRL_H_BASE_
#include "wx/defs.h"
#if wxUSE_FILECTRL
#include "wx/string.h"
#include "wx/event.h"
enum
{
wxFC_OPEN = 0x0001,
wxFC_SAVE = 0x0002,
wxFC_MULTIPLE = 0x0004,
wxFC_NOSHOWHIDDEN = 0x0008
};
#define wxFC_DEFAULT_STYLE wxFC_OPEN
extern WXDLLIMPEXP_DATA_CORE(const char) wxFileCtrlNameStr[]; // in filectrlcmn.cpp
class WXDLLIMPEXP_CORE wxFileCtrlBase
{
public:
virtual ~wxFileCtrlBase() {}
virtual void SetWildcard( const wxString& wildCard ) = 0;
virtual void SetFilterIndex( int filterindex ) = 0;
virtual bool SetDirectory( const wxString& dir ) = 0;
// Selects a certain file.
// In case the filename specified isn't found/couldn't be shown with
// currently selected filter, false is returned and nothing happens
virtual bool SetFilename( const wxString& name ) = 0;
// chdirs to a certain directory and selects a certain file.
// In case the filename specified isn't found/couldn't be shown with
// currently selected filter, false is returned and if directory exists
// it's chdir'ed to
virtual bool SetPath( const wxString& path ) = 0;
virtual wxString GetFilename() const = 0;
virtual wxString GetDirectory() const = 0;
virtual wxString GetWildcard() const = 0;
virtual wxString GetPath() const = 0;
virtual void GetPaths( wxArrayString& paths ) const = 0;
virtual void GetFilenames( wxArrayString& files ) const = 0;
virtual int GetFilterIndex() const = 0;
virtual bool HasMultipleFileSelection() const = 0;
virtual void ShowHidden(bool show) = 0;
};
void wxGenerateFilterChangedEvent( wxFileCtrlBase *fileCtrl, wxWindow *wnd );
void wxGenerateFolderChangedEvent( wxFileCtrlBase *fileCtrl, wxWindow *wnd );
void wxGenerateSelectionChangedEvent( wxFileCtrlBase *fileCtrl, wxWindow *wnd );
void wxGenerateFileActivatedEvent( wxFileCtrlBase *fileCtrl, wxWindow *wnd, const wxString& filename = wxEmptyString );
#if defined(__WXGTK20__) && !defined(__WXUNIVERSAL__)
#define wxFileCtrl wxGtkFileCtrl
#include "wx/gtk/filectrl.h"
#else
#define wxFileCtrl wxGenericFileCtrl
#include "wx/generic/filectrlg.h"
#endif
// Some documentation
// On wxEVT_FILECTRL_FILTERCHANGED, only the value returned by GetFilterIndex is
// valid and it represents the (new) current filter index for the wxFileCtrl.
// On wxEVT_FILECTRL_FOLDERCHANGED, only the value returned by GetDirectory is
// valid and it represents the (new) current directory for the wxFileCtrl.
// On wxEVT_FILECTRL_FILEACTIVATED, GetDirectory returns the current directory
// for the wxFileCtrl and GetFiles returns the names of the file(s) activated.
// On wxEVT_FILECTRL_SELECTIONCHANGED, GetDirectory returns the current directory
// for the wxFileCtrl and GetFiles returns the names of the currently selected
// file(s).
// In wxGTK, after each wxEVT_FILECTRL_FOLDERCHANGED, wxEVT_FILECTRL_SELECTIONCHANGED
// is fired automatically once or more with 0 files.
class WXDLLIMPEXP_CORE wxFileCtrlEvent : public wxCommandEvent
{
public:
wxFileCtrlEvent() {}
wxFileCtrlEvent( wxEventType type, wxObject *evtObject, int id )
: wxCommandEvent( type, id )
{
SetEventObject( evtObject );
}
// no need for the copy constructor as the default one will be fine.
virtual wxEvent *Clone() const wxOVERRIDE { return new wxFileCtrlEvent( *this ); }
void SetFiles( const wxArrayString &files ) { m_files = files; }
void SetDirectory( const wxString &directory ) { m_directory = directory; }
void SetFilterIndex( int filterIndex ) { m_filterIndex = filterIndex; }
wxArrayString GetFiles() const { return m_files; }
wxString GetDirectory() const { return m_directory; }
int GetFilterIndex() const { return m_filterIndex; }
wxString GetFile() const;
protected:
int m_filterIndex;
wxString m_directory;
wxArrayString m_files;
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxFileCtrlEvent);
};
typedef void ( wxEvtHandler::*wxFileCtrlEventFunction )( wxFileCtrlEvent& );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_FILECTRL_SELECTIONCHANGED, wxFileCtrlEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_FILECTRL_FILEACTIVATED, wxFileCtrlEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_FILECTRL_FOLDERCHANGED, wxFileCtrlEvent );
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_FILECTRL_FILTERCHANGED, wxFileCtrlEvent );
#define wxFileCtrlEventHandler(func) \
wxEVENT_HANDLER_CAST( wxFileCtrlEventFunction, func )
#define EVT_FILECTRL_FILEACTIVATED(id, fn) \
wx__DECLARE_EVT1(wxEVT_FILECTRL_FILEACTIVATED, id, wxFileCtrlEventHandler(fn))
#define EVT_FILECTRL_SELECTIONCHANGED(id, fn) \
wx__DECLARE_EVT1(wxEVT_FILECTRL_SELECTIONCHANGED, id, wxFileCtrlEventHandler(fn))
#define EVT_FILECTRL_FOLDERCHANGED(id, fn) \
wx__DECLARE_EVT1(wxEVT_FILECTRL_FOLDERCHANGED, id, wxFileCtrlEventHandler(fn))
#define EVT_FILECTRL_FILTERCHANGED(id, fn) \
wx__DECLARE_EVT1(wxEVT_FILECTRL_FILTERCHANGED, id, wxFileCtrlEventHandler(fn))
#endif // wxUSE_FILECTRL
#endif // _WX_FILECTRL_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/wxcrtbase.h | /*
* Name: wx/wxcrtbase.h
* Purpose: Type-safe ANSI and Unicode builds compatible wrappers for
* CRT functions
* Author: Joel Farley, Ove Kaaven
* Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
* Created: 1998/06/12
* Copyright: (c) 1998-2006 wxWidgets dev team
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_WXCRTBASE_H_
#define _WX_WXCRTBASE_H_
/* -------------------------------------------------------------------------
headers and missing declarations
------------------------------------------------------------------------- */
#include "wx/chartype.h"
/*
Standard headers we need here.
NB: don't include any wxWidgets headers here because almost all of them
include this one!
NB2: User code should include wx/crt.h instead of including this
header directly.
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <wctype.h>
#include <time.h>
#if defined(__WINDOWS__)
#include <io.h>
#endif
#if defined(HAVE_STRTOK_R) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
char *strtok_r(char *, const char *, char **);
#endif
/*
Traditional MinGW doesn't declare isascii() in strict ANSI mode and we can't
declare it here ourselves as it's an inline function, so use our own
replacement instead.
*/
#ifndef isascii
#if defined(wxNEEDS_STRICT_ANSI_WORKAROUNDS)
#define wxNEED_ISASCII
#endif
#endif /* isascii */
#ifdef wxNEED_ISASCII
inline int isascii(int c) { return (unsigned)c < 0x80; }
// Avoid further (re)definitions of it.
#define isascii isascii
#endif
/* string.h functions */
#ifdef wxNEED_STRDUP
WXDLLIMPEXP_BASE char *strdup(const char* s);
#endif
/* -------------------------------------------------------------------------
UTF-8 locale handling
------------------------------------------------------------------------- */
#ifdef __cplusplus
/* flag indicating whether the current locale uses UTF-8 or not; must be
updated every time the locale is changed! */
#if wxUSE_UTF8_LOCALE_ONLY
#define wxLocaleIsUtf8 true
#else
extern WXDLLIMPEXP_BASE bool wxLocaleIsUtf8;
#endif
/* function used to update the flag: */
extern WXDLLIMPEXP_BASE void wxUpdateLocaleIsUtf8();
#endif /* __cplusplus */
/* -------------------------------------------------------------------------
string.h
------------------------------------------------------------------------- */
#define wxCRT_StrcatA strcat
#define wxCRT_StrchrA strchr
#define wxCRT_StrcmpA strcmp
#define wxCRT_StrcpyA strcpy
#define wxCRT_StrcspnA strcspn
#define wxCRT_StrlenA strlen
#define wxCRT_StrncatA strncat
#define wxCRT_StrncmpA strncmp
#define wxCRT_StrncpyA strncpy
#define wxCRT_StrpbrkA strpbrk
#define wxCRT_StrrchrA strrchr
#define wxCRT_StrspnA strspn
#define wxCRT_StrstrA strstr
#define wxCRT_StrcatW wcscat
#define wxCRT_StrchrW wcschr
#define wxCRT_StrcmpW wcscmp
#define wxCRT_StrcpyW wcscpy
#define wxCRT_StrcspnW wcscspn
#define wxCRT_StrncatW wcsncat
#define wxCRT_StrncmpW wcsncmp
#define wxCRT_StrncpyW wcsncpy
#define wxCRT_StrpbrkW wcspbrk
#define wxCRT_StrrchrW wcsrchr
#define wxCRT_StrspnW wcsspn
#define wxCRT_StrstrW wcsstr
#define wxCRT_StrcollA strcoll
#define wxCRT_StrxfrmA strxfrm
#define wxCRT_StrcollW wcscoll
#define wxCRT_StrxfrmW wcsxfrm
/* Almost all compilers have strdup(), but VC++ and MinGW call it _strdup().
And we need to declare it manually for MinGW in strict ANSI mode. */
#if (defined(__VISUALC__) && __VISUALC__ >= 1400)
#define wxCRT_StrdupA _strdup
#elif defined(__MINGW32__)
wxDECL_FOR_STRICT_MINGW32(char*, _strdup, (const char *))
#define wxCRT_StrdupA _strdup
#else
#define wxCRT_StrdupA strdup
#endif
/* Windows compilers provide _wcsdup() except for (old) Cygwin */
#if defined(__WINDOWS__) && !defined(__CYGWIN__)
wxDECL_FOR_STRICT_MINGW32(wchar_t*, _wcsdup, (const wchar_t*))
#define wxCRT_StrdupW _wcsdup
#elif defined(HAVE_WCSDUP)
#define wxCRT_StrdupW wcsdup
#endif
#ifdef wxHAVE_TCHAR_SUPPORT
/* we surely have wchar_t if we have TCHAR have wcslen() */
#ifndef HAVE_WCSLEN
#define HAVE_WCSLEN
#endif
#endif /* wxHAVE_TCHAR_SUPPORT */
#ifdef HAVE_WCSLEN
#define wxCRT_StrlenW wcslen
#endif
#define wxCRT_StrtodA strtod
#define wxCRT_StrtolA strtol
#define wxCRT_StrtoulA strtoul
#ifdef __ANDROID__ // these functions are broken on android
extern double android_wcstod(const wchar_t *nptr, wchar_t **endptr);
extern long android_wcstol(const wchar_t *nptr, wchar_t **endptr, int base);
extern unsigned long android_wcstoul(const wchar_t *nptr, wchar_t **endptr, int base);
#define wxCRT_StrtodW android_wcstod
#define wxCRT_StrtolW android_wcstol
#define wxCRT_StrtoulW android_wcstoul
#else
#define wxCRT_StrtodW wcstod
#define wxCRT_StrtolW wcstol
#define wxCRT_StrtoulW wcstoul
#endif
#ifdef __VISUALC__
#define wxCRT_StrtollA _strtoi64
#define wxCRT_StrtoullA _strtoui64
#define wxCRT_StrtollW _wcstoi64
#define wxCRT_StrtoullW _wcstoui64
#else
/* Both of these functions are implemented in C++11 compilers */
#if defined(__cplusplus) && __cplusplus >= 201103L
#ifndef HAVE_STRTOULL
#define HAVE_STRTOULL
#endif
#ifndef HAVE_WCSTOULL
#define HAVE_WCSTOULL
#endif
#endif
#ifdef HAVE_STRTOULL
wxDECL_FOR_STRICT_MINGW32(long long, strtoll, (const char*, char**, int))
wxDECL_FOR_STRICT_MINGW32(unsigned long long, strtoull, (const char*, char**, int))
#define wxCRT_StrtollA strtoll
#define wxCRT_StrtoullA strtoull
#endif /* HAVE_STRTOULL */
#ifdef HAVE_WCSTOULL
/* assume that we have wcstoull(), which is also C99, too */
#define wxCRT_StrtollW wcstoll
#define wxCRT_StrtoullW wcstoull
#endif /* HAVE_WCSTOULL */
#endif
/*
Only VC8 and later provide strnlen() and wcsnlen() functions under Windows.
*/
#if wxCHECK_VISUALC_VERSION(8)
#ifndef HAVE_STRNLEN
#define HAVE_STRNLEN
#endif
#ifndef HAVE_WCSNLEN
#define HAVE_WCSNLEN
#endif
#endif
#ifdef HAVE_STRNLEN
#define wxCRT_StrnlenA strnlen
#endif
#ifdef HAVE_WCSNLEN
/*
When using MinGW, wcsnlen() is not declared, but is still found by
configure -- just declare it in this case as it seems better to use it
if it's available (see https://sourceforge.net/p/mingw/bugs/2332/)
*/
wxDECL_FOR_MINGW32_ALWAYS(size_t, wcsnlen, (const wchar_t*, size_t))
#define wxCRT_StrnlenW wcsnlen
#endif
/* define wxCRT_StricmpA/W and wxCRT_StrnicmpA/W for various compilers */
#if defined(__BORLANDC__)
#define wxCRT_StricmpA stricmp
#define wxCRT_StrnicmpA strnicmp
#elif defined(__VISUALC__) || defined(__MINGW32__)
/*
Due to MinGW 5.3 bug (https://sourceforge.net/p/mingw/bugs/2322/),
_stricmp() and _strnicmp() are not declared in its standard headers
when compiling without optimizations. Work around this by always
declaring them ourselves (notice that if/when this bug were fixed, we'd
still need to use wxDECL_FOR_STRICT_MINGW32() for them here.
*/
wxDECL_FOR_MINGW32_ALWAYS(int, _stricmp, (const char*, const char*))
wxDECL_FOR_MINGW32_ALWAYS(int, _strnicmp, (const char*, const char*, size_t))
#define wxCRT_StricmpA _stricmp
#define wxCRT_StrnicmpA _strnicmp
#elif defined(__UNIX__)
#define wxCRT_StricmpA strcasecmp
#define wxCRT_StrnicmpA strncasecmp
/* #else -- use wxWidgets implementation */
#endif
#ifdef __VISUALC__
#define wxCRT_StricmpW _wcsicmp
#define wxCRT_StrnicmpW _wcsnicmp
#elif defined(__UNIX__)
#ifdef HAVE_WCSCASECMP
#define wxCRT_StricmpW wcscasecmp
#endif
#ifdef HAVE_WCSNCASECMP
#define wxCRT_StrnicmpW wcsncasecmp
#endif
/* #else -- use wxWidgets implementation */
#endif
#ifdef HAVE_STRTOK_R
#define wxCRT_StrtokA(str, sep, last) strtok_r(str, sep, last)
#endif
/* FIXME-UTF8: detect and use wcstok() if available for wxCRT_StrtokW */
/* these are extern "C" because they are used by regex lib: */
#ifdef __cplusplus
extern "C" {
#endif
#ifndef wxCRT_StrlenW
WXDLLIMPEXP_BASE size_t wxCRT_StrlenW(const wchar_t *s);
#endif
#ifndef wxCRT_StrncmpW
WXDLLIMPEXP_BASE int wxCRT_StrncmpW(const wchar_t *s1, const wchar_t *s2, size_t n);
#endif
#ifdef __cplusplus
}
#endif
/* FIXME-UTF8: remove this once we are Unicode only */
#if wxUSE_UNICODE
#define wxCRT_StrlenNative wxCRT_StrlenW
#define wxCRT_StrncmpNative wxCRT_StrncmpW
#define wxCRT_ToupperNative wxCRT_ToupperW
#define wxCRT_TolowerNative wxCRT_TolowerW
#else
#define wxCRT_StrlenNative wxCRT_StrlenA
#define wxCRT_StrncmpNative wxCRT_StrncmpA
#define wxCRT_ToupperNative toupper
#define wxCRT_TolowerNative tolower
#endif
#ifndef wxCRT_StrcatW
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrcatW(wchar_t *dest, const wchar_t *src);
#endif
#ifndef wxCRT_StrchrW
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrchrW(const wchar_t *s, wchar_t c);
#endif
#ifndef wxCRT_StrcmpW
WXDLLIMPEXP_BASE int wxCRT_StrcmpW(const wchar_t *s1, const wchar_t *s2);
#endif
#ifndef wxCRT_StrcollW
WXDLLIMPEXP_BASE int wxCRT_StrcollW(const wchar_t *s1, const wchar_t *s2);
#endif
#ifndef wxCRT_StrcpyW
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrcpyW(wchar_t *dest, const wchar_t *src);
#endif
#ifndef wxCRT_StrcspnW
WXDLLIMPEXP_BASE size_t wxCRT_StrcspnW(const wchar_t *s, const wchar_t *reject);
#endif
#ifndef wxCRT_StrncatW
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrncatW(wchar_t *dest, const wchar_t *src, size_t n);
#endif
#ifndef wxCRT_StrncpyW
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrncpyW(wchar_t *dest, const wchar_t *src, size_t n);
#endif
#ifndef wxCRT_StrpbrkW
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrpbrkW(const wchar_t *s, const wchar_t *accept);
#endif
#ifndef wxCRT_StrrchrW
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrrchrW(const wchar_t *s, wchar_t c);
#endif
#ifndef wxCRT_StrspnW
WXDLLIMPEXP_BASE size_t wxCRT_StrspnW(const wchar_t *s, const wchar_t *accept);
#endif
#ifndef wxCRT_StrstrW
WXDLLIMPEXP_BASE const wchar_t *wxCRT_StrstrW(const wchar_t *haystack, const wchar_t *needle);
#endif
#ifndef wxCRT_StrtodW
WXDLLIMPEXP_BASE double wxCRT_StrtodW(const wchar_t *nptr, wchar_t **endptr);
#endif
#ifndef wxCRT_StrtolW
WXDLLIMPEXP_BASE long int wxCRT_StrtolW(const wchar_t *nptr, wchar_t **endptr, int base);
#endif
#ifndef wxCRT_StrtoulW
WXDLLIMPEXP_BASE unsigned long int wxCRT_StrtoulW(const wchar_t *nptr, wchar_t **endptr, int base);
#endif
#ifndef wxCRT_StrxfrmW
WXDLLIMPEXP_BASE size_t wxCRT_StrxfrmW(wchar_t *dest, const wchar_t *src, size_t n);
#endif
#ifndef wxCRT_StrdupA
WXDLLIMPEXP_BASE char *wxCRT_StrdupA(const char *psz);
#endif
#ifndef wxCRT_StrdupW
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrdupW(const wchar_t *pwz);
#endif
#ifndef wxCRT_StricmpA
WXDLLIMPEXP_BASE int wxCRT_StricmpA(const char *psz1, const char *psz2);
#endif
#ifndef wxCRT_StricmpW
WXDLLIMPEXP_BASE int wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2);
#endif
#ifndef wxCRT_StrnicmpA
WXDLLIMPEXP_BASE int wxCRT_StrnicmpA(const char *psz1, const char *psz2, size_t len);
#endif
#ifndef wxCRT_StrnicmpW
WXDLLIMPEXP_BASE int wxCRT_StrnicmpW(const wchar_t *psz1, const wchar_t *psz2, size_t len);
#endif
#ifndef wxCRT_StrtokA
WXDLLIMPEXP_BASE char *wxCRT_StrtokA(char *psz, const char *delim, char **save_ptr);
#endif
#ifndef wxCRT_StrtokW
WXDLLIMPEXP_BASE wchar_t *wxCRT_StrtokW(wchar_t *psz, const wchar_t *delim, wchar_t **save_ptr);
#endif
/* supply strtoll and strtoull, if needed */
#ifdef wxLongLong_t
#ifndef wxCRT_StrtollA
WXDLLIMPEXP_BASE wxLongLong_t wxCRT_StrtollA(const char* nptr,
char** endptr,
int base);
WXDLLIMPEXP_BASE wxULongLong_t wxCRT_StrtoullA(const char* nptr,
char** endptr,
int base);
#endif
#ifndef wxCRT_StrtollW
WXDLLIMPEXP_BASE wxLongLong_t wxCRT_StrtollW(const wchar_t* nptr,
wchar_t** endptr,
int base);
WXDLLIMPEXP_BASE wxULongLong_t wxCRT_StrtoullW(const wchar_t* nptr,
wchar_t** endptr,
int base);
#endif
#endif /* wxLongLong_t */
/* -------------------------------------------------------------------------
stdio.h
------------------------------------------------------------------------- */
#if defined(__UNIX__) || defined(__WXMAC__)
#define wxMBFILES 1
#else
#define wxMBFILES 0
#endif
/* these functions are only needed in the form used for filenames (i.e. char*
on Unix, wchar_t* on Windows), so we don't need to use A/W suffix: */
#if wxMBFILES || !wxUSE_UNICODE /* ANSI filenames */
#define wxCRT_Fopen fopen
#define wxCRT_Freopen freopen
#define wxCRT_Remove remove
#define wxCRT_Rename rename
#else /* Unicode filenames */
wxDECL_FOR_STRICT_MINGW32(FILE*, _wfopen, (const wchar_t*, const wchar_t*))
wxDECL_FOR_STRICT_MINGW32(FILE*, _wfreopen, (const wchar_t*, const wchar_t*, FILE*))
wxDECL_FOR_STRICT_MINGW32(int, _wrename, (const wchar_t*, const wchar_t*))
wxDECL_FOR_STRICT_MINGW32(int, _wremove, (const wchar_t*))
#define wxCRT_Rename _wrename
#define wxCRT_Remove _wremove
#define wxCRT_Fopen _wfopen
#define wxCRT_Freopen _wfreopen
#endif /* wxMBFILES/!wxMBFILES */
#define wxCRT_PutsA puts
#define wxCRT_FputsA fputs
#define wxCRT_FgetsA fgets
#define wxCRT_FputcA fputc
#define wxCRT_FgetcA fgetc
#define wxCRT_UngetcA ungetc
#ifdef wxHAVE_TCHAR_SUPPORT
#define wxCRT_PutsW _putws
#define wxCRT_FputsW fputws
#define wxCRT_FputcW fputwc
#endif
#ifdef HAVE_FPUTWS
#define wxCRT_FputsW fputws
#endif
#ifdef HAVE_PUTWS
#define wxCRT_PutsW putws
#endif
#ifdef HAVE_FPUTWC
#define wxCRT_FputcW fputwc
#endif
#define wxCRT_FgetsW fgetws
#ifndef wxCRT_PutsW
WXDLLIMPEXP_BASE int wxCRT_PutsW(const wchar_t *ws);
#endif
#ifndef wxCRT_FputsW
WXDLLIMPEXP_BASE int wxCRT_FputsW(const wchar_t *ch, FILE *stream);
#endif
#ifndef wxCRT_FputcW
WXDLLIMPEXP_BASE int wxCRT_FputcW(wchar_t wc, FILE *stream);
#endif
/*
NB: tmpnam() is unsafe and thus is not wrapped!
Use other wxWidgets facilities instead:
wxFileName::CreateTempFileName, wxTempFile, or wxTempFileOutputStream
*/
#define wxTmpnam(x) wxTmpnam_is_insecure_use_wxTempFile_instead
#define wxCRT_PerrorA perror
#ifdef wxHAVE_TCHAR_SUPPORT
#define wxCRT_PerrorW _wperror
#endif
/* -------------------------------------------------------------------------
stdlib.h
------------------------------------------------------------------------- */
#define wxCRT_GetenvA getenv
#ifdef _tgetenv
#define wxCRT_GetenvW _wgetenv
#endif
#ifndef wxCRT_GetenvW
WXDLLIMPEXP_BASE wchar_t * wxCRT_GetenvW(const wchar_t *name);
#endif
#define wxCRT_SystemA system
/* mingw32 doesn't provide _tsystem() or _wsystem(): */
#if defined(_tsystem)
#define wxCRT_SystemW _wsystem
#endif
#define wxCRT_AtofA atof
#define wxCRT_AtoiA atoi
#define wxCRT_AtolA atol
#if defined(wxHAVE_TCHAR_SUPPORT)
wxDECL_FOR_STRICT_MINGW32(int, _wtoi, (const wchar_t*))
wxDECL_FOR_STRICT_MINGW32(long, _wtol, (const wchar_t*))
#define wxCRT_AtoiW _wtoi
#define wxCRT_AtolW _wtol
/* _wtof doesn't exist */
#else
#ifndef __VMS
#define wxCRT_AtofW(s) wcstod(s, NULL)
#endif
#define wxCRT_AtolW(s) wcstol(s, NULL, 10)
/* wcstoi doesn't exist */
#endif
/* -------------------------------------------------------------------------
time.h
------------------------------------------------------------------------- */
#define wxCRT_StrftimeA strftime
#ifdef __SGI__
/*
IRIX provides not one but two versions of wcsftime(): XPG4 one which
uses "const char*" for the third parameter and so can't be used and the
correct, XPG5, one. Unfortunately we can't just define _XOPEN_SOURCE
high enough to get XPG5 version as this undefines other symbols which
make other functions we use unavailable (see <standards.h> for gory
details). So just declare the XPG5 version ourselves, we're extremely
unlikely to ever be compiled on a system without it. But if we ever do,
a configure test would need to be added for it (and _MIPS_SYMBOL_PRESENT
should be used to check for its presence during run-time, i.e. it would
probably be simpler to just always use our own wxCRT_StrftimeW() below
if it does ever become a problem).
*/
#ifdef __cplusplus
extern "C"
#endif
size_t
_xpg5_wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm * );
#define wxCRT_StrftimeW _xpg5_wcsftime
#else
/*
Assume it's always available under non-Unix systems as this does seem
to be the case for now. And under Unix we trust configure to detect it
(except for SGI special case above).
*/
#if defined(HAVE_WCSFTIME) || !defined(__UNIX__)
#define wxCRT_StrftimeW wcsftime
#endif
#endif
#ifndef wxCRT_StrftimeW
WXDLLIMPEXP_BASE size_t wxCRT_StrftimeW(wchar_t *s, size_t max,
const wchar_t *fmt,
const struct tm *tm);
#endif
/* -------------------------------------------------------------------------
ctype.h
------------------------------------------------------------------------- */
#define wxCRT_IsalnumW(c) iswalnum(c)
#define wxCRT_IsalphaW(c) iswalpha(c)
#define wxCRT_IscntrlW(c) iswcntrl(c)
#define wxCRT_IsdigitW(c) iswdigit(c)
#define wxCRT_IsgraphW(c) iswgraph(c)
#define wxCRT_IslowerW(c) iswlower(c)
#define wxCRT_IsprintW(c) iswprint(c)
#define wxCRT_IspunctW(c) iswpunct(c)
#define wxCRT_IsspaceW(c) iswspace(c)
#define wxCRT_IsupperW(c) iswupper(c)
#define wxCRT_IsxdigitW(c) iswxdigit(c)
#ifdef __GLIBC__
#if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
/* /usr/include/wctype.h incorrectly declares translations */
/* tables which provokes tons of compile-time warnings -- try */
/* to correct this */
#define wxCRT_TolowerW(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
#define wxCRT_ToupperW(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
#else /* !glibc 2.0 */
#define wxCRT_TolowerW towlower
#define wxCRT_ToupperW towupper
#endif
#else /* !__GLIBC__ */
/* There is a bug in MSVC RTL: toxxx() functions don't do anything
with signed chars < 0, so "fix" it here. */
#define wxCRT_TolowerW(c) towlower((wxUChar)(wxChar)(c))
#define wxCRT_ToupperW(c) towupper((wxUChar)(wxChar)(c))
#endif /* __GLIBC__/!__GLIBC__ */
/* The Android platform, as of 2014, only support most wide-char function with
the exception of multi-byte encoding/decoding functions & wsprintf/wsscanf
See android-ndk-r9d/docs/STANDALONE-TOOLCHAIN.html (section 7.2)
In fact, mbstowcs/wcstombs are defined and compile, but don't work correctly
*/
#if defined(__WXQT__) && defined(__ANDROID__)
#define wxNEED_WX_MBSTOWCS
#undef HAVE_WCSRTOMBS
// TODO: use Qt built-in required functionality
#endif
#if defined(wxNEED_WX_MBSTOWCS) && defined(__ANDROID__)
#warning "Custom mb/wchar conv. only works for ASCII, see Android NDK notes"
WXDLLIMPEXP_BASE size_t android_mbstowcs(wchar_t *, const char *, size_t);
WXDLLIMPEXP_BASE size_t android_wcstombs(char *, const wchar_t *, size_t);
#define wxMbstowcs android_mbstowcs
#define wxWcstombs android_wcstombs
#else
#define wxMbstowcs mbstowcs
#define wxWcstombs wcstombs
#endif
/* -------------------------------------------------------------------------
wx wrappers for CRT functions in both char* and wchar_t* versions
------------------------------------------------------------------------- */
#ifdef __cplusplus
/* NB: this belongs to wxcrt.h and not this header, but it makes life easier
* for buffer.h and stringimpl.h (both of which must be included before
* string.h, which is required by wxcrt.h) to have them here: */
/* safe version of strlen() (returns 0 if passed NULL pointer) */
inline size_t wxStrlen(const char *s) { return s ? wxCRT_StrlenA(s) : 0; }
inline size_t wxStrlen(const wchar_t *s) { return s ? wxCRT_StrlenW(s) : 0; }
#ifndef wxWCHAR_T_IS_WXCHAR16
WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar16 *s );
#endif
#ifndef wxWCHAR_T_IS_WXCHAR32
WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar32 *s );
#endif
#define wxWcslen wxCRT_StrlenW
#define wxStrdupA wxCRT_StrdupA
#define wxStrdupW wxCRT_StrdupW
inline char* wxStrdup(const char *s) { return wxCRT_StrdupA(s); }
inline wchar_t* wxStrdup(const wchar_t *s) { return wxCRT_StrdupW(s); }
#ifndef wxWCHAR_T_IS_WXCHAR16
WXDLLIMPEXP_BASE wxChar16* wxStrdup(const wxChar16* s);
#endif
#ifndef wxWCHAR_T_IS_WXCHAR32
WXDLLIMPEXP_BASE wxChar32* wxStrdup(const wxChar32* s);
#endif
#endif /* __cplusplus */
#endif /* _WX_WXCRTBASE_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/imagtiff.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/imagtiff.h
// Purpose: wxImage TIFF handler
// Author: Robert Roebling
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGTIFF_H_
#define _WX_IMAGTIFF_H_
#include "wx/defs.h"
//-----------------------------------------------------------------------------
// wxTIFFHandler
//-----------------------------------------------------------------------------
#if wxUSE_LIBTIFF
#include "wx/image.h"
#include "wx/versioninfo.h"
// defines for wxImage::SetOption
#define wxIMAGE_OPTION_TIFF_BITSPERSAMPLE wxString(wxT("BitsPerSample"))
#define wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL wxString(wxT("SamplesPerPixel"))
#define wxIMAGE_OPTION_TIFF_COMPRESSION wxString(wxT("Compression"))
#define wxIMAGE_OPTION_TIFF_PHOTOMETRIC wxString(wxT("Photometric"))
#define wxIMAGE_OPTION_TIFF_IMAGEDESCRIPTOR wxString(wxT("ImageDescriptor"))
// for backwards compatibility
#define wxIMAGE_OPTION_BITSPERSAMPLE wxIMAGE_OPTION_TIFF_BITSPERSAMPLE
#define wxIMAGE_OPTION_SAMPLESPERPIXEL wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL
#define wxIMAGE_OPTION_COMPRESSION wxIMAGE_OPTION_TIFF_COMPRESSION
#define wxIMAGE_OPTION_IMAGEDESCRIPTOR wxIMAGE_OPTION_TIFF_IMAGEDESCRIPTOR
class WXDLLIMPEXP_CORE wxTIFFHandler: public wxImageHandler
{
public:
wxTIFFHandler();
static wxVersionInfo GetLibraryVersionInfo();
#if wxUSE_STREAMS
virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=true, int index=-1 ) wxOVERRIDE;
virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=true ) wxOVERRIDE;
protected:
virtual int DoGetImageCount( wxInputStream& stream ) wxOVERRIDE;
virtual bool DoCanRead( wxInputStream& stream ) wxOVERRIDE;
#endif
private:
wxDECLARE_DYNAMIC_CLASS(wxTIFFHandler);
};
#endif // wxUSE_LIBTIFF
#endif // _WX_IMAGTIFF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/nonownedwnd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/nonownedwnd.h
// Purpose: declares wxNonTopLevelWindow class
// Author: Vaclav Slavik
// Modified by:
// Created: 2006-12-24
// Copyright: (c) 2006 TT-Solutions
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_NONOWNEDWND_H_
#define _WX_NONOWNEDWND_H_
#include "wx/window.h"
// Styles that can be used with any wxNonOwnedWindow:
#define wxFRAME_SHAPED 0x0010 // Create a window that is able to be shaped
class WXDLLIMPEXP_FWD_CORE wxGraphicsPath;
// ----------------------------------------------------------------------------
// wxNonOwnedWindow: a window that is not a child window of another one.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNonOwnedWindowBase : public wxWindow
{
public:
// Set the shape of the window to the given region.
// Returns true if the platform supports this feature (and the
// operation is successful.)
bool SetShape(const wxRegion& region)
{
// This style is in fact only needed by wxOSX/Carbon so once we don't
// use this port any more, we could get rid of this requirement, but
// for now you must specify wxFRAME_SHAPED for SetShape() to work on
// all platforms.
wxCHECK_MSG
(
HasFlag(wxFRAME_SHAPED), false,
wxS("Shaped windows must be created with the wxFRAME_SHAPED style.")
);
return region.IsEmpty() ? DoClearShape() : DoSetRegionShape(region);
}
#if wxUSE_GRAPHICS_CONTEXT
// Set the shape using the specified path.
bool SetShape(const wxGraphicsPath& path)
{
wxCHECK_MSG
(
HasFlag(wxFRAME_SHAPED), false,
wxS("Shaped windows must be created with the wxFRAME_SHAPED style.")
);
return DoSetPathShape(path);
}
#endif // wxUSE_GRAPHICS_CONTEXT
// Overridden base class methods.
// ------------------------------
virtual void AdjustForParentClientOrigin(int& WXUNUSED(x), int& WXUNUSED(y),
int WXUNUSED(sizeFlags) = 0) const wxOVERRIDE
{
// Non owned windows positions don't need to be adjusted for parent
// client area origin so simply do nothing here.
}
virtual void InheritAttributes() wxOVERRIDE
{
// Non owned windows don't inherit attributes from their parent window
// (if the parent frame is red, it doesn't mean that all dialogs shown
// by it should be red as well), so don't do anything here neither.
}
protected:
virtual bool DoClearShape()
{
return false;
}
virtual bool DoSetRegionShape(const wxRegion& WXUNUSED(region))
{
return false;
}
#if wxUSE_GRAPHICS_CONTEXT
virtual bool DoSetPathShape(const wxGraphicsPath& WXUNUSED(path))
{
return false;
}
#endif // wxUSE_GRAPHICS_CONTEXT
};
#if defined(__WXDFB__)
#include "wx/dfb/nonownedwnd.h"
#elif defined(__WXGTK20__)
#include "wx/gtk/nonownedwnd.h"
#elif defined(__WXMAC__)
#include "wx/osx/nonownedwnd.h"
#elif defined(__WXMSW__)
#include "wx/msw/nonownedwnd.h"
#elif defined(__WXQT__)
#include "wx/qt/nonownedwnd.h"
#else
// No special class needed in other ports, they can derive both wxTLW and
// wxPopupWindow directly from wxWindow and don't implement SetShape().
class wxNonOwnedWindow : public wxNonOwnedWindowBase
{
};
#endif
#endif // _WX_NONOWNEDWND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/activityindicator.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/activityindicator.h
// Purpose: wxActivityIndicator declaration.
// Author: Vadim Zeitlin
// Created: 2015-03-05
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ACTIVITYINDICATOR_H_
#define _WX_ACTIVITYINDICATOR_H_
#include "wx/defs.h"
#if wxUSE_ACTIVITYINDICATOR
#include "wx/control.h"
#define wxActivityIndicatorNameStr wxS("activityindicator")
// ----------------------------------------------------------------------------
// wxActivityIndicator: small animated indicator of some application activity.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxActivityIndicatorBase : public wxControl
{
public:
// Start or stop the activity animation (it is stopped initially).
virtual void Start() = 0;
virtual void Stop() = 0;
// Return true if the control is currently showing activity.
virtual bool IsRunning() const = 0;
// Override some base class virtual methods.
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
protected:
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
};
#ifndef __WXUNIVERSAL__
#if defined(__WXGTK220__)
#define wxHAS_NATIVE_ACTIVITYINDICATOR
#include "wx/gtk/activityindicator.h"
#elif defined(__WXOSX_COCOA__)
#define wxHAS_NATIVE_ACTIVITYINDICATOR
#include "wx/osx/activityindicator.h"
#endif
#endif // !__WXUNIVERSAL__
#ifndef wxHAS_NATIVE_ACTIVITYINDICATOR
#include "wx/generic/activityindicator.h"
#endif
#endif // wxUSE_ACTIVITYINDICATOR
#endif // _WX_ACTIVITYINDICATOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/app.h
// Purpose: wxAppBase class and macros used for declaration of wxApp
// derived class in the user code
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_APP_H_BASE_
#define _WX_APP_H_BASE_
// ----------------------------------------------------------------------------
// headers we have to include here
// ----------------------------------------------------------------------------
#include "wx/event.h" // for the base class
#include "wx/eventfilter.h" // (and another one)
#include "wx/build.h"
#include "wx/cmdargs.h" // for wxCmdLineArgsArray used by wxApp::argv
#include "wx/init.h" // we must declare wxEntry()
#include "wx/intl.h" // for wxLayoutDirection
#include "wx/log.h" // for wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD()
class WXDLLIMPEXP_FWD_BASE wxAppConsole;
class WXDLLIMPEXP_FWD_BASE wxAppTraits;
class WXDLLIMPEXP_FWD_BASE wxCmdLineParser;
class WXDLLIMPEXP_FWD_BASE wxEventLoopBase;
class WXDLLIMPEXP_FWD_BASE wxMessageOutput;
#if wxUSE_GUI
struct WXDLLIMPEXP_FWD_CORE wxVideoMode;
class WXDLLIMPEXP_FWD_CORE wxWindow;
#endif
// this macro should be used in any main() or equivalent functions defined in wx
#define wxDISABLE_DEBUG_SUPPORT() \
wxDISABLE_ASSERTS_IN_RELEASE_BUILD(); \
wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD()
// ----------------------------------------------------------------------------
// typedefs
// ----------------------------------------------------------------------------
// the type of the function used to create a wxApp object on program start up
typedef wxAppConsole* (*wxAppInitializerFunction)();
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
enum
{
wxPRINT_WINDOWS = 1,
wxPRINT_POSTSCRIPT = 2
};
// ----------------------------------------------------------------------------
// global variables
// ----------------------------------------------------------------------------
// use of this list is strongly deprecated, use wxApp ScheduleForDestruction()
// and IsScheduledForDestruction() methods instead of this list directly, it
// is here for compatibility purposes only
extern WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
// ----------------------------------------------------------------------------
// wxAppConsoleBase: wxApp for non-GUI applications
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxAppConsoleBase : public wxEvtHandler,
public wxEventFilter
{
public:
// ctor and dtor
wxAppConsoleBase();
virtual ~wxAppConsoleBase();
// the virtual functions which may/must be overridden in the derived class
// -----------------------------------------------------------------------
// This is the very first function called for a newly created wxApp object,
// it is used by the library to do the global initialization. If, for some
// reason, you must override it (instead of just overriding OnInit(), as
// usual, for app-specific initializations), do not forget to call the base
// class version!
virtual bool Initialize(int& argc, wxChar **argv);
// This gives wxCocoa a chance to call OnInit() with a memory pool in place
virtual bool CallOnInit() { return OnInit(); }
// Called before OnRun(), this is a good place to do initialization -- if
// anything fails, return false from here to prevent the program from
// continuing. The command line is normally parsed here, call the base
// class OnInit() to do it.
virtual bool OnInit();
// This is the replacement for the normal main(): all program work should
// be done here. When OnRun() returns, the programs starts shutting down.
virtual int OnRun();
// Called before the first events are handled, called from within MainLoop()
virtual void OnLaunched();
// This is called by wxEventLoopBase::SetActive(): you should put the code
// which needs an active event loop here.
// Note that this function is called whenever an event loop is activated;
// you may want to use wxEventLoopBase::IsMain() to perform initialization
// specific for the app's main event loop.
virtual void OnEventLoopEnter(wxEventLoopBase* WXUNUSED(loop)) {}
// This is only called if OnInit() returned true so it's a good place to do
// any cleanup matching the initializations done there.
virtual int OnExit();
// This is called by wxEventLoopBase::OnExit() for each event loop which
// is exited.
virtual void OnEventLoopExit(wxEventLoopBase* WXUNUSED(loop)) {}
// This is the very last function called on wxApp object before it is
// destroyed. If you override it (instead of overriding OnExit() as usual)
// do not forget to call the base class version!
virtual void CleanUp();
// Called when a fatal exception occurs, this function should take care not
// to do anything which might provoke a nested exception! It may be
// overridden if you wish to react somehow in non-default way (core dump
// under Unix, application crash under Windows) to fatal program errors,
// however extreme care should be taken if you don't want this function to
// crash.
virtual void OnFatalException() { }
// Called from wxExit() function, should terminate the application a.s.a.p.
virtual void Exit();
// application info: name, description, vendor
// -------------------------------------------
// NB: all these should be set by the application itself, there are no
// reasonable default except for the application name which is taken to
// be argv[0]
// set/get the application name
wxString GetAppName() const;
void SetAppName(const wxString& name) { m_appName = name; }
// set/get the application display name: the display name is the name
// shown to the user in titles, reports, etc while the app name is
// used for paths, config, and other places the user doesn't see
//
// by default the display name is the same as app name or a capitalized
// version of the program if app name was not set neither but it's
// usually better to set it explicitly to something nicer
wxString GetAppDisplayName() const;
void SetAppDisplayName(const wxString& name) { m_appDisplayName = name; }
// set/get the app class name
wxString GetClassName() const { return m_className; }
void SetClassName(const wxString& name) { m_className = name; }
// set/get the vendor name
const wxString& GetVendorName() const { return m_vendorName; }
void SetVendorName(const wxString& name) { m_vendorName = name; }
// set/get the vendor display name: the display name is shown
// in titles/reports/dialogs to the user, while the vendor name
// is used in some areas such as wxConfig, wxStandardPaths, etc
const wxString& GetVendorDisplayName() const
{
return m_vendorDisplayName.empty() ? GetVendorName()
: m_vendorDisplayName;
}
void SetVendorDisplayName(const wxString& name)
{
m_vendorDisplayName = name;
}
// cmd line parsing stuff
// ----------------------
// all of these methods may be overridden in the derived class to
// customize the command line parsing (by default only a few standard
// options are handled)
//
// you also need to call wxApp::OnInit() from YourApp::OnInit() for all
// this to work
#if wxUSE_CMDLINE_PARSER
// this one is called from OnInit() to add all supported options
// to the given parser (don't forget to call the base class version if you
// override it!)
virtual void OnInitCmdLine(wxCmdLineParser& parser);
// called after successfully parsing the command line, return true
// to continue and false to exit (don't forget to call the base class
// version if you override it!)
virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
// called if "--help" option was specified, return true to continue
// and false to exit
virtual bool OnCmdLineHelp(wxCmdLineParser& parser);
// called if incorrect command line options were given, return
// false to abort and true to continue
virtual bool OnCmdLineError(wxCmdLineParser& parser);
#endif // wxUSE_CMDLINE_PARSER
// miscellaneous customization functions
// -------------------------------------
// create the app traits object to which we delegate for everything which
// either should be configurable by the user (then he can change the
// default behaviour simply by overriding CreateTraits() and returning his
// own traits object) or which is GUI/console dependent as then wxAppTraits
// allows us to abstract the differences behind the common facade
wxAppTraits *GetTraits();
// this function provides safer access to traits object than
// wxTheApp->GetTraits() during startup or termination when the global
// application object itself may be unavailable
//
// of course, it still returns NULL in this case and the caller must check
// for it
static wxAppTraits *GetTraitsIfExists();
// Return some valid traits object.
//
// This method checks if we have wxTheApp and returns its traits if it does
// exist and the traits are non-NULL, similarly to GetTraitsIfExists(), but
// falls back to wxConsoleAppTraits to ensure that it always returns
// something valid.
static wxAppTraits& GetValidTraits();
// returns the main event loop instance, i.e. the event loop which is started
// by OnRun() and which dispatches all events sent from the native toolkit
// to the application (except when new event loops are temporarily set-up).
// The returned value maybe NULL. Put initialization code which needs a
// non-NULL main event loop into OnEventLoopEnter().
wxEventLoopBase* GetMainLoop() const
{ return m_mainLoop; }
// This function sets the C locale to the default locale for the current
// environment. It is advised to call this to ensure that the underlying
// toolkit uses the locale in which the numbers and monetary amounts are
// shown in the format expected by user and so on.
//
// Notice that this does _not_ change the global C++ locale, you need to do
// it explicitly if you want.
//
// Finally, notice that while this function is virtual, it is not supposed
// to be overridden outside of the library itself.
virtual void SetCLocale();
// event processing functions
// --------------------------
// Implement the inherited wxEventFilter method but just return -1 from it
// to indicate that default processing should take place.
virtual int FilterEvent(wxEvent& event) wxOVERRIDE;
// return true if we're running event loop, i.e. if the events can
// (already) be dispatched
static bool IsMainLoopRunning();
#if wxUSE_EXCEPTIONS
// execute the functor to handle the given event
//
// this is a generalization of HandleEvent() below and the base class
// implementation of CallEventHandler() still calls HandleEvent() for
// compatibility for functors which are just wxEventFunctions (i.e. methods
// of wxEvtHandler)
virtual void CallEventHandler(wxEvtHandler *handler,
wxEventFunctor& functor,
wxEvent& event) const;
// call the specified handler on the given object with the given event
//
// this method only exists to allow catching the exceptions thrown by any
// event handler, it would lead to an extra (useless) virtual function call
// if the exceptions were not used, so it doesn't even exist in that case
virtual void HandleEvent(wxEvtHandler *handler,
wxEventFunction func,
wxEvent& event) const;
// Called when an unhandled C++ exception occurs inside OnRun(): note that
// the main event loop has already terminated by now and the program will
// exit, if you need to really handle the exceptions you need to override
// OnExceptionInMainLoop()
virtual void OnUnhandledException();
// Function called if an uncaught exception is caught inside the main
// event loop: it may return true to continue running the event loop or
// false to stop it. If this function rethrows the exception, as it does by
// default, simply because there is no general way to handle exceptions,
// StoreCurrentException() will be called to store it because in any case
// the exception can't be allowed to escape.
virtual bool OnExceptionInMainLoop();
// This function can be overridden to store the current exception, in view
// of rethrowing it later when RethrowStoredException() is called. If the
// exception was stored, return true. If the exception can't be stored,
// i.e. if this function returns false, the program will abort after
// calling OnUnhandledException().
//
// The default implementation of this function when using C++98 compiler
// just returns false, as there is no generic way to store an arbitrary
// exception in C++98 and each application must do it on its own for the
// exceptions it uses in its overridden version. When using C++11, the
// default implementation uses std::current_exception() and returns true,
// so it's normally not necessary to override this method when using C++11.
virtual bool StoreCurrentException();
// If StoreCurrentException() is overridden, this function should be
// overridden as well to rethrow the exceptions stored by it when the
// control gets back to our code, i.e. when it's safe to do it.
//
// The default version does nothing when using C++98 and uses
// std::rethrow_exception() in C++11.
virtual void RethrowStoredException();
#endif // wxUSE_EXCEPTIONS
// pending events
// --------------
// IMPORTANT: all these methods conceptually belong to wxEventLoopBase
// but for many reasons we need to allow queuing of events
// even when there's no event loop (e.g. in wxApp::OnInit);
// this feature is used e.g. to queue events on secondary threads
// or in wxPython to use wx.CallAfter before the GUI is initialized
// process all events in the m_handlersWithPendingEvents list -- it is necessary
// to call this function to process posted events. This happens during each
// event loop iteration in GUI mode but if there is no main loop, it may be
// also called directly.
virtual void ProcessPendingEvents();
// check if there are pending events on global pending event list
bool HasPendingEvents() const;
// temporary suspends processing of the pending events
void SuspendProcessingOfPendingEvents();
// resume processing of the pending events previously stopped because of a
// call to SuspendProcessingOfPendingEvents()
void ResumeProcessingOfPendingEvents();
// called by ~wxEvtHandler to (eventually) remove the handler from the list of
// the handlers with pending events
void RemovePendingEventHandler(wxEvtHandler* toRemove);
// adds an event handler to the list of the handlers with pending events
void AppendPendingEventHandler(wxEvtHandler* toAppend);
// moves the event handler from the list of the handlers with pending events
//to the list of the handlers with _delayed_ pending events
void DelayPendingEventHandler(wxEvtHandler* toDelay);
// deletes the current pending events
void DeletePendingEvents();
// delayed destruction
// -------------------
// If an object may have pending events for it, it shouldn't be deleted
// immediately as this would result in a crash when trying to handle these
// events: instead, it should be scheduled for destruction and really
// destroyed only after processing all pending events.
//
// Notice that this is only possible if we have a running event loop,
// otherwise the object is just deleted directly by ScheduleForDestruction()
// and IsScheduledForDestruction() always returns false.
// schedule the object for destruction in the near future
void ScheduleForDestruction(wxObject *object);
// return true if the object is scheduled for destruction
bool IsScheduledForDestruction(wxObject *object) const;
// wxEventLoop-related methods
// ---------------------------
// all these functions are forwarded to the corresponding methods of the
// currently active event loop -- and do nothing if there is none
virtual bool Pending();
virtual bool Dispatch();
virtual int MainLoop();
virtual void ExitMainLoop();
bool Yield(bool onlyIfNeeded = false);
virtual void WakeUpIdle();
// this method is called by the active event loop when there are no events
// to process
//
// by default it generates the idle events and if you override it in your
// derived class you should call the base class version to ensure that idle
// events are still sent out
virtual bool ProcessIdle();
// this virtual function is overridden in GUI wxApp to always return true
// as GUI applications always have an event loop -- but console ones may
// have it or not, so it simply returns true if already have an event loop
// running but false otherwise
virtual bool UsesEventLoop() const;
// debugging support
// -----------------
// this function is called when an assert failure occurs, the base class
// version does the normal processing (i.e. shows the usual assert failure
// dialog box)
//
// the arguments are the location of the failed assert (func may be empty
// if the compiler doesn't support C99 __FUNCTION__), the text of the
// assert itself and the user-specified message
virtual void OnAssertFailure(const wxChar *file,
int line,
const wxChar *func,
const wxChar *cond,
const wxChar *msg);
// old version of the function without func parameter, for compatibility
// only, override OnAssertFailure() in the new code
virtual void OnAssert(const wxChar *file,
int line,
const wxChar *cond,
const wxChar *msg);
// check that the wxBuildOptions object (constructed in the application
// itself, usually the one from wxIMPLEMENT_APP() macro) matches the build
// options of the library and abort if it doesn't
static bool CheckBuildOptions(const char *optionsSignature,
const char *componentName);
// implementation only from now on
// -------------------------------
// helpers for dynamic wxApp construction
static void SetInitializerFunction(wxAppInitializerFunction fn)
{ ms_appInitFn = fn; }
static wxAppInitializerFunction GetInitializerFunction()
{ return ms_appInitFn; }
// accessors for ms_appInstance field (external code might wish to modify
// it, this is why we provide a setter here as well, but you should really
// know what you're doing if you call it), wxTheApp is usually used instead
// of GetInstance()
static wxAppConsole *GetInstance() { return ms_appInstance; }
static void SetInstance(wxAppConsole *app) { ms_appInstance = app; }
// command line arguments (public for backwards compatibility)
int argc;
// this object is implicitly convertible to either "char**" (traditional
// type of argv parameter of main()) or to "wchar_t **" (for compatibility
// with Unicode build in previous wx versions and because the command line
// can, in pr
#if wxUSE_UNICODE
wxCmdLineArgsArray argv;
#else
char **argv;
#endif
protected:
// delete all objects in wxPendingDelete list
//
// called from ProcessPendingEvents()
void DeletePendingObjects();
// the function which creates the traits object when GetTraits() needs it
// for the first time
virtual wxAppTraits *CreateTraits();
// function used for dynamic wxApp creation
static wxAppInitializerFunction ms_appInitFn;
// the one and only global application object
static wxAppConsole *ms_appInstance;
// create main loop from AppTraits or return NULL if
// there is no main loop implementation
wxEventLoopBase *CreateMainLoop();
// application info (must be set from the user code)
wxString m_vendorName, // vendor name ("acme")
m_vendorDisplayName, // vendor display name (e.g. "ACME Inc")
m_appName, // app name ("myapp")
m_appDisplayName, // app display name ("My Application")
m_className; // class name
// the class defining the application behaviour, NULL initially and created
// by GetTraits() when first needed
wxAppTraits *m_traits;
// the main event loop of the application (may be NULL if the loop hasn't
// been started yet or has already terminated)
wxEventLoopBase *m_mainLoop;
// pending events management vars:
// the array of the handlers with pending events which needs to be processed
// inside ProcessPendingEvents()
wxEvtHandlerArray m_handlersWithPendingEvents;
// helper array used by ProcessPendingEvents() to store the event handlers
// which have pending events but of these events none can be processed right now
// (because of a call to wxEventLoop::YieldFor() which asked to selectively process
// pending events)
wxEvtHandlerArray m_handlersWithPendingDelayedEvents;
#if wxUSE_THREADS
// this critical section protects both the lists above
wxCriticalSection m_handlersWithPendingEventsLocker;
#endif
// flag modified by Suspend/ResumeProcessingOfPendingEvents()
bool m_bDoPendingEventProcessing;
friend class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
// the application object is a singleton anyhow, there is no sense in
// copying it
wxDECLARE_NO_COPY_CLASS(wxAppConsoleBase);
};
#if defined(__UNIX__) && !defined(__WINDOWS__)
#include "wx/unix/app.h"
#else
// this has to be a class and not a typedef as we forward declare it
class wxAppConsole : public wxAppConsoleBase { };
#endif
// ----------------------------------------------------------------------------
// wxAppBase: the common part of wxApp implementations for all platforms
// ----------------------------------------------------------------------------
#if wxUSE_GUI
class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
{
public:
wxAppBase();
virtual ~wxAppBase();
// the virtual functions which may/must be overridden in the derived class
// -----------------------------------------------------------------------
// very first initialization function
//
// Override: very rarely
virtual bool Initialize(int& argc, wxChar **argv) wxOVERRIDE;
// a platform-dependent version of OnInit(): the code here is likely to
// depend on the toolkit. default version does nothing.
//
// Override: rarely.
virtual bool OnInitGui();
// called to start program execution - the default version just enters
// the main GUI loop in which events are received and processed until
// the last window is not deleted (if GetExitOnFrameDelete) or
// ExitMainLoop() is called. In console mode programs, the execution
// of the program really starts here
//
// Override: rarely in GUI applications, always in console ones.
virtual int OnRun() wxOVERRIDE;
// a matching function for OnInit()
virtual int OnExit() wxOVERRIDE;
// very last clean up function
//
// Override: very rarely
virtual void CleanUp() wxOVERRIDE;
// the worker functions - usually not used directly by the user code
// -----------------------------------------------------------------
// safer alternatives to Yield(), using wxWindowDisabler
virtual bool SafeYield(wxWindow *win, bool onlyIfNeeded);
virtual bool SafeYieldFor(wxWindow *win, long eventsToProcess);
// this virtual function is called in the GUI mode when the application
// becomes idle and normally just sends wxIdleEvent to all interested
// parties
//
// it should return true if more idle events are needed, false if not
virtual bool ProcessIdle() wxOVERRIDE;
// override base class version: GUI apps always use an event loop
virtual bool UsesEventLoop() const wxOVERRIDE { return true; }
// top level window functions
// --------------------------
// return true if our app has focus
virtual bool IsActive() const { return m_isActive; }
// set the "main" top level window
void SetTopWindow(wxWindow *win) { m_topWindow = win; }
// return the "main" top level window (if it hadn't been set previously
// with SetTopWindow(), will return just some top level window and, if
// there are none, will return NULL)
virtual wxWindow *GetTopWindow() const;
// control the exit behaviour: by default, the program will exit the
// main loop (and so, usually, terminate) when the last top-level
// program window is deleted. Beware that if you disable this behaviour
// (with SetExitOnFrameDelete(false)), you'll have to call
// ExitMainLoop() explicitly from somewhere.
void SetExitOnFrameDelete(bool flag)
{ m_exitOnFrameDelete = flag ? Yes : No; }
bool GetExitOnFrameDelete() const
{ return m_exitOnFrameDelete == Yes; }
// display mode, visual, printing mode, ...
// ------------------------------------------------------------------------
// Get display mode that is used use. This is only used in framebuffer
// wxWin ports such as wxDFB.
virtual wxVideoMode GetDisplayMode() const;
// Set display mode to use. This is only used in framebuffer wxWin
// ports such as wxDFB. This method should be called from
// wxApp::OnInitGui
virtual bool SetDisplayMode(const wxVideoMode& WXUNUSED(info)) { return true; }
// set use of best visual flag (see below)
void SetUseBestVisual( bool flag, bool forceTrueColour = false )
{ m_useBestVisual = flag; m_forceTrueColour = forceTrueColour; }
bool GetUseBestVisual() const { return m_useBestVisual; }
// set/get printing mode: see wxPRINT_XXX constants.
//
// default behaviour is the normal one for Unix: always use PostScript
// printing.
virtual void SetPrintMode(int WXUNUSED(mode)) { }
int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
// Return the layout direction for the current locale or wxLayout_Default
// if it's unknown
virtual wxLayoutDirection GetLayoutDirection() const;
// Change the theme used by the application, return true on success.
virtual bool SetNativeTheme(const wxString& WXUNUSED(theme)) { return false; }
// command line parsing (GUI-specific)
// ------------------------------------------------------------------------
#if wxUSE_CMDLINE_PARSER
virtual bool OnCmdLineParsed(wxCmdLineParser& parser) wxOVERRIDE;
virtual void OnInitCmdLine(wxCmdLineParser& parser) wxOVERRIDE;
#endif
// miscellaneous other stuff
// ------------------------------------------------------------------------
// called by toolkit-specific code to set the app status: active (we have
// focus) or not and also the last window which had focus before we were
// deactivated
virtual void SetActive(bool isActive, wxWindow *lastFocus);
protected:
// override base class method to use GUI traits
virtual wxAppTraits *CreateTraits() wxOVERRIDE;
// Helper method deleting all existing top level windows: this is used
// during the application shutdown.
void DeleteAllTLWs();
// the main top level window (may be NULL)
wxWindow *m_topWindow;
// if Yes, exit the main loop when the last top level window is deleted, if
// No don't do it and if Later -- only do it once we reach our OnRun()
//
// the explanation for using this strange scheme is given in appcmn.cpp
enum
{
Later = -1,
No,
Yes
} m_exitOnFrameDelete;
// true if the app wants to use the best visual on systems where
// more than one are available (Sun, SGI, XFree86 4.0 ?)
bool m_useBestVisual;
// force TrueColour just in case "best" isn't TrueColour
bool m_forceTrueColour;
// does any of our windows have focus?
bool m_isActive;
wxDECLARE_NO_COPY_CLASS(wxAppBase);
};
// ----------------------------------------------------------------------------
// now include the declaration of the real class
// ----------------------------------------------------------------------------
#if defined(__WXMSW__)
#include "wx/msw/app.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/app.h"
#elif defined(__WXDFB__)
#include "wx/dfb/app.h"
#elif defined(__WXGTK20__)
#include "wx/gtk/app.h"
#elif defined(__WXGTK__)
#include "wx/gtk1/app.h"
#elif defined(__WXX11__)
#include "wx/x11/app.h"
#elif defined(__WXMAC__)
#include "wx/osx/app.h"
#elif defined(__WXQT__)
#include "wx/qt/app.h"
#endif
#else // !GUI
// wxApp is defined in core and we cannot define another one in wxBase,
// so use the preprocessor to allow using wxApp in console programs too
#define wxApp wxAppConsole
#endif // GUI/!GUI
// ----------------------------------------------------------------------------
// the global data
// ----------------------------------------------------------------------------
// for compatibility, we define this macro to access the global application
// object of type wxApp
//
// note that instead of using of wxTheApp in application code you should
// consider using wxDECLARE_APP() after which you may call wxGetApp() which will
// return the object of the correct type (i.e. MyApp and not wxApp)
//
// the cast is safe as in GUI build we only use wxApp, not wxAppConsole, and in
// console mode it does nothing at all
#define wxTheApp static_cast<wxApp*>(wxApp::GetInstance())
// ----------------------------------------------------------------------------
// global functions
// ----------------------------------------------------------------------------
// event loop related functions only work in GUI programs
// ------------------------------------------------------
// Force an exit from main loop
WXDLLIMPEXP_BASE void wxExit();
// avoid redeclaring this function here if it had been already declared by
// wx/utils.h, this results in warnings from g++ with -Wredundant-decls
#ifndef wx_YIELD_DECLARED
#define wx_YIELD_DECLARED
// Yield to other apps/messages
WXDLLIMPEXP_CORE bool wxYield();
#endif // wx_YIELD_DECLARED
// Yield to other apps/messages
WXDLLIMPEXP_BASE void wxWakeUpIdle();
// ----------------------------------------------------------------------------
// macros for dynamic creation of the application object
// ----------------------------------------------------------------------------
// Having a global instance of this class allows wxApp to be aware of the app
// creator function. wxApp can then call this function to create a new app
// object. Convoluted, but necessary.
class WXDLLIMPEXP_BASE wxAppInitializer
{
public:
wxAppInitializer(wxAppInitializerFunction fn)
{ wxApp::SetInitializerFunction(fn); }
};
// the code below defines a wxIMPLEMENT_WXWIN_MAIN macro which you can use if
// your compiler really, really wants main() to be in your main program (e.g.
// hello.cpp). Now wxIMPLEMENT_APP should add this code if required.
// For compilers that support it, prefer to use wmain() and let the CRT parse
// the command line for us, for the others parse it ourselves under Windows to
// ensure that wxWidgets console applications accept arbitrary Unicode strings
// as command line parameters and not just those representable in the current
// locale (under Unix UTF-8, capable of representing any Unicode string, is
// almost always used and there is no way to retrieve the Unicode command line
// anyhow).
#if wxUSE_UNICODE && defined(__WINDOWS__)
#ifdef __VISUALC__
#define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
int wmain(int argc, wchar_t **argv) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
\
return wxEntry(argc, argv); \
}
#else // No wmain(), use main() but don't trust its arguments.
#define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
int main(int, char **) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
\
return wxEntry(); \
}
#endif
#else // Use standard main()
#define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
int main(int argc, char **argv) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
\
return wxEntry(argc, argv); \
}
#endif
// port-specific header could have defined it already in some special way
#ifndef wxIMPLEMENT_WXWIN_MAIN
#define wxIMPLEMENT_WXWIN_MAIN wxIMPLEMENT_WXWIN_MAIN_CONSOLE
#endif // defined(wxIMPLEMENT_WXWIN_MAIN)
#ifdef __WXUNIVERSAL__
#include "wx/univ/theme.h"
#ifdef wxUNIV_DEFAULT_THEME
#define wxIMPLEMENT_WX_THEME_SUPPORT \
WX_USE_THEME(wxUNIV_DEFAULT_THEME);
#else
#define wxIMPLEMENT_WX_THEME_SUPPORT
#endif
#else
#define wxIMPLEMENT_WX_THEME_SUPPORT
#endif
// Use this macro if you want to define your own main() or WinMain() function
// and call wxEntry() from there.
#define wxIMPLEMENT_APP_NO_MAIN(appname) \
appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); } \
wxAppConsole *wxCreateApp() \
{ \
wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
"your program"); \
return new appname; \
} \
wxAppInitializer \
wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp)
// Same as wxIMPLEMENT_APP() normally but doesn't include themes support in
// wxUniversal builds
#define wxIMPLEMENT_APP_NO_THEMES(appname) \
wxIMPLEMENT_WXWIN_MAIN \
wxIMPLEMENT_APP_NO_MAIN(appname)
// Use this macro exactly once, the argument is the name of the wxApp-derived
// class which is the class of your application.
#define wxIMPLEMENT_APP(appname) \
wxIMPLEMENT_WX_THEME_SUPPORT \
wxIMPLEMENT_APP_NO_THEMES(appname)
// Same as wxIMPLEMENT_APP(), but for console applications.
#define wxIMPLEMENT_APP_CONSOLE(appname) \
wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
wxIMPLEMENT_APP_NO_MAIN(appname)
// this macro can be used multiple times and just allows you to use wxGetApp()
// function
#define wxDECLARE_APP(appname) \
extern appname& wxGetApp()
// declare the stuff defined by wxIMPLEMENT_APP() macro, it's not really needed
// anywhere else but at the very least it suppresses icc warnings about
// defining extern symbols without prior declaration, and it shouldn't do any
// harm
extern wxAppConsole *wxCreateApp();
extern wxAppInitializer wxTheAppInitializer;
// ----------------------------------------------------------------------------
// Compatibility macro aliases
// ----------------------------------------------------------------------------
// deprecated variants _not_ requiring a semicolon after them
// (note that also some wx-prefixed macro do _not_ require a semicolon because
// it's not always possible to force the compiler to require it)
#define IMPLEMENT_WXWIN_MAIN_CONSOLE wxIMPLEMENT_WXWIN_MAIN_CONSOLE
#define IMPLEMENT_WXWIN_MAIN wxIMPLEMENT_WXWIN_MAIN
#define IMPLEMENT_WX_THEME_SUPPORT wxIMPLEMENT_WX_THEME_SUPPORT
#define IMPLEMENT_APP_NO_MAIN(app) wxIMPLEMENT_APP_NO_MAIN(app);
#define IMPLEMENT_APP_NO_THEMES(app) wxIMPLEMENT_APP_NO_THEMES(app);
#define IMPLEMENT_APP(app) wxIMPLEMENT_APP(app);
#define IMPLEMENT_APP_CONSOLE(app) wxIMPLEMENT_APP_CONSOLE(app);
#define DECLARE_APP(app) wxDECLARE_APP(app);
#endif // _WX_APP_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/base64.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/base64.h
// Purpose: declaration of BASE64 encoding/decoding functionality
// Author: Charles Reimers, Vadim Zeitlin
// Created: 2007-06-18
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BASE64_H_
#define _WX_BASE64_H_
#include "wx/defs.h"
#if wxUSE_BASE64
#include "wx/string.h"
#include "wx/buffer.h"
// ----------------------------------------------------------------------------
// encoding functions
// ----------------------------------------------------------------------------
// return the size needed for the buffer containing the encoded representation
// of a buffer of given length
inline size_t wxBase64EncodedSize(size_t len) { return 4*((len+2)/3); }
// raw base64 encoding function which encodes the contents of a buffer of the
// specified length into the buffer of the specified size
//
// returns the length of the encoded data or wxCONV_FAILED if the buffer is not
// large enough; to determine the needed size you can either allocate a buffer
// of wxBase64EncodedSize(srcLen) size or call the function with NULL buffer in
// which case the required size will be returned
WXDLLIMPEXP_BASE size_t
wxBase64Encode(char *dst, size_t dstLen, const void *src, size_t srcLen);
// encode the contents of the given buffer using base64 and return as string
// (there is no error return)
inline wxString wxBase64Encode(const void *src, size_t srcLen)
{
const size_t dstLen = wxBase64EncodedSize(srcLen);
wxCharBuffer dst(dstLen);
wxBase64Encode(dst.data(), dstLen, src, srcLen);
return dst;
}
inline wxString wxBase64Encode(const wxMemoryBuffer& buf)
{
return wxBase64Encode(buf.GetData(), buf.GetDataLen());
}
// ----------------------------------------------------------------------------
// decoding functions
// ----------------------------------------------------------------------------
// elements of this enum specify the possible behaviours of wxBase64Decode()
// when an invalid character is encountered
enum wxBase64DecodeMode
{
// normal behaviour: stop at any invalid characters
wxBase64DecodeMode_Strict,
// skip whitespace characters
wxBase64DecodeMode_SkipWS,
// the most lenient behaviour: simply ignore all invalid characters
wxBase64DecodeMode_Relaxed
};
// return the buffer size necessary for decoding a base64 string of the given
// length
inline size_t wxBase64DecodedSize(size_t srcLen) { return 3*srcLen/4; }
// raw decoding function which decodes the contents of the string of specified
// length (or NUL-terminated by default) into the provided buffer of the given
// size
//
// the function normally stops at any character invalid inside a base64-encoded
// string (i.e. not alphanumeric nor '+' nor '/') but can be made to skip the
// whitespace or all invalid characters using its mode argument
//
// returns the length of the decoded data or wxCONV_FAILED if an error occurs
// such as the buffer is too small or the encoded string is invalid; in the
// latter case the posErr is filled with the position where the decoding
// stopped if it is not NULL
WXDLLIMPEXP_BASE size_t
wxBase64Decode(void *dst, size_t dstLen,
const char *src, size_t srcLen = wxNO_LEN,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,
size_t *posErr = NULL);
inline size_t
wxBase64Decode(void *dst, size_t dstLen,
const wxString& src,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,
size_t *posErr = NULL)
{
// don't use str.length() here as the ASCII buffer is shorter than it for
// strings with embedded NULs
return wxBase64Decode(dst, dstLen, src.ToAscii(), wxNO_LEN, mode, posErr);
}
// decode the contents of the given string; the returned buffer is empty if an
// error occurs during decoding
WXDLLIMPEXP_BASE wxMemoryBuffer
wxBase64Decode(const char *src, size_t srcLen = wxNO_LEN,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,
size_t *posErr = NULL);
inline wxMemoryBuffer
wxBase64Decode(const wxString& src,
wxBase64DecodeMode mode = wxBase64DecodeMode_Strict,
size_t *posErr = NULL)
{
// don't use str.length() here as the ASCII buffer is shorter than it for
// strings with embedded NULs
return wxBase64Decode(src.ToAscii(), wxNO_LEN, mode, posErr);
}
#endif // wxUSE_BASE64
#endif // _WX_BASE64_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/combo.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/combo.h
// Purpose: wxComboCtrl declaration
// Author: Jaakko Salli
// Modified by:
// Created: Apr-30-2006
// Copyright: (c) Jaakko Salli
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COMBOCONTROL_H_BASE_
#define _WX_COMBOCONTROL_H_BASE_
/*
A few words about all the classes defined in this file are probably in
order: why do we need extra wxComboCtrl and wxComboPopup classes?
This is because a traditional combobox is a combination of a text control
(with a button allowing to open the pop down list) with a listbox and
wxComboBox class is exactly such control, however we want to also have other
combinations - in fact, we want to allow anything at all to be used as pop
down list, not just a wxListBox.
So we define a base wxComboCtrl which can use any control as pop down
list and wxComboBox deriving from it which implements the standard wxWidgets
combobox API. wxComboCtrl needs to be told somehow which control to use
and this is done by SetPopupControl(). However, we need something more than
just a wxControl in this method as, for example, we need to call
SetSelection("initial text value") and wxControl doesn't have such method.
So we also need a wxComboPopup which is just a very simple interface which
must be implemented by a control to be usable as a popup.
We couldn't derive wxComboPopup from wxControl as this would make it
impossible to have a class deriving from both wxListBx and from it, so
instead it is just a mix-in.
*/
#include "wx/defs.h"
#if wxUSE_COMBOCTRL
#include "wx/control.h"
#include "wx/renderer.h" // this is needed for wxCONTROL_XXX flags
#include "wx/bitmap.h" // wxBitmap used by-value
#include "wx/textentry.h"
#include "wx/time.h" // needed for wxMilliClock_t
class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
class WXDLLIMPEXP_FWD_CORE wxComboPopup;
//
// New window styles for wxComboCtrlBase
//
enum
{
// Double-clicking a read-only combo triggers call to popup's OnComboPopup.
// In wxOwnerDrawnComboBox, for instance, it cycles item.
wxCC_SPECIAL_DCLICK = 0x0100,
// Dropbutton acts like standard push button.
wxCC_STD_BUTTON = 0x0200
};
// wxComboCtrl internal flags
enum
{
// First those that can be passed to Customize.
// It is Windows style for all flags to be clear.
// Button is preferred outside the border (GTK style)
wxCC_BUTTON_OUTSIDE_BORDER = 0x0001,
// Show popup on mouse up instead of mouse down (which is the Windows style)
wxCC_POPUP_ON_MOUSE_UP = 0x0002,
// All text is not automatically selected on click
wxCC_NO_TEXT_AUTO_SELECT = 0x0004,
// Drop-button stays down as long as popup is displayed.
wxCC_BUTTON_STAYS_DOWN = 0x0008,
// Drop-button covers the entire control.
wxCC_FULL_BUTTON = 0x0010,
// Drop-button goes over the custom-border (used under WinVista).
wxCC_BUTTON_COVERS_BORDER = 0x0020,
// Internal use: signals creation is complete
wxCC_IFLAG_CREATED = 0x0100,
// Internal use: really put button outside
wxCC_IFLAG_BUTTON_OUTSIDE = 0x0200,
// Internal use: SetMargins has been successfully called
wxCC_IFLAG_LEFT_MARGIN_SET = 0x0400,
// Internal use: Set wxTAB_TRAVERSAL to parent when popup is dismissed
wxCC_IFLAG_PARENT_TAB_TRAVERSAL = 0x0800,
// Internal use: Secondary popup window type should be used (if available).
wxCC_IFLAG_USE_ALT_POPUP = 0x1000,
// Internal use: Skip popup animation.
wxCC_IFLAG_DISABLE_POPUP_ANIM = 0x2000,
// Internal use: Drop-button is a bitmap button or has non-default size
// (but can still be on either side of the control), regardless whether
// specified by the platform or the application.
wxCC_IFLAG_HAS_NONSTANDARD_BUTTON = 0x4000
};
// Flags used by PreprocessMouseEvent and HandleButtonMouseEvent
enum
{
wxCC_MF_ON_BUTTON = 0x0001, // cursor is on dropbutton area
wxCC_MF_ON_CLICK_AREA = 0x0002 // cursor is on dropbutton or other area
// that can be clicked to show the popup.
};
// Namespace for wxComboCtrl feature flags
struct wxComboCtrlFeatures
{
enum
{
MovableButton = 0x0001, // Button can be on either side of control
BitmapButton = 0x0002, // Button may be replaced with bitmap
ButtonSpacing = 0x0004, // Button can have spacing from the edge
// of the control
TextIndent = 0x0008, // SetMargins can be used to control
// left margin.
PaintControl = 0x0010, // Combo control itself can be custom painted
PaintWritable = 0x0020, // A variable-width area in front of writable
// combo control's textctrl can be custom
// painted
Borderless = 0x0040, // wxNO_BORDER window style works
// There are no feature flags for...
// PushButtonBitmapBackground - if its in wxRendererNative, then it should be
// not an issue to have it automatically under the bitmap.
All = MovableButton|BitmapButton|
ButtonSpacing|TextIndent|
PaintControl|PaintWritable|
Borderless
};
};
class WXDLLIMPEXP_CORE wxComboCtrlBase : public wxControl,
public wxTextEntry
{
friend class wxComboPopup;
friend class wxComboPopupEvtHandler;
public:
// ctors and such
wxComboCtrlBase() : wxControl(), wxTextEntry() { Init(); }
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name);
virtual ~wxComboCtrlBase();
// Show/hide popup window (wxComboBox-compatible methods)
virtual void Popup();
virtual void Dismiss()
{
HidePopup(true);
}
// Show/hide popup window.
// TODO: Maybe deprecate in favor of Popup()/Dismiss().
// However, these functions are still called internally
// so it is not straightforward.
virtual void ShowPopup();
virtual void HidePopup(bool generateEvent=false);
// Override for totally custom combo action
virtual void OnButtonClick();
// return true if the popup is currently shown
bool IsPopupShown() const { return m_popupWinState == Visible; }
// set interface class instance derived from wxComboPopup
// NULL popup can be used to indicate default in a derived class
void SetPopupControl( wxComboPopup* popup )
{
DoSetPopupControl(popup);
}
// get interface class instance derived from wxComboPopup
wxComboPopup* GetPopupControl()
{
EnsurePopupControl();
return m_popupInterface;
}
// get the popup window containing the popup control
wxWindow *GetPopupWindow() const { return m_winPopup; }
// Get the text control which is part of the combobox.
wxTextCtrl *GetTextCtrl() const { return m_text; }
// get the dropdown button which is part of the combobox
// note: its not necessarily a wxButton or wxBitmapButton
wxWindow *GetButton() const { return m_btn; }
// forward these methods to all subcontrols
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
//
// wxTextEntry methods
//
// NB: We basically need to override all of them because there is
// no guarantee how platform-specific wxTextEntry is implemented.
//
virtual void SetValue(const wxString& value) wxOVERRIDE
{ wxTextEntryBase::SetValue(value); }
virtual void ChangeValue(const wxString& value) wxOVERRIDE
{ wxTextEntryBase::ChangeValue(value); }
virtual void WriteText(const wxString& text) wxOVERRIDE;
virtual void AppendText(const wxString& text) wxOVERRIDE
{ wxTextEntryBase::AppendText(text); }
virtual wxString GetValue() const wxOVERRIDE
{ return wxTextEntryBase::GetValue(); }
virtual wxString GetRange(long from, long to) const wxOVERRIDE
{ return wxTextEntryBase::GetRange(from, to); }
// Replace() and DoSetValue() need to be fully re-implemented since
// EventSuppressor utility class does not work with the way
// wxComboCtrl is implemented.
virtual void Replace(long from, long to, const wxString& value) wxOVERRIDE;
virtual void Remove(long from, long to) wxOVERRIDE;
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
virtual void SetInsertionPoint(long pos) wxOVERRIDE;
virtual long GetInsertionPoint() const wxOVERRIDE;
virtual long GetLastPosition() const wxOVERRIDE;
virtual void SetSelection(long from, long to) wxOVERRIDE;
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
virtual void SetEditable(bool editable) wxOVERRIDE;
virtual bool SetHint(const wxString& hint) wxOVERRIDE;
virtual wxString GetHint() const wxOVERRIDE;
// This method sets the text without affecting list selection
// (ie. wxComboPopup::SetStringValue doesn't get called).
void SetText(const wxString& value);
// This method sets value and also optionally sends EVT_TEXT
// (needed by combo popups)
wxDEPRECATED( void SetValueWithEvent(const wxString& value,
bool withEvent = true) );
// Changes value of the control as if user had done it by selecting an
// item from a combo box drop-down list. Needs to be public so that
// derived popup classes can call it.
void SetValueByUser(const wxString& value);
//
// Popup customization methods
//
// Sets minimum width of the popup. If wider than combo control, it will extend to the left.
// Remarks:
// * Value -1 indicates the default.
// * Custom popup may choose to ignore this (wxOwnerDrawnComboBox does not).
void SetPopupMinWidth( int width )
{
m_widthMinPopup = width;
}
// Sets preferred maximum height of the popup.
// Remarks:
// * Value -1 indicates the default.
// * Custom popup may choose to ignore this (wxOwnerDrawnComboBox does not).
void SetPopupMaxHeight( int height )
{
m_heightPopup = height;
}
// Extends popup size horizontally, relative to the edges of the combo control.
// Remarks:
// * Popup minimum width may override extLeft (ie. it has higher precedence).
// * Values 0 indicate default.
// * Custom popup may not take this fully into account (wxOwnerDrawnComboBox takes).
void SetPopupExtents( int extLeft, int extRight )
{
m_extLeft = extLeft;
m_extRight = extRight;
}
// Set width, in pixels, of custom paint area in writable combo.
// In read-only, used to indicate area that is not covered by the
// focus rectangle (which may or may not be drawn, depending on the
// popup type).
void SetCustomPaintWidth( int width );
int GetCustomPaintWidth() const { return m_widthCustomPaint; }
// Set side of the control to which the popup will align itself.
// Valid values are wxLEFT, wxRIGHT and 0. The default value 0 wmeans
// that the side of the button will be used.
void SetPopupAnchor( int anchorSide )
{
m_anchorSide = anchorSide;
}
// Set position of dropdown button.
// width: button width. <= 0 for default.
// height: button height. <= 0 for default.
// side: wxLEFT or wxRIGHT, indicates on which side the button will be placed.
// spacingX: empty space on sides of the button. Default is 0.
// Remarks:
// There is no spacingY - the button will be centred vertically.
void SetButtonPosition( int width = -1,
int height = -1,
int side = wxRIGHT,
int spacingX = 0 );
// Returns current size of the dropdown button.
wxSize GetButtonSize();
//
// Sets dropbutton to be drawn with custom bitmaps.
//
// bmpNormal: drawn when cursor is not on button
// pushButtonBg: Draw push button background below the image.
// NOTE! This is usually only properly supported on platforms with appropriate
// method in wxRendererNative.
// bmpPressed: drawn when button is depressed
// bmpHover: drawn when cursor hovers on button. This is ignored on platforms
// that do not generally display hover differently.
// bmpDisabled: drawn when combobox is disabled.
void SetButtonBitmaps( const wxBitmap& bmpNormal,
bool pushButtonBg = false,
const wxBitmap& bmpPressed = wxNullBitmap,
const wxBitmap& bmpHover = wxNullBitmap,
const wxBitmap& bmpDisabled = wxNullBitmap );
#if WXWIN_COMPATIBILITY_2_8
//
// This will set the space in pixels between left edge of the control and the
// text, regardless whether control is read-only (ie. no wxTextCtrl) or not.
// Platform-specific default can be set with value-1.
// Remarks
// * This method may do nothing on some native implementations.
wxDEPRECATED( void SetTextIndent( int indent ) );
// Returns actual indentation in pixels.
wxDEPRECATED( wxCoord GetTextIndent() const );
#endif
// Returns area covered by the text field.
const wxRect& GetTextRect() const
{
return m_tcArea;
}
// Call with enable as true to use a type of popup window that guarantees ability
// to focus the popup control, and normal function of common native controls.
// This alternative popup window is usually a wxDialog, and as such it's parent
// frame will appear as if the focus has been lost from it.
void UseAltPopupWindow( bool enable = true )
{
wxASSERT_MSG( !m_winPopup,
wxT("call this only before SetPopupControl") );
if ( enable )
m_iFlags |= wxCC_IFLAG_USE_ALT_POPUP;
else
m_iFlags &= ~wxCC_IFLAG_USE_ALT_POPUP;
}
// Call with false to disable popup animation, if any.
void EnablePopupAnimation( bool enable = true )
{
if ( enable )
m_iFlags &= ~wxCC_IFLAG_DISABLE_POPUP_ANIM;
else
m_iFlags |= wxCC_IFLAG_DISABLE_POPUP_ANIM;
}
//
// Utilities needed by the popups or native implementations
//
// Returns true if given key combination should toggle the popup.
// NB: This is a separate from other keyboard handling because:
// 1) Replaceability.
// 2) Centralized code (otherwise it'd be split up between
// wxComboCtrl key handler and wxVListBoxComboPopup's
// key handler).
virtual bool IsKeyPopupToggle(const wxKeyEvent& event) const = 0;
// Prepare background of combo control or an item in a dropdown list
// in a way typical on platform. This includes painting the focus/disabled
// background and setting the clipping region.
// Unless you plan to paint your own focus indicator, you should always call this
// in your wxComboPopup::PaintComboControl implementation.
// In addition, it sets pen and text colour to what looks good and proper
// against the background.
// flags: wxRendererNative flags: wxCONTROL_ISSUBMENU: is drawing a list item instead of combo control
// wxCONTROL_SELECTED: list item is selected
// wxCONTROL_DISABLED: control/item is disabled
virtual void PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const;
// Returns true if focus indicator should be drawn in the control.
bool ShouldDrawFocus() const
{
const wxWindow* curFocus = FindFocus();
return ( IsPopupWindowState(Hidden) &&
(curFocus == m_mainCtrlWnd || (m_btn && curFocus == m_btn)) &&
(m_windowStyle & wxCB_READONLY) );
}
// These methods return references to appropriate dropbutton bitmaps
const wxBitmap& GetBitmapNormal() const { return m_bmpNormal; }
const wxBitmap& GetBitmapPressed() const { return m_bmpPressed; }
const wxBitmap& GetBitmapHover() const { return m_bmpHover; }
const wxBitmap& GetBitmapDisabled() const { return m_bmpDisabled; }
// Set custom style flags for embedded wxTextCtrl. Usually must be used
// with two-step creation, before Create() call.
void SetTextCtrlStyle( int style );
// Return internal flags
wxUint32 GetInternalFlags() const { return m_iFlags; }
// Return true if Create has finished
bool IsCreated() const { return m_iFlags & wxCC_IFLAG_CREATED ? true : false; }
// Need to override to return text area background colour
wxColour GetBackgroundColour() const;
// common code to be called on popup hide/dismiss
void OnPopupDismiss(bool generateEvent);
// PopupShown states
enum
{
Hidden = 0,
Closing = 1,
Animating = 2,
Visible = 3
};
bool IsPopupWindowState( int state ) const { return (state == m_popupWinState) ? true : false; }
wxByte GetPopupWindowState() const { return m_popupWinState; }
// Set value returned by GetMainWindowOfCompositeControl
void SetCtrlMainWnd( wxWindow* wnd ) { m_mainCtrlWnd = wnd; }
// This is public so we can access it from wxComboCtrlTextCtrl
virtual wxWindow *GetMainWindowOfCompositeControl() wxOVERRIDE
{ return m_mainCtrlWnd; }
// also set the embedded wxTextCtrl colours
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
protected:
// Returns true if hint text should be drawn in the control
bool ShouldUseHintText(int flags = 0) const
{
return ( !m_text &&
!(flags & wxCONTROL_ISSUBMENU) &&
!m_valueString.length() &&
m_hintText.length() &&
!ShouldDrawFocus() );
}
//
// Override these for customization purposes
//
// called from wxSizeEvent handler
virtual void OnResize() = 0;
// Return native text indentation
// (i.e. text margin, for pure text, not textctrl)
virtual wxCoord GetNativeTextIndent() const;
// Called in syscolourchanged handler and base create
virtual void OnThemeChange();
// Creates wxTextCtrl.
// extraStyle: Extra style parameters
void CreateTextCtrl( int extraStyle );
// Called when text was changed programmatically
// (e.g. from WriteText())
void OnSetValue(const wxString& value);
// Installs standard input handler to combo (and optionally to the textctrl)
void InstallInputHandlers();
// Flags for DrawButton
enum
{
Button_PaintBackground = 0x0001, // Paints control background below the button
Button_BitmapOnly = 0x0002 // Only paints the bitmap
};
// Draws dropbutton. Using wxRenderer or bitmaps, as appropriate.
// Flags are defined above.
virtual void DrawButton( wxDC& dc, const wxRect& rect, int flags = Button_PaintBackground );
// Call if cursor is on button area or mouse is captured for the button.
//bool HandleButtonMouseEvent( wxMouseEvent& event, bool isInside );
bool HandleButtonMouseEvent( wxMouseEvent& event, int flags );
// returns true if event was consumed or filtered (event type is also set to 0 in this case)
bool PreprocessMouseEvent( wxMouseEvent& event, int flags );
//
// This will handle left_down and left_dclick events outside button in a Windows-like manner.
// If you need alternate behaviour, it is recommended you manipulate and filter events to it
// instead of building your own handling routine (for reference, on wxEVT_LEFT_DOWN it will
// toggle popup and on wxEVT_LEFT_DCLICK it will do the same or run the popup's dclick method,
// if defined - you should pass events of other types of it for common processing).
void HandleNormalMouseEvent( wxMouseEvent& event );
// Creates popup window, calls interface->Create(), etc
void CreatePopup();
// Destroy popup window and all related constructs
void DestroyPopup();
// override the base class virtuals involved in geometry calculations
// The common version only sets a default width, so the derived classes
// should override it and set the height and change the width as needed.
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
// NULL popup can be used to indicate default in a derived class
virtual void DoSetPopupControl(wxComboPopup* popup);
// ensures there is at least the default popup
void EnsurePopupControl();
// Recalculates button and textctrl areas. Called when size or button setup change.
// btnWidth: default/calculated width of the dropbutton. 0 means unchanged,
// just recalculate.
void CalculateAreas( int btnWidth = 0 );
// Standard textctrl positioning routine. Just give it platform-dependent
// textctrl coordinate adjustment.
virtual void PositionTextCtrl( int textCtrlXAdjust = 0,
int textCtrlYAdjust = 0);
// event handlers
void OnSizeEvent( wxSizeEvent& event );
void OnFocusEvent(wxFocusEvent& event);
void OnIdleEvent(wxIdleEvent& event);
void OnTextCtrlEvent(wxCommandEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
void OnKeyEvent(wxKeyEvent& event);
void OnCharEvent(wxKeyEvent& event);
// Set customization flags (directs how wxComboCtrlBase helpers behave)
void Customize( wxUint32 flags ) { m_iFlags |= flags; }
// Dispatches size event and refreshes
void RecalcAndRefresh();
// Flags for DoShowPopup and AnimateShow
enum
{
ShowBelow = 0x0000, // Showing popup below the control
ShowAbove = 0x0001, // Showing popup above the control
CanDeferShow = 0x0002 // Can only return true from AnimateShow if this is set
};
// Shows and positions the popup.
virtual void DoShowPopup( const wxRect& rect, int flags );
// Implement in derived class to create a drop-down animation.
// Return true if finished immediately. Otherwise popup is only
// shown when the derived class call DoShowPopup.
// Flags are same as for DoShowPopup.
virtual bool AnimateShow( const wxRect& rect, int flags );
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE;
#endif
// protected wxTextEntry methods
virtual void DoSetValue(const wxString& value, int flags) wxOVERRIDE;
virtual wxString DoGetValue() const wxOVERRIDE;
virtual wxWindow *GetEditableWindow() wxOVERRIDE { return this; }
// margins functions
virtual bool DoSetMargins(const wxPoint& pt) wxOVERRIDE;
virtual wxPoint DoGetMargins() const wxOVERRIDE;
// This is used when m_text is hidden (readonly).
wxString m_valueString;
// This is used when control is unfocused and m_valueString is empty
wxString m_hintText;
// the text control and button we show all the time
wxTextCtrl* m_text;
wxWindow* m_btn;
// wxPopupWindow or similar containing the window managed by the interface.
wxWindow* m_winPopup;
// the popup control/panel
wxWindow* m_popup;
// popup interface
wxComboPopup* m_popupInterface;
// this is input etc. handler for the text control
wxEvtHandler* m_textEvtHandler;
// this is for the top level window
wxEvtHandler* m_toplevEvtHandler;
// this is for the control in popup
wxEvtHandler* m_popupEvtHandler;
// this is for the popup window
wxEvtHandler* m_popupWinEvtHandler;
// main (ie. topmost) window of a composite control (default = this)
wxWindow* m_mainCtrlWnd;
// used to prevent immediate re-popupping in case closed popup
// by clicking on the combo control (needed because of inconsistent
// transient implementation across platforms).
wxMilliClock_t m_timeCanAcceptClick;
// how much popup should expand to the left/right of the control
wxCoord m_extLeft;
wxCoord m_extRight;
// minimum popup width
wxCoord m_widthMinPopup;
// preferred popup height
wxCoord m_heightPopup;
// how much of writable combo is custom-paint by callback?
// also used to indicate area that is not covered by "blue"
// selection indicator.
wxCoord m_widthCustomPaint;
// left margin, in pixels
wxCoord m_marginLeft;
// side on which the popup is aligned
int m_anchorSide;
// Width of the "fake" border
wxCoord m_widthCustomBorder;
// The button and textctrl click/paint areas
wxRect m_tcArea;
wxRect m_btnArea;
// Colour of the text area, in case m_text is NULL
wxColour m_tcBgCol;
// current button state (uses renderer flags)
int m_btnState;
// button position
int m_btnWid;
int m_btnHei;
int m_btnSide;
int m_btnSpacingX;
// last default button width
int m_btnWidDefault;
// custom dropbutton bitmaps
wxBitmap m_bmpNormal;
wxBitmap m_bmpPressed;
wxBitmap m_bmpHover;
wxBitmap m_bmpDisabled;
// area used by the button
wxSize m_btnSize;
// platform-dependent customization and other flags
wxUint32 m_iFlags;
// custom style for m_text
int m_textCtrlStyle;
// draw blank button background under bitmap?
bool m_blankButtonBg;
// is the popup window currently shown?
wxByte m_popupWinState;
// should the focus be reset to the textctrl in idle time?
bool m_resetFocus;
// is the text-area background colour overridden?
bool m_hasTcBgCol;
private:
void Init();
wxByte m_ignoreEvtText; // Number of next EVT_TEXTs to ignore
// Is popup window wxPopupTransientWindow, wxPopupWindow or wxDialog?
wxByte m_popupWinType;
wxDECLARE_EVENT_TABLE();
wxDECLARE_ABSTRACT_CLASS(wxComboCtrlBase);
};
// ----------------------------------------------------------------------------
// wxComboPopup is the interface which must be implemented by a control to be
// used as a popup by wxComboCtrl
// ----------------------------------------------------------------------------
// wxComboPopup internal flags
enum
{
wxCP_IFLAG_CREATED = 0x0001 // Set by wxComboCtrlBase after Create is called
};
class WXDLLIMPEXP_FWD_CORE wxComboCtrl;
class WXDLLIMPEXP_CORE wxComboPopup
{
friend class wxComboCtrlBase;
public:
wxComboPopup()
{
m_combo = NULL;
m_iFlags = 0;
}
// This is called immediately after construction finishes. m_combo member
// variable has been initialized before the call.
// NOTE: It is not in constructor so the derived class doesn't need to redefine
// a default constructor of its own.
virtual void Init() { }
virtual ~wxComboPopup();
// Create the popup child control.
// Return true for success.
virtual bool Create(wxWindow* parent) = 0;
// Calls Destroy() for the popup control (i.e. one returned by
// GetControl()) and makes sure that 'this' is deleted at the end.
// Default implementation works for both cases where popup control
// class is multiple inherited or created on heap as a separate
// object.
virtual void DestroyPopup();
// We must have an associated control which is subclassed by the combobox.
virtual wxWindow *GetControl() = 0;
// Called immediately after the popup is shown
virtual void OnPopup();
// Called when popup is dismissed
virtual void OnDismiss();
// Called just prior to displaying popup.
// Default implementation does nothing.
virtual void SetStringValue( const wxString& value );
// Gets displayed string representation of the value.
virtual wxString GetStringValue() const = 0;
// Called to check if the popup - when an item container - actually
// has matching item. Case-sensitivity checking etc. is up to the
// implementation. If the found item matched the string, but is
// different, it should be written back to pItem. Default implementation
// always return true and does not alter trueItem.
virtual bool FindItem(const wxString& item, wxString* trueItem=NULL);
// This is called to custom paint in the combo control itself (ie. not the popup).
// Default implementation draws value as string.
virtual void PaintComboControl( wxDC& dc, const wxRect& rect );
// Receives wxEVT_KEY_DOWN key events from the parent wxComboCtrl.
// Events not handled should be skipped, as usual.
virtual void OnComboKeyEvent( wxKeyEvent& event );
// Receives wxEVT_CHAR key events from the parent wxComboCtrl.
// Events not handled should be skipped, as usual.
virtual void OnComboCharEvent( wxKeyEvent& event );
// Implement if you need to support special action when user
// double-clicks on the parent wxComboCtrl.
virtual void OnComboDoubleClick();
// Return final size of popup. Called on every popup, just prior to OnShow.
// minWidth = preferred minimum width for window
// prefHeight = preferred height. Only applies if > 0,
// maxHeight = max height for window, as limited by screen size
// and should only be rounded down, if necessary.
virtual wxSize GetAdjustedSize( int minWidth, int prefHeight, int maxHeight );
// Return true if you want delay call to Create until the popup is shown
// for the first time. It is more efficient, but note that it is often
// more convenient to have the control created immediately.
// Default returns false.
virtual bool LazyCreate();
//
// Utilities
//
// Hides the popup
void Dismiss();
// Returns true if Create has been called.
bool IsCreated() const
{
return (m_iFlags & wxCP_IFLAG_CREATED) ? true : false;
}
// Returns pointer to the associated parent wxComboCtrl.
wxComboCtrl* GetComboCtrl() const;
// Default PaintComboControl behaviour
static void DefaultPaintComboControl( wxComboCtrlBase* combo,
wxDC& dc,
const wxRect& rect );
protected:
wxComboCtrlBase* m_combo;
wxUint32 m_iFlags;
private:
// Called in wxComboCtrlBase::SetPopupControl
void InitBase(wxComboCtrlBase *combo)
{
m_combo = combo;
}
};
// ----------------------------------------------------------------------------
// include the platform-dependent header defining the real class
// ----------------------------------------------------------------------------
#if defined(__WXUNIVERSAL__)
// No native universal (but it must still be first in the list)
#elif defined(__WXMSW__)
#include "wx/msw/combo.h"
#endif
// Any ports may need generic as an alternative
#include "wx/generic/combo.h"
#endif // wxUSE_COMBOCTRL
#endif
// _WX_COMBOCONTROL_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/animate.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/animate.h
// Purpose: wxAnimation and wxAnimationCtrl
// Author: Julian Smart and Guillermo Rodriguez Garcia
// Modified by: Francesco Montorsi
// Created: 13/8/99
// Copyright: (c) Julian Smart and Guillermo Rodriguez Garcia
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ANIMATE_H_
#define _WX_ANIMATE_H_
#include "wx/defs.h"
#if wxUSE_ANIMATIONCTRL
#include "wx/animdecod.h"
#include "wx/control.h"
#include "wx/timer.h"
#include "wx/bitmap.h"
class WXDLLIMPEXP_FWD_CORE wxAnimation;
extern WXDLLIMPEXP_DATA_CORE(wxAnimation) wxNullAnimation;
extern WXDLLIMPEXP_DATA_CORE(const char) wxAnimationCtrlNameStr[];
// ----------------------------------------------------------------------------
// wxAnimationBase
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAnimationBase : public wxObject
{
public:
wxAnimationBase() {}
virtual bool IsOk() const = 0;
// can be -1
virtual int GetDelay(unsigned int frame) const = 0;
virtual unsigned int GetFrameCount() const = 0;
virtual wxImage GetFrame(unsigned int frame) const = 0;
virtual wxSize GetSize() const = 0;
virtual bool LoadFile(const wxString& name,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual bool Load(wxInputStream& stream,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
protected:
wxDECLARE_ABSTRACT_CLASS(wxAnimationBase);
};
// ----------------------------------------------------------------------------
// wxAnimationCtrlBase
// ----------------------------------------------------------------------------
// do not autoresize to the animation's size when SetAnimation() is called
#define wxAC_NO_AUTORESIZE (0x0010)
// default style does not include wxAC_NO_AUTORESIZE, that is, the control
// auto-resizes by default to fit the new animation when SetAnimation() is called
#define wxAC_DEFAULT_STYLE (wxBORDER_NONE)
class WXDLLIMPEXP_CORE wxAnimationCtrlBase : public wxControl
{
public:
wxAnimationCtrlBase() { }
// public API
virtual bool LoadFile(const wxString& filename,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual bool Load(wxInputStream& stream,
wxAnimationType type = wxANIMATION_TYPE_ANY) = 0;
virtual void SetAnimation(const wxAnimation &anim) = 0;
virtual wxAnimation GetAnimation() const = 0;
virtual bool Play() = 0;
virtual void Stop() = 0;
virtual bool IsPlaying() const = 0;
virtual void SetInactiveBitmap(const wxBitmap &bmp);
// always return the original bitmap set in this control
wxBitmap GetInactiveBitmap() const
{ return m_bmpStatic; }
protected:
// the inactive bitmap as it was set by the user
wxBitmap m_bmpStatic;
// the inactive bitmap currently shown in the control
// (may differ in the size from m_bmpStatic)
wxBitmap m_bmpStaticReal;
// updates m_bmpStaticReal from m_bmpStatic if needed
virtual void UpdateStaticImage();
// called by SetInactiveBitmap
virtual void DisplayStaticImage() = 0;
private:
wxDECLARE_ABSTRACT_CLASS(wxAnimationCtrlBase);
};
// ----------------------------------------------------------------------------
// include the platform-specific version of the wxAnimationCtrl class
// ----------------------------------------------------------------------------
#if defined(__WXGTK20__) && !defined(__WXUNIVERSAL__)
#include "wx/gtk/animate.h"
#else
#include "wx/generic/animate.h"
#endif
#endif // wxUSE_ANIMATIONCTRL
#endif // _WX_ANIMATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/types.h | /*
* Name: wx/types.h
* Purpose: Declarations of common wx types and related constants.
* Author: Vadim Zeitlin (extracted from wx/defs.h)
* Created: 2018-01-07
* Copyright: (c) 1997-2018 wxWidgets dev team
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_TYPES_H_
#define _WX_TYPES_H_
/*
Don't include wx/defs.h from here as we're included from it, but do include
wx/platform.h which will take care of including wx/setup.h too.
*/
#include "wx/platform.h"
/* ---------------------------------------------------------------------------- */
/* standard wxWidgets types */
/* ---------------------------------------------------------------------------- */
/* the type for screen and DC coordinates */
typedef int wxCoord;
enum { wxDefaultCoord = -1 };
/* ---------------------------------------------------------------------------- */
/* define fixed length types */
/* ---------------------------------------------------------------------------- */
#if defined(__MINGW32__)
#include <sys/types.h>
#endif
/* chars are always one byte (by definition), shorts are always two (in */
/* practice) */
/* 8bit */
typedef signed char wxInt8;
typedef unsigned char wxUint8;
typedef wxUint8 wxByte;
/* 16bit */
#ifdef SIZEOF_SHORT
#if SIZEOF_SHORT != 2
#error "wxWidgets assumes sizeof(short) == 2, please fix the code"
#endif
#else
#define SIZEOF_SHORT 2
#endif
typedef signed short wxInt16;
typedef unsigned short wxUint16;
typedef wxUint16 wxWord;
/*
things are getting more interesting with ints, longs and pointers
there are several different standard data models described by this table:
+-----------+----------------------------+
|type\model | LP64 ILP64 LLP64 ILP32 LP32|
+-----------+----------------------------+
|char | 8 8 8 8 8 |
|short | 16 16 16 16 16 |
|int | 32 64 32 32 16 |
|long | 64 64 32 32 32 |
|long long | 64 64 64 -- -- |
|void * | 64 64 64 32 32 |
+-----------+----------------------------+
Win16 used LP32 (but we don't support it any longer), Win32 obviously used
ILP32 and Win64 uses LLP64 (a.k.a. P64)
Under Unix LP64 is the most widely used (the only I've ever seen, in fact)
*/
/* 32bit */
#if defined(__WINDOWS__)
#if defined(__WIN32__)
typedef int wxInt32;
typedef unsigned int wxUint32;
/*
Win64 uses LLP64 model and so ints and longs have the same size as
in Win32.
*/
#ifndef SIZEOF_INT
#define SIZEOF_INT 4
#endif
#ifndef SIZEOF_LONG
#define SIZEOF_LONG 4
#endif
#ifndef SIZEOF_LONG_LONG
#define SIZEOF_LONG_LONG 8
#endif
#ifndef SIZEOF_WCHAR_T
/* Windows uses UTF-16 */
#define SIZEOF_WCHAR_T 2
#endif
#ifndef SIZEOF_SIZE_T
/*
Under Win64 sizeof(size_t) == 8 and so it is neither unsigned
int nor unsigned long!
*/
#ifdef __WIN64__
#define SIZEOF_SIZE_T 8
#undef wxSIZE_T_IS_UINT
#else /* Win32 */
#define SIZEOF_SIZE_T 4
#define wxSIZE_T_IS_UINT
#endif
#undef wxSIZE_T_IS_ULONG
#endif
#ifndef SIZEOF_VOID_P
#ifdef __WIN64__
#define SIZEOF_VOID_P 8
#else /* Win32 */
#define SIZEOF_VOID_P 4
#endif /* Win64/32 */
#endif
#else
#error "Unsupported Windows version"
#endif
#else /* !Windows */
/* SIZEOF_XXX are normally defined by configure */
#ifdef SIZEOF_INT
#if SIZEOF_INT == 8
/* must be ILP64 data model, there is normally a special 32 bit */
/* type in it but we don't know what it is... */
#error "No 32bit int type on this platform"
#elif SIZEOF_INT == 4
typedef int wxInt32;
typedef unsigned int wxUint32;
#elif SIZEOF_INT == 2
/* must be LP32 */
#if SIZEOF_LONG != 4
#error "No 32bit int type on this platform"
#endif
typedef long wxInt32;
typedef unsigned long wxUint32;
#else
/* wxWidgets is not ready for 128bit systems yet... */
#error "Unknown sizeof(int) value, what are you compiling for?"
#endif
#else /* !defined(SIZEOF_INT) */
/* assume default 32bit machine -- what else can we do? */
wxCOMPILE_TIME_ASSERT( sizeof(int) == 4, IntMustBeExactly4Bytes);
wxCOMPILE_TIME_ASSERT( sizeof(size_t) == 4, SizeTMustBeExactly4Bytes);
wxCOMPILE_TIME_ASSERT( sizeof(void *) == 4, PtrMustBeExactly4Bytes);
#define SIZEOF_INT 4
#define SIZEOF_SIZE_T 4
#define SIZEOF_VOID_P 4
typedef int wxInt32;
typedef unsigned int wxUint32;
#if defined(__MACH__) && !defined(SIZEOF_WCHAR_T)
#define SIZEOF_WCHAR_T 4
#endif
#if !defined(SIZEOF_WCHAR_T)
/* also assume that sizeof(wchar_t) == 2 (under Unix the most */
/* common case is 4 but there configure would have defined */
/* SIZEOF_WCHAR_T for us) */
/* the most common case */
wxCOMPILE_TIME_ASSERT( sizeof(wchar_t) == 2,
Wchar_tMustBeExactly2Bytes);
#define SIZEOF_WCHAR_T 2
#endif /* !defined(SIZEOF_WCHAR_T) */
#endif
#endif /* Win/!Win */
#ifndef SIZEOF_WCHAR_T
#error "SIZEOF_WCHAR_T must be defined, but isn't"
#endif
/* also define C99-like sized MIN/MAX constants */
#define wxINT8_MIN CHAR_MIN
#define wxINT8_MAX CHAR_MAX
#define wxUINT8_MAX UCHAR_MAX
#define wxINT16_MIN SHRT_MIN
#define wxINT16_MAX SHRT_MAX
#define wxUINT16_MAX USHRT_MAX
#if SIZEOF_INT == 4
#define wxINT32_MIN INT_MIN
#define wxINT32_MAX INT_MAX
#define wxUINT32_MAX UINT_MAX
#elif SIZEOF_LONG == 4
#define wxINT32_MIN LONG_MIN
#define wxINT32_MAX LONG_MAX
#define wxUINT32_MAX ULONG_MAX
#else
#error "Unknown 32 bit type"
#endif
typedef wxUint32 wxDword;
#ifdef LLONG_MAX
#define wxINT64_MIN LLONG_MIN
#define wxINT64_MAX LLONG_MAX
#define wxUINT64_MAX ULLONG_MAX
#else
#define wxINT64_MIN (wxLL(-9223372036854775807)-1)
#define wxINT64_MAX wxLL(9223372036854775807)
#define wxUINT64_MAX wxULL(0xFFFFFFFFFFFFFFFF)
#endif
/* 64 bit */
/* NB: we #define and not typedef wxLongLong_t because we use "#ifdef */
/* wxLongLong_t" in wx/longlong.h */
/* wxULongLong_t is set later (usually to unsigned wxLongLong_t) */
/* to avoid compilation problems on 64bit machines with ambiguous method calls */
/* we will need to define this */
#undef wxLongLongIsLong
/*
First check for specific compilers which have known 64 bit integer types,
this avoids clashes with SIZEOF_LONG[_LONG] being defined incorrectly for
e.g. MSVC builds (Python.h defines it as 8 even for MSVC).
Also notice that we check for "long long" before checking for 64 bit long as
we still want to use "long long" and not "long" for wxLongLong_t on 64 bit
architectures to be able to pass wxLongLong_t to the standard functions
prototyped as taking "long long" such as strtoll().
*/
#if (defined(__VISUALC__) || defined(__INTELC__)) && defined(__WIN32__)
#define wxLongLong_t __int64
#define wxLongLongSuffix i64
#define wxLongLongFmtSpec "I64"
#elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
#define wxLongLong_t __int64
#define wxLongLongSuffix i64
#define wxLongLongFmtSpec "L"
#elif defined(__MINGW32__) && \
(defined(__USE_MINGW_ANSI_STDIO) && (__USE_MINGW_ANSI_STDIO != 1))
#define wxLongLong_t long long
#define wxLongLongSuffix ll
#define wxLongLongFmtSpec "I64"
#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8) || \
defined(__GNUC__) || \
defined(__CYGWIN__)
#define wxLongLong_t long long
#define wxLongLongSuffix ll
#define wxLongLongFmtSpec "ll"
#elif defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
#define wxLongLong_t long
#define wxLongLongSuffix l
#define wxLongLongFmtSpec "l"
#define wxLongLongIsLong
#endif
#ifdef wxLongLong_t
#define wxULongLong_t unsigned wxLongLong_t
/*
wxLL() and wxULL() macros allow to define 64 bit constants in a
portable way.
*/
#ifndef wxCOMPILER_BROKEN_CONCAT_OPER
#define wxLL(x) wxCONCAT(x, wxLongLongSuffix)
#define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix))
#else
/*
Currently only Borland compiler has broken concatenation operator
and this compiler is known to use [u]i64 suffix.
*/
#define wxLL(x) wxAPPEND_i64(x)
#define wxULL(x) wxAPPEND_ui64(x)
#endif
typedef wxLongLong_t wxInt64;
typedef wxULongLong_t wxUint64;
#define wxHAS_INT64 1
#ifndef wxLongLongIsLong
#define wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
#endif
#elif wxUSE_LONGLONG
/* these macros allow to define 64 bit constants in a portable way */
#define wxLL(x) wxLongLong(x)
#define wxULL(x) wxULongLong(x)
#define wxInt64 wxLongLong
#define wxUint64 wxULongLong
#define wxHAS_INT64 1
#else /* !wxUSE_LONGLONG */
#define wxHAS_INT64 0
#endif
/*
Helper macro for conditionally compiling some code only if wxLongLong_t is
available and is a type different from the other integer types (i.e. not
long).
*/
#ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
#define wxIF_LONG_LONG_TYPE(x) x
#else
#define wxIF_LONG_LONG_TYPE(x)
#endif
/* Make sure ssize_t is defined (a signed type the same size as size_t). */
/* (HAVE_SSIZE_T is not already defined by configure) */
#ifndef HAVE_SSIZE_T
#ifdef __MINGW32__
#if defined(_SSIZE_T_) || defined(_SSIZE_T_DEFINED)
#define HAVE_SSIZE_T
#endif
#endif
#endif /* !HAVE_SSIZE_T */
/* If we really don't have ssize_t, provide our own version. */
#ifdef HAVE_SSIZE_T
#ifdef __UNIX__
#include <sys/types.h>
#endif
#else /* !HAVE_SSIZE_T */
#if SIZEOF_SIZE_T == 4
typedef wxInt32 ssize_t;
#elif SIZEOF_SIZE_T == 8
typedef wxInt64 ssize_t;
#else
#error "error defining ssize_t, size_t is not 4 or 8 bytes"
#endif
/* prevent ssize_t redefinitions in other libraries */
#define HAVE_SSIZE_T
#endif
/*
We can't rely on Windows _W64 being defined as windows.h may not be
included so define our own equivalent: this should be used with types
like WXLPARAM or WXWPARAM which are 64 bit under Win64 to avoid warnings
each time we cast it to a pointer or a handle (which results in hundreds
of warnings as Win32 API often passes pointers in them)
*/
#ifdef __VISUALC__
#define wxW64 __w64
#else
#define wxW64
#endif
/*
Define signed and unsigned integral types big enough to contain all of long,
size_t and void *.
*/
#if SIZEOF_LONG >= SIZEOF_VOID_P
/*
Normal case when long is the largest integral type.
*/
typedef long wxIntPtr;
typedef unsigned long wxUIntPtr;
#elif SIZEOF_SIZE_T >= SIZEOF_VOID_P
/*
Win64 case: size_t is the only integral type big enough for "void *".
Notice that we must use __w64 to avoid warnings about casting pointers
to wxIntPtr (which we do often as this is what it is defined for) in 32
bit build with MSVC.
*/
typedef wxW64 ssize_t wxIntPtr;
typedef size_t wxUIntPtr;
#else
/*
This should never happen for the current architectures but if you're
using one where it does, please contact [email protected].
*/
#error "Pointers can't be stored inside integer types."
#endif
#endif // _WX_TYPES_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/dcmemory.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dcmemory.h
// Purpose: wxMemoryDC base header
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCMEMORY_H_BASE_
#define _WX_DCMEMORY_H_BASE_
#include "wx/dc.h"
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMemoryDC: public wxDC
{
public:
wxMemoryDC();
wxMemoryDC( wxBitmap& bitmap );
wxMemoryDC( wxDC *dc );
// select the given bitmap to draw on it
void SelectObject(wxBitmap& bmp);
// select the given bitmap for read-only
void SelectObjectAsSource(const wxBitmap& bmp);
// get selected bitmap
const wxBitmap& GetSelectedBitmap() const;
wxBitmap& GetSelectedBitmap();
private:
wxDECLARE_DYNAMIC_CLASS(wxMemoryDC);
};
#endif
// _WX_DCMEMORY_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/anybutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/anybutton.h
// Purpose: wxAnyButtonBase class
// Author: Vadim Zeitlin
// Created: 2000-08-15 (extracted from button.h)
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ANYBUTTON_H_BASE_
#define _WX_ANYBUTTON_H_BASE_
#include "wx/defs.h"
#ifdef wxHAS_ANY_BUTTON
// ----------------------------------------------------------------------------
// wxAnyButton specific flags
// ----------------------------------------------------------------------------
// These flags affect label alignment
#define wxBU_LEFT 0x0040
#define wxBU_TOP 0x0080
#define wxBU_RIGHT 0x0100
#define wxBU_BOTTOM 0x0200
#define wxBU_ALIGN_MASK ( wxBU_LEFT | wxBU_TOP | wxBU_RIGHT | wxBU_BOTTOM )
// These two flags are obsolete and have no effect any longer.
#define wxBU_NOAUTODRAW 0x0000
#define wxBU_AUTODRAW 0x0004
// by default, the buttons will be created with some (system dependent)
// minimal size to make them look nicer, giving this style will make them as
// small as possible
#define wxBU_EXACTFIT 0x0001
// this flag can be used to disable using the text label in the button: it is
// mostly useful when creating buttons showing bitmap and having stock id as
// without it both the standard label corresponding to the stock id and the
// bitmap would be shown
#define wxBU_NOTEXT 0x0002
#include "wx/bitmap.h"
#include "wx/control.h"
// ----------------------------------------------------------------------------
// wxAnyButton: common button functionality
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAnyButtonBase : public wxControl
{
public:
wxAnyButtonBase() { }
// show the image in the button in addition to the label: this method is
// supported on all (major) platforms
void SetBitmap(const wxBitmap& bitmap, wxDirection dir = wxLEFT)
{
SetBitmapLabel(bitmap);
SetBitmapPosition(dir);
}
wxBitmap GetBitmap() const { return DoGetBitmap(State_Normal); }
// Methods for setting individual images for different states: normal,
// selected (meaning pushed or pressed), focused (meaning normal state for
// a focused button), disabled or hover (a.k.a. hot or current).
//
// Remember that SetBitmap() itself must be called before any other
// SetBitmapXXX() methods (except for SetBitmapLabel() which is a synonym
// for it anyhow) and that all bitmaps passed to these functions should be
// of the same size.
void SetBitmapLabel(const wxBitmap& bitmap)
{ DoSetBitmap(bitmap, State_Normal); }
void SetBitmapPressed(const wxBitmap& bitmap)
{ DoSetBitmap(bitmap, State_Pressed); }
void SetBitmapDisabled(const wxBitmap& bitmap)
{ DoSetBitmap(bitmap, State_Disabled); }
void SetBitmapCurrent(const wxBitmap& bitmap)
{ DoSetBitmap(bitmap, State_Current); }
void SetBitmapFocus(const wxBitmap& bitmap)
{ DoSetBitmap(bitmap, State_Focused); }
wxBitmap GetBitmapLabel() const { return DoGetBitmap(State_Normal); }
wxBitmap GetBitmapPressed() const { return DoGetBitmap(State_Pressed); }
wxBitmap GetBitmapDisabled() const { return DoGetBitmap(State_Disabled); }
wxBitmap GetBitmapCurrent() const { return DoGetBitmap(State_Current); }
wxBitmap GetBitmapFocus() const { return DoGetBitmap(State_Focused); }
// set the margins around the image
void SetBitmapMargins(wxCoord x, wxCoord y) { DoSetBitmapMargins(x, y); }
void SetBitmapMargins(const wxSize& sz) { DoSetBitmapMargins(sz.x, sz.y); }
wxSize GetBitmapMargins() { return DoGetBitmapMargins(); }
// set the image position relative to the text, i.e. wxLEFT means that the
// image is to the left of the text (this is the default)
void SetBitmapPosition(wxDirection dir);
// Buttons on MSW can look bad if they are not native colours, because
// then they become owner-drawn and not theme-drawn. Disable it here
// in wxAnyButtonBase to make it consistent.
virtual bool ShouldInheritColours() const wxOVERRIDE { return false; }
// wxUniv-compatible and deprecated equivalents to SetBitmapXXX()
#if WXWIN_COMPATIBILITY_2_8
void SetImageLabel(const wxBitmap& bitmap) { SetBitmap(bitmap); }
void SetImageMargins(wxCoord x, wxCoord y) { SetBitmapMargins(x, y); }
#endif // WXWIN_COMPATIBILITY_2_8
// backwards compatible names for pressed/current bitmaps: they're not
// deprecated as there is nothing really wrong with using them and no real
// advantage to using the new names but the new names are still preferred
wxBitmap GetBitmapSelected() const { return GetBitmapPressed(); }
wxBitmap GetBitmapHover() const { return GetBitmapCurrent(); }
void SetBitmapSelected(const wxBitmap& bitmap) { SetBitmapPressed(bitmap); }
void SetBitmapHover(const wxBitmap& bitmap) { SetBitmapCurrent(bitmap); }
// this enum is not part of wx public API, it is public because it is used
// in non wxAnyButton-derived classes internally
//
// also notice that MSW code relies on the values of the enum elements, do
// not change them without revising src/msw/button.cpp
enum State
{
State_Normal,
State_Current, // a.k.a. hot or "hovering"
State_Pressed, // a.k.a. "selected" in public API for some reason
State_Disabled,
State_Focused,
State_Max
};
// return the current setting for the "normal" state of the button, it can
// be different from State_Normal for a wxToggleButton
virtual State GetNormalState() const
{
return State_Normal;
}
// return true if this button shouldn't show the text label, either because
// it doesn't have it or because it was explicitly disabled with wxBU_NOTEXT
bool DontShowLabel() const
{
return HasFlag(wxBU_NOTEXT) || GetLabel().empty();
}
// return true if we do show the label
bool ShowsLabel() const
{
return !DontShowLabel();
}
protected:
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual wxBitmap DoGetBitmap(State WXUNUSED(which)) const
{ return wxBitmap(); }
virtual void DoSetBitmap(const wxBitmap& WXUNUSED(bitmap),
State WXUNUSED(which))
{ }
virtual wxSize DoGetBitmapMargins() const
{ return wxSize(0, 0); }
virtual void DoSetBitmapMargins(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
{ }
virtual void DoSetBitmapPosition(wxDirection WXUNUSED(dir))
{ }
virtual bool DoGetAuthNeeded() const { return false; }
virtual void DoSetAuthNeeded(bool WXUNUSED(show)) { }
wxDECLARE_NO_COPY_CLASS(wxAnyButtonBase);
};
#if defined(__WXUNIVERSAL__)
#include "wx/univ/anybutton.h"
#elif defined(__WXMSW__)
#include "wx/msw/anybutton.h"
//#elif defined(__WXMOTIF__)
// #include "wx/motif/anybutton.h"
#elif defined(__WXGTK20__)
#include "wx/gtk/anybutton.h"
//#elif defined(__WXGTK__)
// #include "wx/gtk1/anybutton.h"
#elif defined(__WXMAC__)
#include "wx/osx/anybutton.h"
#elif defined(__WXQT__)
#include "wx/qt/anybutton.h"
#else
typedef wxAnyButtonBase wxAnyButton;
#endif
#endif // wxHAS_ANY_BUTTON
#endif // _WX_ANYBUTTON_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/graphics.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/graphics.h
// Purpose: graphics context header
// Author: Stefan Csomor
// Modified by:
// Created:
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GRAPHICS_H_
#define _WX_GRAPHICS_H_
#include "wx/defs.h"
#if wxUSE_GRAPHICS_CONTEXT
#include "wx/affinematrix2d.h"
#include "wx/geometry.h"
#include "wx/colour.h"
#include "wx/dynarray.h"
#include "wx/font.h"
#include "wx/image.h"
#include "wx/peninfobase.h"
#include "wx/vector.h"
enum wxAntialiasMode
{
wxANTIALIAS_NONE, // should be 0
wxANTIALIAS_DEFAULT
};
enum wxInterpolationQuality
{
// default interpolation
wxINTERPOLATION_DEFAULT,
// no interpolation
wxINTERPOLATION_NONE,
// fast interpolation, suited for interactivity
wxINTERPOLATION_FAST,
// better quality
wxINTERPOLATION_GOOD,
// best quality, not suited for interactivity
wxINTERPOLATION_BEST
};
enum wxCompositionMode
{
// R = Result, S = Source, D = Destination, premultiplied with alpha
// Ra, Sa, Da their alpha components
// classic Porter-Duff compositions
// http://keithp.com/~keithp/porterduff/p253-porter.pdf
wxCOMPOSITION_INVALID = -1, /* indicates invalid/unsupported mode */
wxCOMPOSITION_CLEAR, /* R = 0 */
wxCOMPOSITION_SOURCE, /* R = S */
wxCOMPOSITION_OVER, /* R = S + D*(1 - Sa) */
wxCOMPOSITION_IN, /* R = S*Da */
wxCOMPOSITION_OUT, /* R = S*(1 - Da) */
wxCOMPOSITION_ATOP, /* R = S*Da + D*(1 - Sa) */
wxCOMPOSITION_DEST, /* R = D, essentially a noop */
wxCOMPOSITION_DEST_OVER, /* R = S*(1 - Da) + D */
wxCOMPOSITION_DEST_IN, /* R = D*Sa */
wxCOMPOSITION_DEST_OUT, /* R = D*(1 - Sa) */
wxCOMPOSITION_DEST_ATOP, /* R = S*(1 - Da) + D*Sa */
wxCOMPOSITION_XOR, /* R = S*(1 - Da) + D*(1 - Sa) */
// mathematical compositions
wxCOMPOSITION_ADD /* R = S + D */
};
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxWindowDC;
class WXDLLIMPEXP_FWD_CORE wxMemoryDC;
#if wxUSE_PRINTING_ARCHITECTURE
class WXDLLIMPEXP_FWD_CORE wxPrinterDC;
#endif
#ifdef __WXMSW__
#if wxUSE_ENH_METAFILE
class WXDLLIMPEXP_FWD_CORE wxEnhMetaFileDC;
#endif
#endif
class WXDLLIMPEXP_FWD_CORE wxGraphicsContext;
class WXDLLIMPEXP_FWD_CORE wxGraphicsPath;
class WXDLLIMPEXP_FWD_CORE wxGraphicsMatrix;
class WXDLLIMPEXP_FWD_CORE wxGraphicsFigure;
class WXDLLIMPEXP_FWD_CORE wxGraphicsRenderer;
class WXDLLIMPEXP_FWD_CORE wxGraphicsPen;
class WXDLLIMPEXP_FWD_CORE wxGraphicsBrush;
class WXDLLIMPEXP_FWD_CORE wxGraphicsFont;
class WXDLLIMPEXP_FWD_CORE wxGraphicsBitmap;
/*
* notes about the graphics context apis
*
* angles : are measured in radians, 0.0 being in direction of positiv x axis, PI/2 being
* in direction of positive y axis.
*/
// Base class of all objects used for drawing in the new graphics API, the always point back to their
// originating rendering engine, there is no dynamic unloading of a renderer currently allowed,
// these references are not counted
//
// The data used by objects like graphics pens etc is ref counted, in order to avoid unnecessary expensive
// duplication. Any operation on a shared instance that results in a modified state, uncouples this
// instance from the other instances that were shared - using copy on write semantics
//
class WXDLLIMPEXP_FWD_CORE wxGraphicsObjectRefData;
class WXDLLIMPEXP_FWD_CORE wxGraphicsBitmapData;
class WXDLLIMPEXP_FWD_CORE wxGraphicsMatrixData;
class WXDLLIMPEXP_FWD_CORE wxGraphicsPathData;
class WXDLLIMPEXP_CORE wxGraphicsObject : public wxObject
{
public:
wxGraphicsObject();
wxGraphicsObject( wxGraphicsRenderer* renderer );
virtual ~wxGraphicsObject();
bool IsNull() const;
// returns the renderer that was used to create this instance, or NULL if it has not been initialized yet
wxGraphicsRenderer* GetRenderer() const;
wxGraphicsObjectRefData* GetGraphicsData() const;
protected:
virtual wxObjectRefData* CreateRefData() const wxOVERRIDE;
virtual wxObjectRefData* CloneRefData(const wxObjectRefData* data) const wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxGraphicsObject);
};
// ----------------------------------------------------------------------------
// wxGraphicsPenInfo describes a wxGraphicsPen
// ----------------------------------------------------------------------------
class wxGraphicsPenInfo : public wxPenInfoBase<wxGraphicsPenInfo>
{
public:
explicit wxGraphicsPenInfo(const wxColour& colour = wxColour(),
wxDouble width = 1.0,
wxPenStyle style = wxPENSTYLE_SOLID)
: wxPenInfoBase<wxGraphicsPenInfo>(colour, style)
{
m_width = width;
}
// Setters
wxGraphicsPenInfo& Width(wxDouble width)
{ m_width = width; return *this; }
// Accessors
wxDouble GetWidth() const { return m_width; }
private:
wxDouble m_width;
};
class WXDLLIMPEXP_CORE wxGraphicsPen : public wxGraphicsObject
{
public:
wxGraphicsPen() {}
virtual ~wxGraphicsPen() {}
private:
wxDECLARE_DYNAMIC_CLASS(wxGraphicsPen);
};
extern WXDLLIMPEXP_DATA_CORE(wxGraphicsPen) wxNullGraphicsPen;
class WXDLLIMPEXP_CORE wxGraphicsBrush : public wxGraphicsObject
{
public:
wxGraphicsBrush() {}
virtual ~wxGraphicsBrush() {}
private:
wxDECLARE_DYNAMIC_CLASS(wxGraphicsBrush);
};
extern WXDLLIMPEXP_DATA_CORE(wxGraphicsBrush) wxNullGraphicsBrush;
class WXDLLIMPEXP_CORE wxGraphicsFont : public wxGraphicsObject
{
public:
wxGraphicsFont() {}
virtual ~wxGraphicsFont() {}
private:
wxDECLARE_DYNAMIC_CLASS(wxGraphicsFont);
};
extern WXDLLIMPEXP_DATA_CORE(wxGraphicsFont) wxNullGraphicsFont;
class WXDLLIMPEXP_CORE wxGraphicsBitmap : public wxGraphicsObject
{
public:
wxGraphicsBitmap() {}
virtual ~wxGraphicsBitmap() {}
// Convert bitmap to wxImage: this is more efficient than converting to
// wxBitmap first and then to wxImage and also works without X server
// connection under Unix that wxBitmap requires.
#if wxUSE_IMAGE
wxImage ConvertToImage() const;
#endif // wxUSE_IMAGE
void* GetNativeBitmap() const;
const wxGraphicsBitmapData* GetBitmapData() const
{ return (const wxGraphicsBitmapData*) GetRefData(); }
wxGraphicsBitmapData* GetBitmapData()
{ return (wxGraphicsBitmapData*) GetRefData(); }
private:
wxDECLARE_DYNAMIC_CLASS(wxGraphicsBitmap);
};
extern WXDLLIMPEXP_DATA_CORE(wxGraphicsBitmap) wxNullGraphicsBitmap;
class WXDLLIMPEXP_CORE wxGraphicsMatrix : public wxGraphicsObject
{
public:
wxGraphicsMatrix() {}
virtual ~wxGraphicsMatrix() {}
// concatenates the matrix
virtual void Concat( const wxGraphicsMatrix *t );
void Concat( const wxGraphicsMatrix &t ) { Concat( &t ); }
// sets the matrix to the respective values
virtual void Set(wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
wxDouble tx=0.0, wxDouble ty=0.0);
// gets the component valuess of the matrix
virtual void Get(wxDouble* a=NULL, wxDouble* b=NULL, wxDouble* c=NULL,
wxDouble* d=NULL, wxDouble* tx=NULL, wxDouble* ty=NULL) const;
// makes this the inverse matrix
virtual void Invert();
// returns true if the elements of the transformation matrix are equal ?
virtual bool IsEqual( const wxGraphicsMatrix* t) const;
bool IsEqual( const wxGraphicsMatrix& t) const { return IsEqual( &t ); }
// return true if this is the identity matrix
virtual bool IsIdentity() const;
//
// transformation
//
// add the translation to this matrix
virtual void Translate( wxDouble dx , wxDouble dy );
// add the scale to this matrix
virtual void Scale( wxDouble xScale , wxDouble yScale );
// add the rotation to this matrix (radians)
virtual void Rotate( wxDouble angle );
//
// apply the transforms
//
// applies that matrix to the point
virtual void TransformPoint( wxDouble *x, wxDouble *y ) const;
// applies the matrix except for translations
virtual void TransformDistance( wxDouble *dx, wxDouble *dy ) const;
// returns the native representation
virtual void * GetNativeMatrix() const;
const wxGraphicsMatrixData* GetMatrixData() const
{ return (const wxGraphicsMatrixData*) GetRefData(); }
wxGraphicsMatrixData* GetMatrixData()
{ return (wxGraphicsMatrixData*) GetRefData(); }
private:
wxDECLARE_DYNAMIC_CLASS(wxGraphicsMatrix);
};
extern WXDLLIMPEXP_DATA_CORE(wxGraphicsMatrix) wxNullGraphicsMatrix;
class WXDLLIMPEXP_CORE wxGraphicsPath : public wxGraphicsObject
{
public:
wxGraphicsPath() {}
virtual ~wxGraphicsPath() {}
//
// These are the path primitives from which everything else can be constructed
//
// begins a new subpath at (x,y)
virtual void MoveToPoint( wxDouble x, wxDouble y );
void MoveToPoint( const wxPoint2DDouble& p);
// adds a straight line from the current point to (x,y)
virtual void AddLineToPoint( wxDouble x, wxDouble y );
void AddLineToPoint( const wxPoint2DDouble& p);
// adds a cubic Bezier curve from the current point, using two control points and an end point
virtual void AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y );
void AddCurveToPoint( const wxPoint2DDouble& c1, const wxPoint2DDouble& c2, const wxPoint2DDouble& e);
// adds another path
virtual void AddPath( const wxGraphicsPath& path );
// closes the current sub-path
virtual void CloseSubpath();
// gets the last point of the current path, (0,0) if not yet set
virtual void GetCurrentPoint( wxDouble* x, wxDouble* y) const;
wxPoint2DDouble GetCurrentPoint() const;
// adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
virtual void AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise );
void AddArc( const wxPoint2DDouble& c, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise);
//
// These are convenience functions which - if not available natively will be assembled
// using the primitives from above
//
// adds a quadratic Bezier curve from the current point, using a control point and an end point
virtual void AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y );
// appends a rectangle as a new closed subpath
virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
// appends an ellipsis as a new closed subpath fitting the passed rectangle
virtual void AddCircle( wxDouble x, wxDouble y, wxDouble r );
// appends a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1)
virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r );
// appends an ellipse
virtual void AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h);
// appends a rounded rectangle
virtual void AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius);
// returns the native path
virtual void * GetNativePath() const;
// give the native path returned by GetNativePath() back (there might be some deallocations necessary)
virtual void UnGetNativePath(void *p)const;
// transforms each point of this path by the matrix
virtual void Transform( const wxGraphicsMatrix& matrix );
// gets the bounding box enclosing all points (possibly including control points)
virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h)const;
wxRect2DDouble GetBox()const;
virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxODDEVEN_RULE)const;
bool Contains( const wxPoint2DDouble& c, wxPolygonFillMode fillStyle = wxODDEVEN_RULE)const;
const wxGraphicsPathData* GetPathData() const
{ return (const wxGraphicsPathData*) GetRefData(); }
wxGraphicsPathData* GetPathData()
{ return (wxGraphicsPathData*) GetRefData(); }
private:
wxDECLARE_DYNAMIC_CLASS(wxGraphicsPath);
};
extern WXDLLIMPEXP_DATA_CORE(wxGraphicsPath) wxNullGraphicsPath;
// Describes a single gradient stop.
class wxGraphicsGradientStop
{
public:
wxGraphicsGradientStop(wxColour col = wxTransparentColour,
float pos = 0.)
: m_col(col),
m_pos(pos)
{
}
// default copy ctor, assignment operator and dtor are ok
const wxColour& GetColour() const { return m_col; }
void SetColour(const wxColour& col) { m_col = col; }
float GetPosition() const { return m_pos; }
void SetPosition(float pos)
{
wxASSERT_MSG( pos >= 0 && pos <= 1, "invalid gradient stop position" );
m_pos = pos;
}
private:
// The colour of this gradient band.
wxColour m_col;
// Its starting position: 0 is the beginning and 1 is the end.
float m_pos;
};
// A collection of gradient stops ordered by their positions (from lowest to
// highest). The first stop (index 0, position 0.0) is always the starting
// colour and the last one (index GetCount() - 1, position 1.0) is the end
// colour.
class WXDLLIMPEXP_CORE wxGraphicsGradientStops
{
public:
wxGraphicsGradientStops(wxColour startCol = wxTransparentColour,
wxColour endCol = wxTransparentColour)
{
// we can't use Add() here as it relies on having start/end stops as
// first/last array elements so do it manually
m_stops.push_back(wxGraphicsGradientStop(startCol, 0.f));
m_stops.push_back(wxGraphicsGradientStop(endCol, 1.f));
}
// default copy ctor, assignment operator and dtor are ok for this class
// Add a stop in correct order.
void Add(const wxGraphicsGradientStop& stop);
void Add(wxColour col, float pos) { Add(wxGraphicsGradientStop(col, pos)); }
// Get the number of stops.
size_t GetCount() const { return m_stops.size(); }
// Return the stop at the given index (which must be valid).
wxGraphicsGradientStop Item(unsigned n) const { return m_stops.at(n); }
// Get/set start and end colours.
void SetStartColour(wxColour col)
{ m_stops[0].SetColour(col); }
wxColour GetStartColour() const
{ return m_stops[0].GetColour(); }
void SetEndColour(wxColour col)
{ m_stops[m_stops.size() - 1].SetColour(col); }
wxColour GetEndColour() const
{ return m_stops[m_stops.size() - 1].GetColour(); }
private:
// All the stops stored in ascending order of positions.
wxVector<wxGraphicsGradientStop> m_stops;
};
class WXDLLIMPEXP_CORE wxGraphicsContext : public wxGraphicsObject
{
public:
wxGraphicsContext(wxGraphicsRenderer* renderer, wxWindow* window = NULL);
virtual ~wxGraphicsContext();
static wxGraphicsContext* Create( const wxWindowDC& dc);
static wxGraphicsContext * Create( const wxMemoryDC& dc);
#if wxUSE_PRINTING_ARCHITECTURE
static wxGraphicsContext * Create( const wxPrinterDC& dc);
#endif
#ifdef __WXMSW__
#if wxUSE_ENH_METAFILE
static wxGraphicsContext * Create( const wxEnhMetaFileDC& dc);
#endif
#endif
// Create a context from a DC of unknown type, if supported, returns NULL otherwise
static wxGraphicsContext* CreateFromUnknownDC(const wxDC& dc);
static wxGraphicsContext* CreateFromNative( void * context );
static wxGraphicsContext* CreateFromNativeWindow( void * window );
#ifdef __WXMSW__
static wxGraphicsContext* CreateFromNativeHDC(WXHDC dc);
#endif
static wxGraphicsContext* Create( wxWindow* window );
#if wxUSE_IMAGE
// Create a context for drawing onto a wxImage. The image life time must be
// greater than that of the context itself as when the context is destroyed
// it will copy its contents to the specified image.
static wxGraphicsContext* Create(wxImage& image);
#endif // wxUSE_IMAGE
// create a context that can be used for measuring texts only, no drawing allowed
static wxGraphicsContext * Create();
// Return the window this context is associated with, if any.
wxWindow* GetWindow() const { return m_window; }
// begin a new document (relevant only for printing / pdf etc) if there is a progress dialog, message will be shown
virtual bool StartDoc( const wxString& message );
// done with that document (relevant only for printing / pdf etc)
virtual void EndDoc();
// opens a new page (relevant only for printing / pdf etc) with the given size in points
// (if both are null the default page size will be used)
virtual void StartPage( wxDouble width = 0, wxDouble height = 0 );
// ends the current page (relevant only for printing / pdf etc)
virtual void EndPage();
// make sure that the current content of this context is immediately visible
virtual void Flush();
wxGraphicsPath CreatePath() const;
wxGraphicsPen CreatePen(const wxPen& pen) const;
wxGraphicsPen CreatePen(const wxGraphicsPenInfo& info) const
{ return DoCreatePen(info); }
virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) const;
// sets the brush to a linear gradient, starting at (x1,y1) and ending at
// (x2,y2) with the given boundary colours or the specified stops
wxGraphicsBrush
CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
wxDouble x2, wxDouble y2,
const wxColour& c1, const wxColour& c2) const;
wxGraphicsBrush
CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
wxDouble x2, wxDouble y2,
const wxGraphicsGradientStops& stops) const;
// sets the brush to a radial gradient originating at (xo,yc) and ending
// on a circle around (xc,yc) with the given radius; the colours may be
// specified by just the two extremes or the full array of gradient stops
wxGraphicsBrush
CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
wxDouble xc, wxDouble yc, wxDouble radius,
const wxColour& oColor, const wxColour& cColor) const;
wxGraphicsBrush
CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
wxDouble xc, wxDouble yc, wxDouble radius,
const wxGraphicsGradientStops& stops) const;
// creates a font
virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) const;
virtual wxGraphicsFont CreateFont(double sizeInPixels,
const wxString& facename,
int flags = wxFONTFLAG_DEFAULT,
const wxColour& col = *wxBLACK) const;
// create a native bitmap representation
virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap ) const;
#if wxUSE_IMAGE
wxGraphicsBitmap CreateBitmapFromImage(const wxImage& image) const;
#endif // wxUSE_IMAGE
// create a native bitmap representation
virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) const;
// create a 'native' matrix corresponding to these values
virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
wxDouble tx=0.0, wxDouble ty=0.0) const;
wxGraphicsMatrix CreateMatrix( const wxAffineMatrix2DBase& mat ) const
{
wxMatrix2D mat2D;
wxPoint2DDouble tr;
mat.Get(&mat2D, &tr);
return CreateMatrix(mat2D.m_11, mat2D.m_12, mat2D.m_21, mat2D.m_22,
tr.m_x, tr.m_y);
}
// push the current state of the context, ie the transformation matrix on a stack
virtual void PushState() = 0;
// pops a stored state from the stack
virtual void PopState() = 0;
// clips drawings to the region intersected with the current clipping region
virtual void Clip( const wxRegion ®ion ) = 0;
// clips drawings to the rect intersected with the current clipping region
virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h ) = 0;
// resets the clipping to original extent
virtual void ResetClip() = 0;
// returns bounding box of the clipping region
virtual void GetClipBox(wxDouble* x, wxDouble* y, wxDouble* w, wxDouble* h) = 0;
// returns the native context
virtual void * GetNativeContext() = 0;
// returns the current shape antialiasing mode
virtual wxAntialiasMode GetAntialiasMode() const { return m_antialias; }
// sets the antialiasing mode, returns true if it supported
virtual bool SetAntialiasMode(wxAntialiasMode antialias) = 0;
// returns the current interpolation quality
virtual wxInterpolationQuality GetInterpolationQuality() const { return m_interpolation; }
// sets the interpolation quality, returns true if it supported
virtual bool SetInterpolationQuality(wxInterpolationQuality interpolation) = 0;
// returns the current compositing operator
virtual wxCompositionMode GetCompositionMode() const { return m_composition; }
// sets the compositing operator, returns true if it supported
virtual bool SetCompositionMode(wxCompositionMode op) = 0;
// returns the size of the graphics context in device coordinates
void GetSize(wxDouble* width, wxDouble* height) const
{
if ( width )
*width = m_width;
if ( height )
*height = m_height;
}
// returns the resolution of the graphics context in device points per inch
virtual void GetDPI( wxDouble* dpiX, wxDouble* dpiY);
#if 0
// sets the current alpha on this context
virtual void SetAlpha( wxDouble alpha );
// returns the alpha on this context
virtual wxDouble GetAlpha() const;
#endif
// all rendering is done into a fully transparent temporary context
virtual void BeginLayer(wxDouble opacity) = 0;
// composites back the drawings into the context with the opacity given at
// the BeginLayer call
virtual void EndLayer() = 0;
//
// transformation : changes the current transformation matrix CTM of the context
//
// translate
virtual void Translate( wxDouble dx , wxDouble dy ) = 0;
// scale
virtual void Scale( wxDouble xScale , wxDouble yScale ) = 0;
// rotate (radians)
virtual void Rotate( wxDouble angle ) = 0;
// concatenates this transform with the current transform of this context
virtual void ConcatTransform( const wxGraphicsMatrix& matrix ) = 0;
// sets the transform of this context
virtual void SetTransform( const wxGraphicsMatrix& matrix ) = 0;
// gets the matrix of this context
virtual wxGraphicsMatrix GetTransform() const = 0;
//
// setting the paint
//
// sets the pen
virtual void SetPen( const wxGraphicsPen& pen );
void SetPen( const wxPen& pen );
// sets the brush for filling
virtual void SetBrush( const wxGraphicsBrush& brush );
void SetBrush( const wxBrush& brush );
// sets the font
virtual void SetFont( const wxGraphicsFont& font );
void SetFont( const wxFont& font, const wxColour& colour );
// strokes along a path with the current pen
virtual void StrokePath( const wxGraphicsPath& path ) = 0;
// fills a path with the current brush
virtual void FillPath( const wxGraphicsPath& path, wxPolygonFillMode fillStyle = wxODDEVEN_RULE ) = 0;
// draws a path by first filling and then stroking
virtual void DrawPath( const wxGraphicsPath& path, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
// paints a transparent rectangle (only useful for bitmaps or windows)
virtual void ClearRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
//
// text
//
void DrawText( const wxString &str, wxDouble x, wxDouble y )
{ DoDrawText(str, x, y); }
void DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle )
{ DoDrawRotatedText(str, x, y, angle); }
void DrawText( const wxString &str, wxDouble x, wxDouble y,
const wxGraphicsBrush& backgroundBrush )
{ DoDrawFilledText(str, x, y, backgroundBrush); }
void DrawText( const wxString &str, wxDouble x, wxDouble y,
wxDouble angle, const wxGraphicsBrush& backgroundBrush )
{ DoDrawRotatedFilledText(str, x, y, angle, backgroundBrush); }
virtual void GetTextExtent( const wxString &text, wxDouble *width, wxDouble *height,
wxDouble *descent = NULL, wxDouble *externalLeading = NULL ) const = 0;
virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const = 0;
//
// image support
//
virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) = 0;
virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) = 0;
virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) = 0;
//
// convenience methods
//
// strokes a single line
virtual void StrokeLine( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2);
// stroke lines connecting each of the points
virtual void StrokeLines( size_t n, const wxPoint2DDouble *points);
// stroke disconnected lines from begin to end points
virtual void StrokeLines( size_t n, const wxPoint2DDouble *beginPoints, const wxPoint2DDouble *endPoints);
// draws a polygon
virtual void DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
// draws a rectangle
virtual void DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h);
// draws an ellipse
virtual void DrawEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h);
// draws a rounded rectangle
virtual void DrawRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius);
// wrappers using wxPoint2DDouble TODO
// helper to determine if a 0.5 offset should be applied for the drawing operation
virtual bool ShouldOffset() const { return false; }
// indicates whether the context should try to offset for pixel boundaries, this only makes sense on
// bitmap devices like screen, by default this is turned off
virtual void EnableOffset(bool enable = true);
void DisableOffset() { EnableOffset(false); }
bool OffsetEnabled() { return m_enableOffset; }
protected:
// These fields must be initialized in the derived class ctors.
wxDouble m_width,
m_height;
wxGraphicsPen m_pen;
wxGraphicsBrush m_brush;
wxGraphicsFont m_font;
wxAntialiasMode m_antialias;
wxCompositionMode m_composition;
wxInterpolationQuality m_interpolation;
bool m_enableOffset;
protected:
// implementations of overloaded public functions: we use different names
// for them to avoid the virtual function hiding problems in the derived
// classes
virtual wxGraphicsPen DoCreatePen(const wxGraphicsPenInfo& info) const;
virtual void DoDrawText(const wxString& str, wxDouble x, wxDouble y) = 0;
virtual void DoDrawRotatedText(const wxString& str, wxDouble x, wxDouble y,
wxDouble angle);
virtual void DoDrawFilledText(const wxString& str, wxDouble x, wxDouble y,
const wxGraphicsBrush& backgroundBrush);
virtual void DoDrawRotatedFilledText(const wxString& str,
wxDouble x, wxDouble y,
wxDouble angle,
const wxGraphicsBrush& backgroundBrush);
private:
// The associated window, if any, i.e. if one was passed directly to
// Create() or the associated window of the wxDC this context was created
// from.
wxWindow* const m_window;
wxDECLARE_NO_COPY_CLASS(wxGraphicsContext);
wxDECLARE_ABSTRACT_CLASS(wxGraphicsContext);
};
#if 0
//
// A graphics figure allows to cache path, pen etc creations, also will be a basis for layering/grouping elements
//
class WXDLLIMPEXP_CORE wxGraphicsFigure : public wxGraphicsObject
{
public:
wxGraphicsFigure(wxGraphicsRenderer* renderer);
virtual ~wxGraphicsFigure();
void SetPath( wxGraphicsMatrix* matrix );
void SetMatrix( wxGraphicsPath* path);
// draws this object on the context
virtual void Draw( wxGraphicsContext* cg );
// returns the path of this object
wxGraphicsPath* GetPath() { return m_path; }
// returns the transformation matrix of this object, may be null if there is no transformation necessary
wxGraphicsMatrix* GetMatrix() { return m_matrix; }
private:
wxGraphicsMatrix* m_matrix;
wxGraphicsPath* m_path;
wxDECLARE_DYNAMIC_CLASS(wxGraphicsFigure);
};
#endif
//
// The graphics renderer is the instance corresponding to the rendering engine used, eg there is ONE core graphics renderer
// instance on OSX. This instance is pointed back to by all objects created by it. Therefore you can create eg additional
// paths at any point from a given matrix etc.
//
class WXDLLIMPEXP_CORE wxGraphicsRenderer : public wxObject
{
public:
wxGraphicsRenderer() {}
virtual ~wxGraphicsRenderer() {}
static wxGraphicsRenderer* GetDefaultRenderer();
static wxGraphicsRenderer* GetCairoRenderer();
#ifdef __WXMSW__
#if wxUSE_GRAPHICS_GDIPLUS
static wxGraphicsRenderer* GetGDIPlusRenderer();
#endif
#if wxUSE_GRAPHICS_DIRECT2D
static wxGraphicsRenderer* GetDirect2DRenderer();
#endif
#endif
// Context
virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc) = 0;
virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc) = 0;
#if wxUSE_PRINTING_ARCHITECTURE
virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc) = 0;
#endif
#ifdef __WXMSW__
#if wxUSE_ENH_METAFILE
virtual wxGraphicsContext * CreateContext( const wxEnhMetaFileDC& dc) = 0;
#endif
#endif
virtual wxGraphicsContext * CreateContextFromNativeContext( void * context ) = 0;
virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window ) = 0;
#ifdef __WXMSW__
virtual wxGraphicsContext * CreateContextFromNativeHDC(WXHDC dc) = 0;
#endif
virtual wxGraphicsContext * CreateContext( wxWindow* window ) = 0;
#if wxUSE_IMAGE
virtual wxGraphicsContext * CreateContextFromImage(wxImage& image) = 0;
#endif // wxUSE_IMAGE
// create a context that can be used for measuring texts only, no drawing allowed
virtual wxGraphicsContext * CreateMeasuringContext() = 0;
// Path
virtual wxGraphicsPath CreatePath() = 0;
// Matrix
virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
wxDouble tx=0.0, wxDouble ty=0.0) = 0;
// Paints
virtual wxGraphicsPen CreatePen(const wxGraphicsPenInfo& info) = 0;
virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) = 0;
// Gradient brush creation functions may not honour all the stops specified
// stops and use just its boundary colours (this is currently the case
// under OS X)
virtual wxGraphicsBrush
CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
wxDouble x2, wxDouble y2,
const wxGraphicsGradientStops& stops) = 0;
virtual wxGraphicsBrush
CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
wxDouble xc, wxDouble yc,
wxDouble radius,
const wxGraphicsGradientStops& stops) = 0;
// sets the font
virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) = 0;
virtual wxGraphicsFont CreateFont(double sizeInPixels,
const wxString& facename,
int flags = wxFONTFLAG_DEFAULT,
const wxColour& col = *wxBLACK) = 0;
// create a native bitmap representation
virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap ) = 0;
#if wxUSE_IMAGE
virtual wxGraphicsBitmap CreateBitmapFromImage(const wxImage& image) = 0;
virtual wxImage CreateImageFromBitmap(const wxGraphicsBitmap& bmp) = 0;
#endif // wxUSE_IMAGE
// create a graphics bitmap from a native bitmap
virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap ) = 0;
// create a subimage from a native image representation
virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) = 0;
virtual wxString GetName() const = 0;
virtual void
GetVersion(int* major, int* minor = NULL, int* micro = NULL) const = 0;
private:
wxDECLARE_NO_COPY_CLASS(wxGraphicsRenderer);
wxDECLARE_ABSTRACT_CLASS(wxGraphicsRenderer);
};
#if wxUSE_IMAGE
inline
wxImage wxGraphicsBitmap::ConvertToImage() const
{
wxGraphicsRenderer* renderer = GetRenderer();
return renderer ? renderer->CreateImageFromBitmap(*this) : wxNullImage;
}
#endif // wxUSE_IMAGE
#endif // wxUSE_GRAPHICS_CONTEXT
#endif // _WX_GRAPHICS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/dirctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dirctrl.h
// Purpose: Directory control base header
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIRCTRL_H_BASE_
#define _WX_DIRCTRL_H_BASE_
#include "wx/generic/dirctrlg.h"
#endif
// _WX_DIRCTRL_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/cshelp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/cshelp.h
// Purpose: Context-sensitive help support classes
// Author: Julian Smart, Vadim Zeitlin
// Modified by:
// Created: 08/09/2000
// Copyright: (c) 2000 Julian Smart, Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CSHELP_H_
#define _WX_CSHELP_H_
#include "wx/defs.h"
#if wxUSE_HELP
#include "wx/help.h"
#include "wx/hashmap.h"
#if wxUSE_BMPBUTTON
#include "wx/bmpbuttn.h"
#endif
#include "wx/event.h"
// ----------------------------------------------------------------------------
// classes used to implement context help UI
// ----------------------------------------------------------------------------
/*
* wxContextHelp
* Invokes context-sensitive help. When the user
* clicks on a window, a wxEVT_HELP event will be sent to that
* window for the application to display help for.
*/
class WXDLLIMPEXP_CORE wxContextHelp : public wxObject
{
public:
wxContextHelp(wxWindow* win = NULL, bool beginHelp = true);
virtual ~wxContextHelp();
bool BeginContextHelp(wxWindow* win);
bool EndContextHelp();
bool EventLoop();
bool DispatchEvent(wxWindow* win, const wxPoint& pt);
void SetStatus(bool status) { m_status = status; }
protected:
bool m_inHelp;
bool m_status; // true if the user left-clicked
private:
wxDECLARE_DYNAMIC_CLASS(wxContextHelp);
};
#if wxUSE_BMPBUTTON
/*
* wxContextHelpButton
* You can add this to your dialogs (especially on non-Windows platforms)
* to put the application into context help mode.
*/
class WXDLLIMPEXP_CORE wxContextHelpButton : public wxBitmapButton
{
public:
wxContextHelpButton() {}
wxContextHelpButton(wxWindow* parent,
wxWindowID id = wxID_CONTEXT_HELP,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0)
{
Create(parent, id, pos, size, style);
}
bool Create(wxWindow* parent,
wxWindowID id = wxID_CONTEXT_HELP,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
void OnContextHelp(wxCommandEvent& event);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxContextHelpButton);
wxDECLARE_EVENT_TABLE();
};
#endif
// ----------------------------------------------------------------------------
// classes used to implement context help support
// ----------------------------------------------------------------------------
// wxHelpProvider is an abstract class used by the program implementing context help to
// show the help text (or whatever: it may be HTML page or anything else) for
// the given window.
//
// The current help provider must be explicitly set by the application using
// wxHelpProvider::Set().
//
// Special note about ShowHelpAtPoint() and ShowHelp(): we want to be able to
// override ShowHelpAtPoint() when we need to use different help messages for
// different parts of the window, but it should also be possible to override
// just ShowHelp() both for backwards compatibility and just because most
// often the help does not, in fact, depend on the position and so
// implementing just ShowHelp() is simpler and more natural, so by default
// ShowHelpAtPoint() forwards to ShowHelp(). But this means that
// wxSimpleHelpProvider has to override ShowHelp() and not ShowHelpAtPoint()
// for backwards compatibility as otherwise the existing code deriving from it
// and overriding ShowHelp() but calling the base class version wouldn't work
// any more, which forces us to use a rather ugly hack and pass the extra
// parameters of ShowHelpAtPoint() to ShowHelp() via member variables.
class WXDLLIMPEXP_CORE wxHelpProvider
{
public:
// get/set the current (application-global) help provider (Set() returns
// the previous one)
static wxHelpProvider *Set(wxHelpProvider *helpProvider)
{
wxHelpProvider *helpProviderOld = ms_helpProvider;
ms_helpProvider = helpProvider;
return helpProviderOld;
}
// unlike some other class, the help provider is not created on demand,
// this must be explicitly done by the application
static wxHelpProvider *Get() { return ms_helpProvider; }
// get the help string (whose interpretation is help provider dependent
// except that empty string always means that no help is associated with
// the window) for this window
virtual wxString GetHelp(const wxWindowBase *window) = 0;
// do show help for the given window (uses window->GetHelpAtPoint()
// internally if applicable), return true if it was done or false
// if no help available for this window
virtual bool ShowHelpAtPoint(wxWindowBase *window,
const wxPoint& pt,
wxHelpEvent::Origin origin)
{
wxCHECK_MSG( window, false, wxT("window must not be NULL") );
m_helptextAtPoint = pt;
m_helptextOrigin = origin;
return ShowHelp(window);
}
// show help for the given window, see ShowHelpAtPoint() above
virtual bool ShowHelp(wxWindowBase * WXUNUSED(window)) { return false; }
// associate the text with the given window or id: although all help
// providers have these functions to allow making wxWindow::SetHelpText()
// work, not all of them implement them
virtual void AddHelp(wxWindowBase *window, const wxString& text);
// this version associates the given text with all window with this id
// (may be used to set the same help string for all [Cancel] buttons in
// the application, for example)
virtual void AddHelp(wxWindowID id, const wxString& text);
// removes the association
virtual void RemoveHelp(wxWindowBase* window);
// virtual dtor for any base class
virtual ~wxHelpProvider();
protected:
wxHelpProvider()
: m_helptextAtPoint(wxDefaultPosition),
m_helptextOrigin(wxHelpEvent::Origin_Unknown)
{
}
// helper method used by ShowHelp(): returns the help string to use by
// using m_helptextAtPoint/m_helptextOrigin if they're set or just GetHelp
// otherwise
wxString GetHelpTextMaybeAtPoint(wxWindowBase *window);
// parameters of the last ShowHelpAtPoint() call, used by ShowHelp()
wxPoint m_helptextAtPoint;
wxHelpEvent::Origin m_helptextOrigin;
private:
static wxHelpProvider *ms_helpProvider;
};
WX_DECLARE_EXPORTED_HASH_MAP( wxUIntPtr, wxString, wxIntegerHash,
wxIntegerEqual, wxSimpleHelpProviderHashMap );
// wxSimpleHelpProvider is an implementation of wxHelpProvider which supports
// only plain text help strings and shows the string associated with the
// control (if any) in a tooltip
class WXDLLIMPEXP_CORE wxSimpleHelpProvider : public wxHelpProvider
{
public:
// implement wxHelpProvider methods
virtual wxString GetHelp(const wxWindowBase *window) wxOVERRIDE;
// override ShowHelp() and not ShowHelpAtPoint() as explained above
virtual bool ShowHelp(wxWindowBase *window) wxOVERRIDE;
virtual void AddHelp(wxWindowBase *window, const wxString& text) wxOVERRIDE;
virtual void AddHelp(wxWindowID id, const wxString& text) wxOVERRIDE;
virtual void RemoveHelp(wxWindowBase* window) wxOVERRIDE;
protected:
// we use 2 hashes for storing the help strings associated with windows
// and the ids
wxSimpleHelpProviderHashMap m_hashWindows,
m_hashIds;
};
// wxHelpControllerHelpProvider is an implementation of wxHelpProvider which supports
// both context identifiers and plain text help strings. If the help text is an integer,
// it is passed to wxHelpController::DisplayContextPopup. Otherwise, it shows the string
// in a tooltip as per wxSimpleHelpProvider.
class WXDLLIMPEXP_CORE wxHelpControllerHelpProvider : public wxSimpleHelpProvider
{
public:
// Note that it doesn't own the help controller. The help controller
// should be deleted separately.
wxHelpControllerHelpProvider(wxHelpControllerBase* hc = NULL);
// implement wxHelpProvider methods
// again (see above): this should be ShowHelpAtPoint() but we need to
// override ShowHelp() to avoid breaking existing code
virtual bool ShowHelp(wxWindowBase *window) wxOVERRIDE;
// Other accessors
void SetHelpController(wxHelpControllerBase* hc) { m_helpController = hc; }
wxHelpControllerBase* GetHelpController() const { return m_helpController; }
protected:
wxHelpControllerBase* m_helpController;
wxDECLARE_NO_COPY_CLASS(wxHelpControllerHelpProvider);
};
// Convenience function for turning context id into wxString
WXDLLIMPEXP_CORE wxString wxContextId(int id);
#endif // wxUSE_HELP
#endif // _WX_CSHELP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/sckipc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/sckipc.h
// Purpose: Interprocess communication implementation (wxSocket version)
// Author: Julian Smart
// Modified by: Guilhem Lavaux (big rewrite) May 1997, 1998
// Guillermo Rodriguez (updated for wxSocket v2) Jan 2000
// (callbacks deprecated) Mar 2000
// Created: 1993
// Copyright: (c) Julian Smart 1993
// (c) Guilhem Lavaux 1997, 1998
// (c) 2000 Guillermo Rodriguez <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SCKIPC_H
#define _WX_SCKIPC_H
#include "wx/defs.h"
#if wxUSE_SOCKETS && wxUSE_IPC
#include "wx/ipcbase.h"
#include "wx/socket.h"
#include "wx/sckstrm.h"
#include "wx/datstrm.h"
/*
* Mini-DDE implementation
Most transactions involve a topic name and an item name (choose these
as befits your application).
A client can:
- ask the server to execute commands (data) associated with a topic
- request data from server by topic and item
- poke data into the server
- ask the server to start an advice loop on topic/item
- ask the server to stop an advice loop
A server can:
- respond to execute, request, poke and advice start/stop
- send advise data to client
Note that this limits the server in the ways it can send data to the
client, i.e. it can't send unsolicited information.
*
*/
class WXDLLIMPEXP_FWD_NET wxTCPServer;
class WXDLLIMPEXP_FWD_NET wxTCPClient;
class wxIPCSocketStreams;
class WXDLLIMPEXP_NET wxTCPConnection : public wxConnectionBase
{
public:
wxTCPConnection() { Init(); }
wxTCPConnection(void *buffer, size_t size)
: wxConnectionBase(buffer, size)
{
Init();
}
virtual ~wxTCPConnection();
// implement base class pure virtual methods
virtual const void *Request(const wxString& item,
size_t *size = NULL,
wxIPCFormat format = wxIPC_TEXT) wxOVERRIDE;
virtual bool StartAdvise(const wxString& item) wxOVERRIDE;
virtual bool StopAdvise(const wxString& item) wxOVERRIDE;
virtual bool Disconnect(void) wxOVERRIDE;
// Will be used in the future to enable the compression but does nothing
// for now.
void Compress(bool on);
protected:
virtual bool DoExecute(const void *data, size_t size, wxIPCFormat format) wxOVERRIDE;
virtual bool DoPoke(const wxString& item, const void *data, size_t size,
wxIPCFormat format) wxOVERRIDE;
virtual bool DoAdvise(const wxString& item, const void *data, size_t size,
wxIPCFormat format) wxOVERRIDE;
// notice that all the members below are only initialized once the
// connection is made, i.e. in MakeConnection() for the client objects and
// after OnAcceptConnection() in the server ones
// the underlying socket (wxSocketClient for IPC client and wxSocketServer
// for IPC server)
wxSocketBase *m_sock;
// various streams that we use
wxIPCSocketStreams *m_streams;
// the topic of this connection
wxString m_topic;
private:
// common part of both ctors
void Init();
friend class wxTCPServer;
friend class wxTCPClient;
friend class wxTCPEventHandler;
wxDECLARE_NO_COPY_CLASS(wxTCPConnection);
wxDECLARE_DYNAMIC_CLASS(wxTCPConnection);
};
class WXDLLIMPEXP_NET wxTCPServer : public wxServerBase
{
public:
wxTCPServer();
virtual ~wxTCPServer();
// Returns false on error (e.g. port number is already in use)
virtual bool Create(const wxString& serverName) wxOVERRIDE;
virtual wxConnectionBase *OnAcceptConnection(const wxString& topic) wxOVERRIDE;
protected:
wxSocketServer *m_server;
#ifdef __UNIX_LIKE__
// the name of the file associated to the Unix domain socket, may be empty
wxString m_filename;
#endif // __UNIX_LIKE__
wxDECLARE_NO_COPY_CLASS(wxTCPServer);
wxDECLARE_DYNAMIC_CLASS(wxTCPServer);
};
class WXDLLIMPEXP_NET wxTCPClient : public wxClientBase
{
public:
wxTCPClient();
virtual bool ValidHost(const wxString& host) wxOVERRIDE;
// Call this to make a connection. Returns NULL if cannot.
virtual wxConnectionBase *MakeConnection(const wxString& host,
const wxString& server,
const wxString& topic) wxOVERRIDE;
// Callbacks to CLIENT - override at will
virtual wxConnectionBase *OnMakeConnection() wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxTCPClient);
};
#endif // wxUSE_SOCKETS && wxUSE_IPC
#endif // _WX_SCKIPC_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/iconbndl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/iconbndl.h
// Purpose: wxIconBundle
// Author: Mattia barbon
// Modified by:
// Created: 23.03.02
// Copyright: (c) Mattia Barbon
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ICONBNDL_H_
#define _WX_ICONBNDL_H_
#include "wx/gdiobj.h"
#include "wx/gdicmn.h" // for wxSize
#include "wx/icon.h"
#include "wx/dynarray.h"
class WXDLLIMPEXP_FWD_BASE wxInputStream;
WX_DECLARE_EXPORTED_OBJARRAY(wxIcon, wxIconArray);
// Load icons of multiple sizes from files or resources (MSW-only).
class WXDLLIMPEXP_CORE wxIconBundle : public wxGDIObject
{
public:
// Flags that determine what happens if GetIcon() doesn't find the icon of
// exactly the requested size.
enum
{
// Return invalid icon if exact size is not found.
FALLBACK_NONE = 0,
// Return the icon of the system icon size if exact size is not found.
// May be combined with other non-NONE enum elements to determine what
// happens if the system icon size is not found neither.
FALLBACK_SYSTEM = 1,
// Return the icon of closest larger size or, if there is no icon of
// larger size in the bundle, the closest icon of smaller size.
FALLBACK_NEAREST_LARGER = 2
};
// default constructor
wxIconBundle();
// initializes the bundle with the icon(s) found in the file
#if wxUSE_STREAMS && wxUSE_IMAGE
#if wxUSE_FFILE || wxUSE_FILE
wxIconBundle(const wxString& file, wxBitmapType type = wxBITMAP_TYPE_ANY);
#endif // wxUSE_FFILE || wxUSE_FILE
wxIconBundle(wxInputStream& stream, wxBitmapType type = wxBITMAP_TYPE_ANY);
#endif // wxUSE_STREAMS && wxUSE_IMAGE
// initializes the bundle with a single icon
wxIconBundle(const wxIcon& icon);
#if defined(__WINDOWS__) && wxUSE_ICO_CUR
// initializes the bundle with the icons from a group icon stored as an MS Windows resource
wxIconBundle(const wxString& resourceName, WXHINSTANCE module);
#endif
// default copy ctor and assignment operator are OK
// adds all the icons contained in the file to the collection,
// if the collection already contains icons with the same
// width and height, they are replaced
#if wxUSE_STREAMS && wxUSE_IMAGE
#if wxUSE_FFILE || wxUSE_FILE
void AddIcon(const wxString& file, wxBitmapType type = wxBITMAP_TYPE_ANY);
#endif // wxUSE_FFILE || wxUSE_FILE
void AddIcon(wxInputStream& stream, wxBitmapType type = wxBITMAP_TYPE_ANY);
#endif // wxUSE_STREAMS && wxUSE_IMAGE
#if defined(__WINDOWS__) && wxUSE_ICO_CUR
// loads all the icons from a group icon stored in an MS Windows resource
void AddIcon(const wxString& resourceName, WXHINSTANCE module);
#endif
// adds the icon to the collection, if the collection already
// contains an icon with the same width and height, it is
// replaced
void AddIcon(const wxIcon& icon);
// returns the icon with the given size; if no such icon exists,
// behavior is specified by the flags.
wxIcon GetIcon(const wxSize& size, int flags = FALLBACK_SYSTEM) const;
// equivalent to GetIcon(wxSize(size, size))
wxIcon GetIcon(wxCoord size = wxDefaultCoord,
int flags = FALLBACK_SYSTEM) const
{ return GetIcon(wxSize(size, size), flags); }
// returns the icon exactly of the specified size or wxNullIcon if no icon
// of exactly given size are available
wxIcon GetIconOfExactSize(const wxSize& size) const;
wxIcon GetIconOfExactSize(wxCoord size) const
{ return GetIconOfExactSize(wxSize(size, size)); }
// enumerate all icons in the bundle: don't use these functions if ti can
// be avoided, using GetIcon() directly is better
// return the number of available icons
size_t GetIconCount() const;
// return the icon at index (must be < GetIconCount())
wxIcon GetIconByIndex(size_t n) const;
// check if we have any icons at all
bool IsEmpty() const { return GetIconCount() == 0; }
#if WXWIN_COMPATIBILITY_2_8
#if wxUSE_STREAMS && wxUSE_IMAGE && (wxUSE_FFILE || wxUSE_FILE)
wxDEPRECATED( void AddIcon(const wxString& file, long type)
{
AddIcon(file, (wxBitmapType)type);
}
)
wxDEPRECATED_CONSTRUCTOR( wxIconBundle (const wxString& file, long type)
{
AddIcon(file, (wxBitmapType)type);
}
)
#endif // wxUSE_STREAMS && wxUSE_IMAGE && (wxUSE_FFILE || wxUSE_FILE)
#endif // WXWIN_COMPATIBILITY_2_8
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
// delete all icons
void DeleteIcons();
wxDECLARE_DYNAMIC_CLASS(wxIconBundle);
};
#endif // _WX_ICONBNDL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/toplevel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/toplevel.h
// Purpose: declares wxTopLevelWindow class, the base class for all
// top level windows (such as frames and dialogs)
// Author: Vadim Zeitlin, Vaclav Slavik
// Modified by:
// Created: 06.08.01
// Copyright: (c) 2001 Vadim Zeitlin <[email protected]>
// Vaclav Slavik <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOPLEVEL_BASE_H_
#define _WX_TOPLEVEL_BASE_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/nonownedwnd.h"
#include "wx/iconbndl.h"
#include "wx/weakref.h"
// the default names for various classes
extern WXDLLIMPEXP_DATA_CORE(const char) wxFrameNameStr[];
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
/*
Summary of the bits used (some of them are defined in wx/frame.h and
wx/dialog.h and not here):
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|15|14|13|12|11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | \_ wxCENTRE
| | | | | | | | | | | | | | \____ wxFRAME_NO_TASKBAR
| | | | | | | | | | | | | \_______ wxFRAME_TOOL_WINDOW
| | | | | | | | | | | | \__________ wxFRAME_FLOAT_ON_PARENT
| | | | | | | | | | | \_____________ wxFRAME_SHAPED
| | | | | | | | | | \________________ wxDIALOG_NO_PARENT
| | | | | | | | | \___________________ wxRESIZE_BORDER
| | | | | | | | \______________________ wxTINY_CAPTION_VERT
| | | | | | | \_________________________
| | | | | | \____________________________ wxMAXIMIZE_BOX
| | | | | \_______________________________ wxMINIMIZE_BOX
| | | | \__________________________________ wxSYSTEM_MENU
| | | \_____________________________________ wxCLOSE_BOX
| | \________________________________________ wxMAXIMIZE
| \___________________________________________ wxMINIMIZE
\______________________________________________ wxSTAY_ON_TOP
Notice that the 8 lower bits overlap with wxCENTRE and the button selection
bits (wxYES, wxOK wxNO, wxCANCEL, wxAPPLY, wxCLOSE and wxNO_DEFAULT) which
can be combined with the dialog style for several standard dialogs and
hence shouldn't overlap with any styles which can be used for the dialogs.
Additionally, wxCENTRE can be used with frames also.
*/
// style common to both wxFrame and wxDialog
#define wxSTAY_ON_TOP 0x8000
#define wxICONIZE 0x4000
#define wxMINIMIZE wxICONIZE
#define wxMAXIMIZE 0x2000
#define wxCLOSE_BOX 0x1000 // == wxHELP so can't be used with it
#define wxSYSTEM_MENU 0x0800
#define wxMINIMIZE_BOX 0x0400
#define wxMAXIMIZE_BOX 0x0200
#define wxTINY_CAPTION 0x0080 // clashes with wxNO_DEFAULT
#define wxRESIZE_BORDER 0x0040 // == wxCLOSE
#if WXWIN_COMPATIBILITY_2_8
// HORIZ and VERT styles are equivalent anyhow so don't use different names
// for them
#define wxTINY_CAPTION_HORIZ wxTINY_CAPTION
#define wxTINY_CAPTION_VERT wxTINY_CAPTION
#endif
// default style
#define wxDEFAULT_FRAME_STYLE \
(wxSYSTEM_MENU | \
wxRESIZE_BORDER | \
wxMINIMIZE_BOX | \
wxMAXIMIZE_BOX | \
wxCLOSE_BOX | \
wxCAPTION | \
wxCLIP_CHILDREN)
// Dialogs are created in a special way
#define wxTOPLEVEL_EX_DIALOG 0x00000008
// Styles for ShowFullScreen
// (note that wxTopLevelWindow only handles wxFULLSCREEN_NOBORDER and
// wxFULLSCREEN_NOCAPTION; the rest is handled by wxTopLevelWindow)
enum
{
wxFULLSCREEN_NOMENUBAR = 0x0001,
wxFULLSCREEN_NOTOOLBAR = 0x0002,
wxFULLSCREEN_NOSTATUSBAR = 0x0004,
wxFULLSCREEN_NOBORDER = 0x0008,
wxFULLSCREEN_NOCAPTION = 0x0010,
wxFULLSCREEN_ALL = wxFULLSCREEN_NOMENUBAR | wxFULLSCREEN_NOTOOLBAR |
wxFULLSCREEN_NOSTATUSBAR | wxFULLSCREEN_NOBORDER |
wxFULLSCREEN_NOCAPTION
};
// Styles for RequestUserAttention
enum
{
wxUSER_ATTENTION_INFO = 1,
wxUSER_ATTENTION_ERROR = 2
};
// ----------------------------------------------------------------------------
// wxTopLevelWindow: a top level (as opposed to child) window
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindowBase : public wxNonOwnedWindow
{
public:
// construction
wxTopLevelWindowBase();
virtual ~wxTopLevelWindowBase();
// top level wnd state
// --------------------
// maximize = true => maximize, otherwise - restore
virtual void Maximize(bool maximize = true) = 0;
// undo Maximize() or Iconize()
virtual void Restore() = 0;
// iconize = true => iconize, otherwise - restore
virtual void Iconize(bool iconize = true) = 0;
// return true if the frame is maximized
virtual bool IsMaximized() const = 0;
// return true if the frame is always maximized
// due to native guidelines or current policy
virtual bool IsAlwaysMaximized() const;
// return true if the frame is iconized
virtual bool IsIconized() const = 0;
// get the frame icon
wxIcon GetIcon() const;
// get the frame icons
const wxIconBundle& GetIcons() const { return m_icons; }
// set the frame icon: implemented in terms of SetIcons()
void SetIcon(const wxIcon& icon);
// set the frame icons
virtual void SetIcons(const wxIconBundle& icons) { m_icons = icons; }
virtual bool EnableFullScreenView(bool WXUNUSED(enable) = true)
{
return false;
}
// maximize the window to cover entire screen
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) = 0;
// shows the window, but doesn't activate it. If the base code is being run,
// it means the port doesn't implement this method yet and so alert the user.
virtual void ShowWithoutActivating() {
wxFAIL_MSG("ShowWithoutActivating not implemented on this platform.");
}
// return true if the frame is in fullscreen mode
virtual bool IsFullScreen() const = 0;
// the title of the top level window: the text which the
// window shows usually at the top of the frame/dialog in dedicated bar
virtual void SetTitle(const wxString& title) = 0;
virtual wxString GetTitle() const = 0;
// enable/disable close button [x]
virtual bool EnableCloseButton(bool WXUNUSED(enable) = true) { return false; }
virtual bool EnableMaximizeButton(bool WXUNUSED(enable) = true) { return false; }
virtual bool EnableMinimizeButton(bool WXUNUSED(enable) = true) { return false; }
// Attracts the users attention to this window if the application is
// inactive (should be called when a background event occurs)
virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO);
// Is this the active frame (highlighted in the taskbar)?
//
// A TLW is active only if it contains the currently focused window.
virtual bool IsActive() { return IsDescendant(FindFocus()); }
// this function may be overridden to return false to allow closing the
// application even when this top level window is still open
//
// notice that the window is still closed prior to the application exit and
// so it can still veto it even if it returns false from here
virtual bool ShouldPreventAppExit() const { return true; }
// centre the window on screen: this is just a shortcut
void CentreOnScreen(int dir = wxBOTH) { DoCentre(dir | wxCENTRE_ON_SCREEN); }
void CenterOnScreen(int dir = wxBOTH) { CentreOnScreen(dir); }
// Get the default size for a new top level window. This is used when
// creating a wxTLW under some platforms if no explicit size given.
static wxSize GetDefaultSize();
// default item access: we have a permanent default item which is the one
// set by the user code but we may also have a temporary default item which
// would be chosen if the user pressed "Enter" now but the default action
// reverts to the "permanent" default as soon as this temporary default
// item loses focus
// get the default item, temporary or permanent
wxWindow *GetDefaultItem() const
{ return m_winTmpDefault ? m_winTmpDefault : m_winDefault; }
// set the permanent default item, return the old default
wxWindow *SetDefaultItem(wxWindow *win)
{ wxWindow *old = GetDefaultItem(); m_winDefault = win; return old; }
// return the temporary default item, can be NULL
wxWindow *GetTmpDefaultItem() const { return m_winTmpDefault; }
// set a temporary default item, SetTmpDefaultItem(NULL) should be called
// soon after a call to SetTmpDefaultItem(window), return the old default
wxWindow *SetTmpDefaultItem(wxWindow *win)
{ wxWindow *old = GetDefaultItem(); m_winTmpDefault = win; return old; }
// Class for saving/restoring fields describing the window geometry.
//
// This class is used by the functions below to allow saving the geometry
// of the window and restoring it later. The components describing geometry
// are platform-dependent, so there is no struct containing them and
// instead the methods of this class are used to save or [try to] restore
// whichever components are used under the current platform.
class GeometrySerializer
{
public:
virtual ~GeometrySerializer() {}
// If saving a field returns false, it's fatal error and SaveGeometry()
// will return false.
virtual bool SaveField(const wxString& name, int value) const = 0;
// If restoring a field returns false, it just means that the field is
// not present and RestoreToGeometry() still continues with restoring
// the other values.
virtual bool RestoreField(const wxString& name, int* value) = 0;
};
// Save the current window geometry using the provided serializer and
// restore the window to the previously saved geometry.
bool SaveGeometry(const GeometrySerializer& ser) const;
bool RestoreToGeometry(GeometrySerializer& ser);
// implementation only from now on
// -------------------------------
// override some base class virtuals
virtual bool Destroy() wxOVERRIDE;
virtual bool IsTopLevel() const wxOVERRIDE { return true; }
virtual bool IsTopNavigationDomain(NavigationKind kind) const wxOVERRIDE;
virtual bool IsVisible() const { return IsShown(); }
// event handlers
void OnCloseWindow(wxCloseEvent& event);
void OnSize(wxSizeEvent& WXUNUSED(event)) { DoLayout(); }
// Get rect to be used to center top-level children
virtual void GetRectForTopLevelChildren(int *x, int *y, int *w, int *h);
// this should go away, but for now it's called from docview.cpp,
// so should be there for all platforms
void OnActivate(wxActivateEvent &WXUNUSED(event)) { }
// do the window-specific processing after processing the update event
virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) wxOVERRIDE ;
// a different API for SetSizeHints
virtual void SetMinSize(const wxSize& minSize) wxOVERRIDE;
virtual void SetMaxSize(const wxSize& maxSize) wxOVERRIDE;
virtual void OSXSetModified(bool modified) { m_modified = modified; }
virtual bool OSXIsModified() const { return m_modified; }
virtual void SetRepresentedFilename(const wxString& WXUNUSED(filename)) { }
protected:
// the frame client to screen translation should take account of the
// toolbar which may shift the origin of the client area
virtual void DoClientToScreen(int *x, int *y) const wxOVERRIDE;
virtual void DoScreenToClient(int *x, int *y) const wxOVERRIDE;
// add support for wxCENTRE_ON_SCREEN
virtual void DoCentre(int dir) wxOVERRIDE;
// no need to do client to screen translation to get our position in screen
// coordinates: this is already the case
virtual void DoGetScreenPosition(int *x, int *y) const wxOVERRIDE
{
DoGetPosition(x, y);
}
// test whether this window makes part of the frame
// (menubar, toolbar and statusbar are excluded from automatic layout)
virtual bool IsOneOfBars(const wxWindow *WXUNUSED(win)) const
{ return false; }
// check if we should exit the program after deleting this window
bool IsLastBeforeExit() const;
// send the iconize event, return true if processed
bool SendIconizeEvent(bool iconized = true);
// do TLW-specific layout: we resize our unique child to fill the entire
// client area
void DoLayout();
static int WidthDefault(int w) { return w == wxDefaultCoord ? GetDefaultSize().x : w; }
static int HeightDefault(int h) { return h == wxDefaultCoord ? GetDefaultSize().y : h; }
// the frame icon
wxIconBundle m_icons;
// a default window (usually a button) or NULL
wxWindowRef m_winDefault;
// a temporary override of m_winDefault, use the latter if NULL
wxWindowRef m_winTmpDefault;
bool m_modified;
wxDECLARE_NO_COPY_CLASS(wxTopLevelWindowBase);
wxDECLARE_EVENT_TABLE();
};
// include the real class declaration
#if defined(__WXMSW__)
#include "wx/msw/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowMSW
#elif defined(__WXGTK20__)
#include "wx/gtk/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowGTK
#elif defined(__WXGTK__)
#include "wx/gtk1/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowGTK
#elif defined(__WXX11__)
#include "wx/x11/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowX11
#elif defined(__WXDFB__)
#include "wx/dfb/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowDFB
#elif defined(__WXMAC__)
#include "wx/osx/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowMac
#elif defined(__WXMOTIF__)
#include "wx/motif/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowMotif
#elif defined(__WXQT__)
#include "wx/qt/toplevel.h"
#define wxTopLevelWindowNative wxTopLevelWindowQt
#endif
#ifdef __WXUNIVERSAL__
#include "wx/univ/toplevel.h"
#else // !__WXUNIVERSAL__
class WXDLLIMPEXP_CORE wxTopLevelWindow : public wxTopLevelWindowNative
{
public:
// construction
wxTopLevelWindow() { }
wxTopLevelWindow(wxWindow *parent,
wxWindowID winid,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
: wxTopLevelWindowNative(parent, winid, title,
pos, size, style, name)
{
}
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTopLevelWindow);
};
#endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
#endif // _WX_TOPLEVEL_BASE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/build.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/build.h
// Purpose: Runtime build options checking
// Author: Vadim Zeitlin, Vaclav Slavik
// Modified by:
// Created: 07.05.02
// Copyright: (c) 2002 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BUILD_H_
#define _WX_BUILD_H_
#include "wx/version.h"
// NB: This file contains macros for checking binary compatibility of libraries
// in multilib builds, plugins and user components.
// The WX_BUILD_OPTIONS_SIGNATURE macro expands into string that should
// uniquely identify binary compatible builds: i.e. if two builds of the
// library are binary compatible, their signature string should be the
// same; if two builds are binary incompatible, their signatures should
// be different.
//
// Therefore, wxUSE_XXX flags that affect binary compatibility (vtables,
// function signatures) should be accounted for here. So should compilers
// and compiler versions (but note that binary compatible compiler versions
// such as gcc-2.95.2 and gcc-2.95.3 should have same signature!).
// ----------------------------------------------------------------------------
// WX_BUILD_OPTIONS_SIGNATURE
// ----------------------------------------------------------------------------
#define __WX_BO_STRINGIZE(x) __WX_BO_STRINGIZE0(x)
#define __WX_BO_STRINGIZE0(x) #x
#if (wxMINOR_VERSION % 2) == 0
#define __WX_BO_VERSION(x,y,z) \
__WX_BO_STRINGIZE(x) "." __WX_BO_STRINGIZE(y)
#else
#define __WX_BO_VERSION(x,y,z) \
__WX_BO_STRINGIZE(x) "." __WX_BO_STRINGIZE(y) "." __WX_BO_STRINGIZE(z)
#endif
#if wxUSE_UNICODE_UTF8
#define __WX_BO_UNICODE "UTF-8"
#elif wxUSE_UNICODE_WCHAR
#define __WX_BO_UNICODE "wchar_t"
#else
#define __WX_BO_UNICODE "ANSI"
#endif
// GCC and Intel C++ share same C++ ABI (and possibly others in the future),
// check if compiler versions are compatible:
#if defined(__GXX_ABI_VERSION)
// All the changes since ABI version 1002 so far have been insignificant,
// so just check for this value, first used for g++ 3.4 and used by default
// by all g++ 4 versions, as checking for the exact ABI version simply
// results in run-time breakage whenever a new gcc version is released,
// even if there are no real problems.
#if __GXX_ABI_VERSION >= 1002
#define __WX_BO_COMPILER \
",compiler with C++ ABI compatible with gcc 4"
#else
#define __WX_BO_COMPILER \
",compiler with C++ ABI " __WX_BO_STRINGIZE(__GXX_ABI_VERSION)
#endif
#elif defined(__GNUG__)
#define __WX_BO_COMPILER ",GCC " \
__WX_BO_STRINGIZE(__GNUC__) "." __WX_BO_STRINGIZE(__GNUC_MINOR__)
#elif defined(__VISUALC__)
// VC15 (a.k.a. MSVS 2017) is ABI-compatible with VC14 (MSVS 2015), so use
// the same ABI version for both of them.
#if _MSC_VER >= 1900 && _MSC_VER < 2000
#define wxMSVC_ABI_VERSION 1900
#else
#define wxMSVC_ABI_VERSION _MSC_VER
#endif
#define __WX_BO_COMPILER ",Visual C++ " __WX_BO_STRINGIZE(wxMSVC_ABI_VERSION)
#elif defined(__INTEL_COMPILER)
// Notice that this must come after MSVC check as ICC under Windows is
// ABI-compatible with the corresponding version of the MSVC and we want to
// allow using it compile the application code using MSVC-built DLLs.
#define __WX_BO_COMPILER ",Intel C++"
#elif defined(__BORLANDC__)
#define __WX_BO_COMPILER ",Borland C++"
#else
#define __WX_BO_COMPILER
#endif
// WXWIN_COMPATIBILITY macros affect presence of virtual functions
#if WXWIN_COMPATIBILITY_2_8
#define __WX_BO_WXWIN_COMPAT_2_8 ",compatible with 2.8"
#else
#define __WX_BO_WXWIN_COMPAT_2_8
#endif
#if WXWIN_COMPATIBILITY_3_0
#define __WX_BO_WXWIN_COMPAT_3_0 ",compatible with 3.0"
#else
#define __WX_BO_WXWIN_COMPAT_3_0
#endif
// deriving wxWin containers from STL ones changes them completely:
#if wxUSE_STD_CONTAINERS
#define __WX_BO_STL ",STL containers"
#else
#define __WX_BO_STL ",wx containers"
#endif
// This macro is passed as argument to wxAppConsole::CheckBuildOptions()
#define WX_BUILD_OPTIONS_SIGNATURE \
__WX_BO_VERSION(wxMAJOR_VERSION, wxMINOR_VERSION, wxRELEASE_NUMBER) \
" (" __WX_BO_UNICODE \
__WX_BO_COMPILER \
__WX_BO_STL \
__WX_BO_WXWIN_COMPAT_2_8 __WX_BO_WXWIN_COMPAT_3_0 \
")"
// ----------------------------------------------------------------------------
// WX_CHECK_BUILD_OPTIONS
// ----------------------------------------------------------------------------
// Use this macro to check build options. Adding it to a file in DLL will
// ensure that the DLL checks build options in same way wxIMPLEMENT_APP() does.
#define WX_CHECK_BUILD_OPTIONS(libName) \
static struct wxBuildOptionsChecker \
{ \
wxBuildOptionsChecker() \
{ \
wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
libName); \
} \
} gs_buildOptionsCheck;
#endif // _WX_BUILD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/sound.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/sound.h
// Purpose: wxSoundBase class
// Author: Vaclav Slavik
// Modified by:
// Created: 2004/02/01
// Copyright: (c) 2004, Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SOUND_H_BASE_
#define _WX_SOUND_H_BASE_
#include "wx/defs.h"
#if wxUSE_SOUND
#include "wx/object.h"
// ----------------------------------------------------------------------------
// wxSoundBase: common wxSound code and interface
// ----------------------------------------------------------------------------
// Flags for wxSound::Play
// NB: We can't use enum with some compilers, because they keep reporting
// nonexistent ambiguities between Play(unsigned) and static Play(const
// wxString&, unsigned).
#define wxSOUND_SYNC ((unsigned)0)
#define wxSOUND_ASYNC ((unsigned)1)
#define wxSOUND_LOOP ((unsigned)2)
// Base class for wxSound implementations
class WXDLLIMPEXP_ADV wxSoundBase : public wxObject
{
public:
// Play the sound:
bool Play(unsigned flags = wxSOUND_ASYNC) const
{
wxASSERT_MSG( (flags & wxSOUND_LOOP) == 0 ||
(flags & wxSOUND_ASYNC) != 0,
wxT("sound can only be looped asynchronously") );
return DoPlay(flags);
}
// Plays sound from filename:
static bool Play(const wxString& filename, unsigned flags = wxSOUND_ASYNC);
protected:
virtual bool DoPlay(unsigned flags) const = 0;
};
// ----------------------------------------------------------------------------
// wxSound class implementation
// ----------------------------------------------------------------------------
#if defined(__WINDOWS__)
#include "wx/msw/sound.h"
#elif defined(__WXMAC__)
#include "wx/osx/sound.h"
#elif defined(__UNIX__)
#include "wx/unix/sound.h"
#endif
// ----------------------------------------------------------------------------
// wxSoundBase methods
// ----------------------------------------------------------------------------
inline bool wxSoundBase::Play(const wxString& filename, unsigned flags)
{
wxSound snd(filename);
return snd.IsOk() ? snd.Play(flags) : false;
}
#endif // wxUSE_SOUND
#endif // _WX_SOUND_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/tooltip.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/tooltip.h
// Purpose: wxToolTip base header
// Author: Robert Roebling
// Modified by:
// Created:
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOOLTIP_H_BASE_
#define _WX_TOOLTIP_H_BASE_
#include "wx/defs.h"
#if wxUSE_TOOLTIPS
#if defined(__WXMSW__)
#include "wx/msw/tooltip.h"
#elif defined(__WXMOTIF__)
// #include "wx/motif/tooltip.h"
#elif defined(__WXGTK20__)
#include "wx/gtk/tooltip.h"
#elif defined(__WXGTK__)
#include "wx/gtk1/tooltip.h"
#elif defined(__WXMAC__)
#include "wx/osx/tooltip.h"
#elif defined(__WXQT__)
#include "wx/qt/tooltip.h"
#endif
#endif
// wxUSE_TOOLTIPS
#endif
// _WX_TOOLTIP_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/vscroll.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/vscroll.h
// Purpose: Variable scrolled windows (wx[V/H/HV]ScrolledWindow)
// Author: Vadim Zeitlin
// Modified by: Brad Anderson, Bryan Petty
// Created: 30.05.03
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_VSCROLL_H_
#define _WX_VSCROLL_H_
#include "wx/panel.h"
#include "wx/position.h"
#include "wx/scrolwin.h"
class WXDLLIMPEXP_FWD_CORE wxVarScrollHelperEvtHandler;
// Using the same techniques as the wxScrolledWindow class |
// hierarchy, the wx[V/H/HV]ScrolledWindow classes are slightly |
// more complex (compare with the diagram outlined in |
// scrolwin.h) for the purpose of reducing code duplication |
// through the use of mix-in classes. |
// |
// wxAnyScrollHelperBase |
// | |
// | |
// | |
// V |
// wxVarScrollHelperBase |
// / \ |
// / \ |
// V V |
// wxVarHScrollHelper wxVarVScrollHelper |
// | \ / | |
// | \ / | |
// | V V | |
// | wxVarHVScrollHelper | |
// | | | |
// | | V |
// | wxPanel | wxVarVScrollLegacyAdaptor |
// | / \ \ | | |
// | / \ `-----|----------. | |
// | / \ | \ | |
// | / \ | \ | |
// V V \ | V V |
// wxHScrolledWindow \ | wxVScrolledWindow |
// V V |
// wxHVScrolledWindow |
// |
// |
// Border added to suppress GCC multi-line comment warnings ->|
// ===========================================================================
// wxVarScrollHelperBase
// ===========================================================================
// Provides all base common scroll calculations needed for either orientation,
// automatic scrollbar functionality, saved scroll positions, functionality
// for changing the target window to be scrolled, as well as defining all
// required virtual functions that need to be implemented for any orientation
// specific work.
class WXDLLIMPEXP_CORE wxVarScrollHelperBase : public wxAnyScrollHelperBase
{
public:
// constructors and such
// ---------------------
wxVarScrollHelperBase(wxWindow *winToScroll);
virtual ~wxVarScrollHelperBase();
// operations
// ----------
// with physical scrolling on, the device origin is changed properly when
// a wxPaintDC is prepared, children are actually moved and laid out
// properly, and the contents of the window (pixels) are actually moved
void EnablePhysicalScrolling(bool scrolling = true)
{ m_physicalScrolling = scrolling; }
// wxNOT_FOUND if none, i.e. if it is below the last item
int VirtualHitTest(wxCoord coord) const;
// recalculate all our parameters and redisplay all units
virtual void RefreshAll();
// accessors
// ---------
// get the first currently visible unit
size_t GetVisibleBegin() const { return m_unitFirst; }
// get the last currently visible unit
size_t GetVisibleEnd() const
{ return m_unitFirst + m_nUnitsVisible; }
// is this unit currently visible?
bool IsVisible(size_t unit) const
{ return unit >= m_unitFirst && unit < GetVisibleEnd(); }
// translate between scrolled and unscrolled coordinates
int CalcScrolledPosition(int coord) const
{ return DoCalcScrolledPosition(coord); }
int CalcUnscrolledPosition(int coord) const
{ return DoCalcUnscrolledPosition(coord); }
virtual int DoCalcScrolledPosition(int coord) const;
virtual int DoCalcUnscrolledPosition(int coord) const;
// update the thumb size shown by the scrollbar
virtual void UpdateScrollbar();
void RemoveScrollbar();
// Normally the wxScrolledWindow will scroll itself, but in some rare
// occasions you might want it to scroll [part of] another window (e.g. a
// child of it in order to scroll only a portion the area between the
// scrollbars (spreadsheet: only cell area will move).
virtual void SetTargetWindow(wxWindow *target);
// change the DC origin according to the scroll position. To properly
// forward calls to wxWindow::Layout use WX_FORWARD_TO_SCROLL_HELPER()
// derived class
virtual void DoPrepareDC(wxDC& dc) wxOVERRIDE;
// the methods to be called from the window event handlers
void HandleOnScroll(wxScrollWinEvent& event);
void HandleOnSize(wxSizeEvent& event);
#if wxUSE_MOUSEWHEEL
void HandleOnMouseWheel(wxMouseEvent& event);
#endif // wxUSE_MOUSEWHEEL
// these functions must be overidden in the derived class to return
// orientation specific data (e.g. the width for vertically scrolling
// derivatives in the case of GetOrientationTargetSize())
virtual int GetOrientationTargetSize() const = 0;
virtual int GetNonOrientationTargetSize() const = 0;
virtual wxOrientation GetOrientation() const = 0;
protected:
// all *Unit* functions are protected to be exposed by
// wxVarScrollHelperBase implementations (with appropriate names)
// get the number of units this window contains (previously set by
// SetUnitCount())
size_t GetUnitCount() const { return m_unitMax; }
// set the number of units the helper contains: the derived class must
// provide the sizes for all units with indices up to the one given here
// in its OnGetUnitSize()
void SetUnitCount(size_t count);
// redraw the specified unit
virtual void RefreshUnit(size_t unit);
// redraw all units in the specified range (inclusive)
virtual void RefreshUnits(size_t from, size_t to);
// scroll to the specified unit: it will become the first visible unit in
// the window
//
// return true if we scrolled the window, false if nothing was done
bool DoScrollToUnit(size_t unit);
// scroll by the specified number of units/pages
virtual bool DoScrollUnits(int units);
virtual bool DoScrollPages(int pages);
// this function must be overridden in the derived class and it should
// return the size of the given unit in pixels
virtual wxCoord OnGetUnitSize(size_t n) const = 0;
// this function doesn't have to be overridden but it may be useful to do
// it if calculating the units' sizes is a relatively expensive operation
// as it gives the user code a possibility to calculate several of them at
// once
//
// OnGetUnitsSizeHint() is normally called just before OnGetUnitSize() but
// you shouldn't rely on the latter being called for all units in the
// interval specified here. It is also possible that OnGetUnitHeight() will
// be called for the units outside of this interval, so this is really just
// a hint, not a promise.
//
// finally note that unitMin is inclusive, while unitMax is exclusive, as
// usual
virtual void OnGetUnitsSizeHint(size_t WXUNUSED(unitMin),
size_t WXUNUSED(unitMax)) const
{ }
// when the number of units changes, we try to estimate the total size
// of all units which is a rather expensive operation in terms of unit
// access, so if the user code may estimate the average size
// better/faster than we do, it should override this function to implement
// its own logic
//
// this function should return the best guess for the total size it may
// make
virtual wxCoord EstimateTotalSize() const { return DoEstimateTotalSize(); }
wxCoord DoEstimateTotalSize() const;
// find the index of the unit we need to show to fit the specified unit on
// the opposite side either fully or partially (depending on fullyVisible)
size_t FindFirstVisibleFromLast(size_t last,
bool fullyVisible = false) const;
// get the total size of the units between unitMin (inclusive) and
// unitMax (exclusive)
wxCoord GetUnitsSize(size_t unitMin, size_t unitMax) const;
// get the offset of the first visible unit
wxCoord GetScrollOffset() const
{ return GetUnitsSize(0, GetVisibleBegin()); }
// get the size of the target window
wxSize GetTargetSize() const { return m_targetWindow->GetClientSize(); }
void GetTargetSize(int *w, int *h)
{
wxSize size = GetTargetSize();
if ( w )
*w = size.x;
if ( h )
*h = size.y;
}
// calculate the new scroll position based on scroll event type
size_t GetNewScrollPosition(wxScrollWinEvent& event) const;
// replacement implementation of wxWindow::Layout virtual method. To
// properly forward calls to wxWindow::Layout use
// WX_FORWARD_TO_SCROLL_HELPER() derived class
bool ScrollLayout();
#ifdef __WXMAC__
// queue mac window update after handling scroll event
virtual void UpdateMacScrollWindow() { }
#endif // __WXMAC__
// change the target window
void DoSetTargetWindow(wxWindow *target);
// delete the event handler we installed
void DeleteEvtHandler();
// helper function abstracting the orientation test: with vertical
// orientation, it assigns the first value to x and the second one to y,
// with horizontal orientation it reverses them, i.e. the first value is
// assigned to y and the second one to x
void AssignOrient(wxCoord& x, wxCoord& y, wxCoord first, wxCoord second);
// similar to "oriented assignment" above but does "oriented increment":
// for vertical orientation, y is incremented by the given value and x if
// left unchanged, for horizontal orientation x is incremented
void IncOrient(wxCoord& x, wxCoord& y, wxCoord inc);
private:
// the total number of (logical) units
size_t m_unitMax;
// the total (estimated) size
wxCoord m_sizeTotal;
// the first currently visible unit
size_t m_unitFirst;
// the number of currently visible units (including the last, possibly only
// partly, visible one)
size_t m_nUnitsVisible;
// accumulated mouse wheel rotation
#if wxUSE_MOUSEWHEEL
int m_sumWheelRotation;
#endif
// do child scrolling (used in DoPrepareDC())
bool m_physicalScrolling;
// handler injected into target window to forward some useful events to us
wxVarScrollHelperEvtHandler *m_handler;
};
// ===========================================================================
// wxVarVScrollHelper
// ===========================================================================
// Provides public API functions targeted for vertical-specific scrolling,
// wrapping the functionality of wxVarScrollHelperBase.
class WXDLLIMPEXP_CORE wxVarVScrollHelper : public wxVarScrollHelperBase
{
public:
// constructors and such
// ---------------------
// ctor must be given the associated window
wxVarVScrollHelper(wxWindow *winToScroll)
: wxVarScrollHelperBase(winToScroll)
{
}
// operators
void SetRowCount(size_t rowCount) { SetUnitCount(rowCount); }
bool ScrollToRow(size_t row) { return DoScrollToUnit(row); }
virtual bool ScrollRows(int rows)
{ return DoScrollUnits(rows); }
virtual bool ScrollRowPages(int pages)
{ return DoScrollPages(pages); }
virtual void RefreshRow(size_t row)
{ RefreshUnit(row); }
virtual void RefreshRows(size_t from, size_t to)
{ RefreshUnits(from, to); }
// accessors
size_t GetRowCount() const { return GetUnitCount(); }
size_t GetVisibleRowsBegin() const { return GetVisibleBegin(); }
size_t GetVisibleRowsEnd() const { return GetVisibleEnd(); }
bool IsRowVisible(size_t row) const { return IsVisible(row); }
virtual int GetOrientationTargetSize() const wxOVERRIDE
{ return GetTargetWindow()->GetClientSize().y; }
virtual int GetNonOrientationTargetSize() const wxOVERRIDE
{ return GetTargetWindow()->GetClientSize().x; }
virtual wxOrientation GetOrientation() const wxOVERRIDE { return wxVERTICAL; }
protected:
// this function must be overridden in the derived class and it should
// return the size of the given row in pixels
virtual wxCoord OnGetRowHeight(size_t n) const = 0;
wxCoord OnGetUnitSize(size_t n) const wxOVERRIDE { return OnGetRowHeight(n); }
virtual void OnGetRowsHeightHint(size_t WXUNUSED(rowMin),
size_t WXUNUSED(rowMax)) const { }
// forward calls to OnGetRowsHeightHint()
virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const wxOVERRIDE
{ OnGetRowsHeightHint(unitMin, unitMax); }
// again, if not overridden, it will fall back on default method
virtual wxCoord EstimateTotalHeight() const
{ return DoEstimateTotalSize(); }
// forward calls to EstimateTotalHeight()
virtual wxCoord EstimateTotalSize() const wxOVERRIDE { return EstimateTotalHeight(); }
wxCoord GetRowsHeight(size_t rowMin, size_t rowMax) const
{ return GetUnitsSize(rowMin, rowMax); }
};
// ===========================================================================
// wxVarHScrollHelper
// ===========================================================================
// Provides public API functions targeted for horizontal-specific scrolling,
// wrapping the functionality of wxVarScrollHelperBase.
class WXDLLIMPEXP_CORE wxVarHScrollHelper : public wxVarScrollHelperBase
{
public:
// constructors and such
// ---------------------
// ctor must be given the associated window
wxVarHScrollHelper(wxWindow *winToScroll)
: wxVarScrollHelperBase(winToScroll)
{
}
// operators
void SetColumnCount(size_t columnCount)
{ SetUnitCount(columnCount); }
bool ScrollToColumn(size_t column)
{ return DoScrollToUnit(column); }
virtual bool ScrollColumns(int columns)
{ return DoScrollUnits(columns); }
virtual bool ScrollColumnPages(int pages)
{ return DoScrollPages(pages); }
virtual void RefreshColumn(size_t column)
{ RefreshUnit(column); }
virtual void RefreshColumns(size_t from, size_t to)
{ RefreshUnits(from, to); }
// accessors
size_t GetColumnCount() const
{ return GetUnitCount(); }
size_t GetVisibleColumnsBegin() const
{ return GetVisibleBegin(); }
size_t GetVisibleColumnsEnd() const
{ return GetVisibleEnd(); }
bool IsColumnVisible(size_t column) const
{ return IsVisible(column); }
virtual int GetOrientationTargetSize() const wxOVERRIDE
{ return GetTargetWindow()->GetClientSize().x; }
virtual int GetNonOrientationTargetSize() const wxOVERRIDE
{ return GetTargetWindow()->GetClientSize().y; }
virtual wxOrientation GetOrientation() const wxOVERRIDE { return wxHORIZONTAL; }
protected:
// this function must be overridden in the derived class and it should
// return the size of the given column in pixels
virtual wxCoord OnGetColumnWidth(size_t n) const = 0;
wxCoord OnGetUnitSize(size_t n) const wxOVERRIDE { return OnGetColumnWidth(n); }
virtual void OnGetColumnsWidthHint(size_t WXUNUSED(columnMin),
size_t WXUNUSED(columnMax)) const
{ }
// forward calls to OnGetColumnsWidthHint()
virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const wxOVERRIDE
{ OnGetColumnsWidthHint(unitMin, unitMax); }
// again, if not overridden, it will fall back on default method
virtual wxCoord EstimateTotalWidth() const { return DoEstimateTotalSize(); }
// forward calls to EstimateTotalWidth()
virtual wxCoord EstimateTotalSize() const wxOVERRIDE { return EstimateTotalWidth(); }
wxCoord GetColumnsWidth(size_t columnMin, size_t columnMax) const
{ return GetUnitsSize(columnMin, columnMax); }
};
// ===========================================================================
// wxVarHVScrollHelper
// ===========================================================================
// Provides public API functions targeted at functions with similar names in
// both wxVScrollHelper and wxHScrollHelper so class scope doesn't need to be
// specified (since we are using multiple inheritance). It also provides
// functions to make changing values for both orientations at the same time
// easier.
class WXDLLIMPEXP_CORE wxVarHVScrollHelper : public wxVarVScrollHelper,
public wxVarHScrollHelper
{
public:
// constructors and such
// ---------------------
// ctor must be given the associated window
wxVarHVScrollHelper(wxWindow *winToScroll)
: wxVarVScrollHelper(winToScroll), wxVarHScrollHelper(winToScroll) { }
// operators
// ---------
// set the number of units the window contains for each axis: the derived
// class must provide the widths and heights for all units with indices up
// to each of the one given here in its OnGetColumnWidth() and
// OnGetRowHeight()
void SetRowColumnCount(size_t rowCount, size_t columnCount);
// with physical scrolling on, the device origin is changed properly when
// a wxPaintDC is prepared, children are actually moved and laid out
// properly, and the contents of the window (pixels) are actually moved
void EnablePhysicalScrolling(bool vscrolling = true, bool hscrolling = true)
{
wxVarVScrollHelper::EnablePhysicalScrolling(vscrolling);
wxVarHScrollHelper::EnablePhysicalScrolling(hscrolling);
}
// scroll to the specified row/column: it will become the first visible
// cell in the window
//
// return true if we scrolled the window, false if nothing was done
bool ScrollToRowColumn(size_t row, size_t column);
bool ScrollToRowColumn(const wxPosition &pos)
{ return ScrollToRowColumn(pos.GetRow(), pos.GetColumn()); }
// redraw the specified cell
virtual void RefreshRowColumn(size_t row, size_t column);
virtual void RefreshRowColumn(const wxPosition &pos)
{ RefreshRowColumn(pos.GetRow(), pos.GetColumn()); }
// redraw the specified regions (inclusive). If the target window for
// both orientations is the same the rectangle of cells is refreshed; if
// the target windows differ the entire client size opposite the
// orientation direction is refreshed between the specified limits
virtual void RefreshRowsColumns(size_t fromRow, size_t toRow,
size_t fromColumn, size_t toColumn);
virtual void RefreshRowsColumns(const wxPosition& from,
const wxPosition& to)
{
RefreshRowsColumns(from.GetRow(), to.GetRow(),
from.GetColumn(), to.GetColumn());
}
// locate the virtual position from the given device coordinates
wxPosition VirtualHitTest(wxCoord x, wxCoord y) const;
wxPosition VirtualHitTest(const wxPoint &pos) const
{ return VirtualHitTest(pos.x, pos.y); }
// change the DC origin according to the scroll position. To properly
// forward calls to wxWindow::Layout use WX_FORWARD_TO_SCROLL_HELPER()
// derived class. We use this version to call both base classes'
// DoPrepareDC()
virtual void DoPrepareDC(wxDC& dc) wxOVERRIDE;
// replacement implementation of wxWindow::Layout virtual method. To
// properly forward calls to wxWindow::Layout use
// WX_FORWARD_TO_SCROLL_HELPER() derived class. We use this version to
// call both base classes' ScrollLayout()
bool ScrollLayout();
// accessors
// ---------
// get the number of units this window contains (previously set by
// Set[Column/Row/RowColumn/Unit]Count())
wxSize GetRowColumnCount() const;
// get the first currently visible units
wxPosition GetVisibleBegin() const;
wxPosition GetVisibleEnd() const;
// is this cell currently visible?
bool IsVisible(size_t row, size_t column) const;
bool IsVisible(const wxPosition &pos) const
{ return IsVisible(pos.GetRow(), pos.GetColumn()); }
};
#if WXWIN_COMPATIBILITY_2_8
// ===========================================================================
// wxVarVScrollLegacyAdaptor
// ===========================================================================
// Provides backwards compatible API for applications originally built using
// wxVScrolledWindow in 2.6 or 2.8. Originally, wxVScrolledWindow referred
// to scrolling "lines". We use "units" in wxVarScrollHelperBase to avoid
// implying any orientation (since the functions are used for both horizontal
// and vertical scrolling in derived classes). And in the new
// wxVScrolledWindow and wxHScrolledWindow classes, we refer to them as
// "rows" and "columns", respectively. This is to help clear some confusion
// in not only those classes, but also in wxHVScrolledWindow where functions
// are inherited from both.
class WXDLLIMPEXP_CORE wxVarVScrollLegacyAdaptor : public wxVarVScrollHelper
{
public:
// constructors and such
// ---------------------
wxVarVScrollLegacyAdaptor(wxWindow *winToScroll)
: wxVarVScrollHelper(winToScroll)
{
}
// accessors
// ---------
// this is the same as GetVisibleRowsBegin(), exists to match
// GetLastVisibleLine() and for backwards compatibility only
wxDEPRECATED( size_t GetFirstVisibleLine() const );
// get the last currently visible line
//
// this function is unsafe as it returns (size_t)-1 (i.e. a huge positive
// number) if the control is empty, use GetVisibleRowsEnd() instead, this
// one is kept for backwards compatibility
wxDEPRECATED( size_t GetLastVisibleLine() const );
// "line" to "unit" compatibility functions
// ----------------------------------------
// get the number of lines this window contains (set by SetLineCount())
wxDEPRECATED( size_t GetLineCount() const );
// set the number of lines the helper contains: the derived class must
// provide the sizes for all lines with indices up to the one given here
// in its OnGetLineHeight()
wxDEPRECATED( void SetLineCount(size_t count) );
// redraw the specified line
wxDEPRECATED( virtual void RefreshLine(size_t line) );
// redraw all lines in the specified range (inclusive)
wxDEPRECATED( virtual void RefreshLines(size_t from, size_t to) );
// scroll to the specified line: it will become the first visible line in
// the window
//
// return true if we scrolled the window, false if nothing was done
wxDEPRECATED( bool ScrollToLine(size_t line) );
// scroll by the specified number of lines/pages
wxDEPRECATED( virtual bool ScrollLines(int lines) );
wxDEPRECATED( virtual bool ScrollPages(int pages) );
protected:
// unless the code has been updated to override OnGetRowHeight() instead,
// this function must be overridden in the derived class and it should
// return the height of the given row in pixels
wxDEPRECATED_BUT_USED_INTERNALLY(
virtual wxCoord OnGetLineHeight(size_t n) const );
// forwards the calls from base class pure virtual function to pure virtual
// OnGetLineHeight instead (backwards compatible name)
// note that we don't need to forward OnGetUnitSize() as it is already
// forwarded to OnGetRowHeight() in wxVarVScrollHelper
virtual wxCoord OnGetRowHeight(size_t n) const;
// this function doesn't have to be overridden but it may be useful to do
// it if calculating the lines heights is a relatively expensive operation
// as it gives the user code a possibility to calculate several of them at
// once
//
// OnGetLinesHint() is normally called just before OnGetLineHeight() but you
// shouldn't rely on the latter being called for all lines in the interval
// specified here. It is also possible that OnGetLineHeight() will be
// called for the lines outside of this interval, so this is really just a
// hint, not a promise.
//
// finally note that lineMin is inclusive, while lineMax is exclusive, as
// usual
wxDEPRECATED_BUT_USED_INTERNALLY( virtual void OnGetLinesHint(
size_t lineMin, size_t lineMax) const );
// forwards the calls from base class pure virtual function to pure virtual
// OnGetLinesHint instead (backwards compatible name)
void OnGetRowsHeightHint(size_t rowMin, size_t rowMax) const;
};
#else // !WXWIN_COMPATIBILITY_2_8
// shortcut to avoid checking compatibility modes later
// remove this and all references to wxVarVScrollLegacyAdaptor once
// wxWidgets 2.6 and 2.8 compatibility is removed
typedef wxVarVScrollHelper wxVarVScrollLegacyAdaptor;
#endif // WXWIN_COMPATIBILITY_2_8/!WXWIN_COMPATIBILITY_2_8
// this macro must be used in declaration of wxVarScrollHelperBase-derived
// classes
#define WX_FORWARD_TO_VAR_SCROLL_HELPER() \
public: \
virtual void PrepareDC(wxDC& dc) wxOVERRIDE { DoPrepareDC(dc); } \
virtual bool Layout() wxOVERRIDE { return ScrollLayout(); }
// ===========================================================================
// wxVScrolledWindow
// ===========================================================================
// In the name of this class, "V" may stand for "variable" because it can be
// used for scrolling rows of variable heights; "virtual", because it is not
// necessary to know the heights of all rows in advance -- only those which
// are shown on the screen need to be measured; or even "vertical", because
// this class only supports scrolling vertically.
// In any case, this is a generalization of the wxScrolledWindow class which
// can be only used when all rows have the same heights. It lacks some other
// wxScrolledWindow features however, notably it can't scroll only a rectangle
// of the window and not its entire client area.
class WXDLLIMPEXP_CORE wxVScrolledWindow : public wxPanel,
public wxVarVScrollLegacyAdaptor
{
public:
// constructors and such
// ---------------------
// default ctor, you must call Create() later
wxVScrolledWindow() : wxVarVScrollLegacyAdaptor(this) { }
// normal ctor, no need to call Create() after this one
//
// note that wxVSCROLL is always automatically added to our style, there is
// no need to specify it explicitly
wxVScrolledWindow(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
: wxVarVScrollLegacyAdaptor(this)
{
(void)Create(parent, id, pos, size, style, name);
}
// same as the previous ctor but returns status code: true if ok
//
// just as with the ctor above, wxVSCROLL style is always used, there is no
// need to specify it
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
return wxPanel::Create(parent, id, pos, size, style | wxVSCROLL, name);
}
#if WXWIN_COMPATIBILITY_2_8
// Make sure we prefer our version of HitTest rather than wxWindow's
// These functions should no longer be masked in favor of VirtualHitTest()
int HitTest(wxCoord WXUNUSED(x), wxCoord y) const
{ return wxVarVScrollHelper::VirtualHitTest(y); }
int HitTest(const wxPoint& pt) const
{ return HitTest(pt.x, pt.y); }
#endif // WXWIN_COMPATIBILITY_2_8
WX_FORWARD_TO_VAR_SCROLL_HELPER()
#ifdef __WXMAC__
protected:
virtual void UpdateMacScrollWindow() wxOVERRIDE { Update(); }
#endif // __WXMAC__
private:
wxDECLARE_NO_COPY_CLASS(wxVScrolledWindow);
wxDECLARE_ABSTRACT_CLASS(wxVScrolledWindow);
};
// ===========================================================================
// wxHScrolledWindow
// ===========================================================================
// In the name of this class, "H" stands for "horizontal" because it can be
// used for scrolling columns of variable widths. It is not necessary to know
// the widths of all columns in advance -- only those which are shown on the
// screen need to be measured.
// This is a generalization of the wxScrolledWindow class which can be only
// used when all columns have the same width. It lacks some other
// wxScrolledWindow features however, notably it can't scroll only a rectangle
// of the window and not its entire client area.
class WXDLLIMPEXP_CORE wxHScrolledWindow : public wxPanel,
public wxVarHScrollHelper
{
public:
// constructors and such
// ---------------------
// default ctor, you must call Create() later
wxHScrolledWindow() : wxVarHScrollHelper(this) { }
// normal ctor, no need to call Create() after this one
//
// note that wxHSCROLL is always automatically added to our style, there is
// no need to specify it explicitly
wxHScrolledWindow(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
: wxVarHScrollHelper(this)
{
(void)Create(parent, id, pos, size, style, name);
}
// same as the previous ctor but returns status code: true if ok
//
// just as with the ctor above, wxHSCROLL style is always used, there is no
// need to specify it
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
return wxPanel::Create(parent, id, pos, size, style | wxHSCROLL, name);
}
WX_FORWARD_TO_VAR_SCROLL_HELPER()
#ifdef __WXMAC__
protected:
virtual void UpdateMacScrollWindow() wxOVERRIDE { Update(); }
#endif // __WXMAC__
private:
wxDECLARE_NO_COPY_CLASS(wxHScrolledWindow);
wxDECLARE_ABSTRACT_CLASS(wxHScrolledWindow);
};
// ===========================================================================
// wxHVScrolledWindow
// ===========================================================================
// This window inherits all functionality of both vertical and horizontal
// scrolled windows automatically handling everything needed to scroll both
// axis simultaneously.
class WXDLLIMPEXP_CORE wxHVScrolledWindow : public wxPanel,
public wxVarHVScrollHelper
{
public:
// constructors and such
// ---------------------
// default ctor, you must call Create() later
wxHVScrolledWindow()
: wxPanel(),
wxVarHVScrollHelper(this) { }
// normal ctor, no need to call Create() after this one
//
// note that wxVSCROLL and wxHSCROLL are always automatically added to our
// style, there is no need to specify them explicitly
wxHVScrolledWindow(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
: wxPanel(),
wxVarHVScrollHelper(this)
{
(void)Create(parent, id, pos, size, style, name);
}
// same as the previous ctor but returns status code: true if ok
//
// just as with the ctor above, wxVSCROLL and wxHSCROLL styles are always
// used, there is no need to specify them
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
return wxPanel::Create(parent, id, pos, size,
style | wxVSCROLL | wxHSCROLL, name);
}
WX_FORWARD_TO_VAR_SCROLL_HELPER()
#ifdef __WXMAC__
protected:
virtual void UpdateMacScrollWindow() wxOVERRIDE { Update(); }
#endif // __WXMAC__
private:
wxDECLARE_NO_COPY_CLASS(wxHVScrolledWindow);
wxDECLARE_ABSTRACT_CLASS(wxHVScrolledWindow);
};
#endif // _WX_VSCROLL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/stattext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/stattext.h
// Purpose: wxStaticText base header
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATTEXT_H_BASE_
#define _WX_STATTEXT_H_BASE_
#include "wx/defs.h"
#if wxUSE_STATTEXT
#include "wx/control.h"
/*
* wxStaticText flags
*/
#define wxST_NO_AUTORESIZE 0x0001
// free 0x0002 bit
#define wxST_ELLIPSIZE_START 0x0004
#define wxST_ELLIPSIZE_MIDDLE 0x0008
#define wxST_ELLIPSIZE_END 0x0010
#define wxST_ELLIPSIZE_MASK \
(wxST_ELLIPSIZE_START | wxST_ELLIPSIZE_MIDDLE | wxST_ELLIPSIZE_END)
extern WXDLLIMPEXP_DATA_CORE(const char) wxStaticTextNameStr[];
class WXDLLIMPEXP_CORE wxStaticTextBase : public wxControl
{
public:
wxStaticTextBase() { }
// wrap the text of the control so that no line is longer than the given
// width (if possible: this function won't break words)
// This function will modify the value returned by GetLabel()!
void Wrap(int width);
// overridden base virtuals
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
bool IsEllipsized() const
{
return (GetWindowStyle() & wxST_ELLIPSIZE_MASK) != 0;
}
protected: // functions required for wxST_ELLIPSIZE_* support
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// Calls Ellipsize() on the real label if necessary. Unlike GetLabelText(),
// keeps the mnemonics instead of removing them.
virtual wxString GetEllipsizedLabel() const;
// Replaces parts of the string with ellipsis according to the ellipsize
// style. Shouldn't be called if we don't have any.
wxString Ellipsize(const wxString& label) const;
// to be called when updating the size of the static text:
// updates the label redoing ellipsization calculations
void UpdateLabel();
// These functions are platform-specific and must be overridden in ports
// which do not natively support ellipsization and they must be implemented
// in a way so that the m_labelOrig member of wxControl is not touched:
// returns the real label currently displayed inside the control.
virtual wxString DoGetLabel() const { return wxEmptyString; }
// sets the real label currently displayed inside the control,
// _without_ invalidating the size. The text passed is always markup-free
// but may contain the mnemonic characters.
virtual void DoSetLabel(const wxString& WXUNUSED(str)) { }
// Update the current size to match the best size unless wxST_NO_AUTORESIZE
// style is explicitly used.
void AutoResizeIfNecessary();
private:
wxDECLARE_NO_COPY_CLASS(wxStaticTextBase);
};
// see wx/generic/stattextg.h for the explanation
#ifndef wxNO_PORT_STATTEXT_INCLUDE
#if defined(__WXUNIVERSAL__)
#include "wx/univ/stattext.h"
#elif defined(__WXMSW__)
#include "wx/msw/stattext.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/stattext.h"
#elif defined(__WXGTK20__)
#include "wx/gtk/stattext.h"
#elif defined(__WXGTK__)
#include "wx/gtk1/stattext.h"
#elif defined(__WXMAC__)
#include "wx/osx/stattext.h"
#elif defined(__WXQT__)
#include "wx/qt/stattext.h"
#endif
#endif // !wxNO_PORT_STATTEXT_INCLUDE
#endif // wxUSE_STATTEXT
#endif // _WX_STATTEXT_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/wxcrtvararg.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/wxcrtvararg.h
// Purpose: Type-safe ANSI and Unicode builds compatible wrappers for
// printf(), scanf() and related CRT functions
// Author: Joel Farley, Ove Kåven
// Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
// Created: 2007-02-19
// Copyright: (c) 2007 REA Elektronik GmbH
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WXCRTVARARG_H_
#define _WX_WXCRTVARARG_H_
// NB: User code should include wx/crt.h instead of including this
// header directly.
#include "wx/wxcrt.h"
#include "wx/strvararg.h"
#include "wx/string.h"
// ----------------------------------------------------------------------------
// CRT functions aliases
// ----------------------------------------------------------------------------
/* Required for wxPrintf() etc */
#include <stdarg.h>
/* printf() family saga */
/*
For many old Unix systems [v]snprintf()/vsscanf() exists in the system
libraries but not in the headers, so we need to declare it ourselves to be
able to use it.
*/
#ifdef __UNIX__
#if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
#ifdef __cplusplus
extern "C"
#else
extern
#endif
int vsnprintf(char *str, size_t size, const char *format, va_list ap);
#endif /* !HAVE_VSNPRINTF_DECL */
#if defined(HAVE_SNPRINTF) && !defined(HAVE_SNPRINTF_DECL)
#ifdef __cplusplus
extern "C"
#else
extern
#endif
int snprintf(char *str, size_t size, const char *format, ...);
#endif /* !HAVE_SNPRINTF_DECL */
#if defined(HAVE_VSSCANF) && !defined(HAVE_VSSCANF_DECL)
#ifdef __cplusplus
extern "C"
#else
extern
#endif
int vsscanf(const char *str, const char *format, va_list ap);
#endif /* !HAVE_VSSCANF_DECL */
/* Wrapper for vsnprintf if it's 3rd parameter is non-const. Note: the
* same isn't done for snprintf below, the builtin wxSnprintf_ is used
* instead since it's already a simple wrapper */
#if defined __cplusplus && defined HAVE_BROKEN_VSNPRINTF_DECL
inline int wx_fixed_vsnprintf(char *str, size_t size, const char *format, va_list ap)
{
return vsnprintf(str, size, (char*)format, ap);
}
#endif
#endif /* __UNIX__ */
/*
mingw32 normally uses MSVCRT which has non-standard vswprintf() and so
normally _vsnwprintf() is used instead, the only exception is when mingw32
is used with STLPort which does have a standard vswprintf() starting from
version 5.1 which we can use.
*/
#ifdef __MINGW32__
#if defined(_STLPORT_VERSION) && _STLPORT_VERSION >= 0x510
#ifndef HAVE_VSWPRINTF
#define HAVE_VSWPRINTF
#endif
#elif defined(HAVE_VSWPRINTF)
/* can't use non-standard vswprintf() */
#undef HAVE_VSWPRINTF
#endif
#endif /* __MINGW32__ */
#if wxUSE_PRINTF_POS_PARAMS
/*
The systems where vsnprintf() supports positional parameters should
define the HAVE_UNIX98_PRINTF symbol.
On systems which don't (e.g. Windows) we are forced to use
our wxVsnprintf() implementation.
*/
#if defined(HAVE_UNIX98_PRINTF)
#ifdef HAVE_VSWPRINTF
#define wxCRT_VsnprintfW vswprintf
#endif
#ifdef HAVE_BROKEN_VSNPRINTF_DECL
#define wxCRT_VsnprintfA wx_fixed_vsnprintf
#else
#define wxCRT_VsnprintfA vsnprintf
#endif
#else /* !HAVE_UNIX98_PRINTF */
/*
The only compiler with positional parameters support under Windows
is VC++ 8.0 which provides a new xxprintf_p() functions family.
The 2003 PSDK includes a slightly earlier version of VC8 than the
main release and does not have the printf_p functions.
*/
#if defined _MSC_FULL_VER && _MSC_FULL_VER >= 140050727
#define wxCRT_VsnprintfA _vsprintf_p
#define wxCRT_VsnprintfW _vswprintf_p
#endif
#endif /* HAVE_UNIX98_PRINTF/!HAVE_UNIX98_PRINTF */
#else /* !wxUSE_PRINTF_POS_PARAMS */
/*
We always want to define safe snprintf() function to be used instead of
sprintf(). Some compilers already have it (or rather vsnprintf() which
we really need...), otherwise we implement it using our own printf()
code.
We define function with a trailing underscore here because the real one
is a wrapper around it as explained below
*/
#if defined(__VISUALC__) || \
(defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
#define wxCRT_VsnprintfA _vsnprintf
#define wxCRT_VsnprintfW _vsnwprintf
#else
#if defined(HAVE__VSNWPRINTF)
#define wxCRT_VsnprintfW _vsnwprintf
#elif defined(HAVE_VSWPRINTF)
#define wxCRT_VsnprintfW vswprintf
#endif
#if defined(HAVE_VSNPRINTF)
#ifdef HAVE_BROKEN_VSNPRINTF_DECL
#define wxCRT_VsnprintfA wx_fixed_vsnprintf
#else
#define wxCRT_VsnprintfA vsnprintf
#endif
#endif
#endif
#endif /* wxUSE_PRINTF_POS_PARAMS/!wxUSE_PRINTF_POS_PARAMS */
#ifndef wxCRT_VsnprintfW
/* no (suitable) vsnprintf(), cook our own */
WXDLLIMPEXP_BASE int
wxCRT_VsnprintfW(wchar_t *buf, size_t len, const wchar_t *format, va_list argptr);
#define wxUSE_WXVSNPRINTFW 1
#else
#define wxUSE_WXVSNPRINTFW 0
#endif
#ifndef wxCRT_VsnprintfA
/* no (suitable) vsnprintf(), cook our own */
WXDLLIMPEXP_BASE int
wxCRT_VsnprintfA(char *buf, size_t len, const char *format, va_list argptr);
#define wxUSE_WXVSNPRINTFA 1
#else
#define wxUSE_WXVSNPRINTFA 0
#endif
// for wxString code, define wxUSE_WXVSNPRINTF to indicate that wx
// implementation is used no matter what (in UTF-8 build, either *A or *W
// version may be called):
#if !wxUSE_UNICODE
#define wxUSE_WXVSNPRINTF wxUSE_WXVSNPRINTFA
#elif wxUSE_UNICODE_WCHAR
#define wxUSE_WXVSNPRINTF wxUSE_WXVSNPRINTFW
#elif wxUSE_UTF8_LOCALE_ONLY
#define wxUSE_WXVSNPRINTF wxUSE_WXVSNPRINTFA
#else // UTF-8 under any locale
#define wxUSE_WXVSNPRINTF (wxUSE_WXVSNPRINTFA && wxUSE_WXVSNPRINTFW)
#endif
#define wxCRT_FprintfA fprintf
#define wxCRT_PrintfA printf
#define wxCRT_VfprintfA vfprintf
#define wxCRT_VprintfA vprintf
#define wxCRT_VsprintfA vsprintf
/*
In Unicode mode we need to have all standard functions such as wprintf() and
so on but not all systems have them so use our own implementations in this
case.
*/
#if !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
#define wxNEED_WPRINTF
#endif
#if !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_VSWSCANF) && defined(HAVE_VSSCANF)
#define wxNEED_VSWSCANF
#endif
#if defined(wxNEED_WPRINTF)
/*
we need to implement all wide character printf functions either because
we don't have them at all or because they don't have the semantics we
need
*/
int wxCRT_PrintfW( const wchar_t *format, ... );
int wxCRT_FprintfW( FILE *stream, const wchar_t *format, ... );
int wxCRT_VfprintfW( FILE *stream, const wchar_t *format, va_list ap );
int wxCRT_VprintfW( const wchar_t *format, va_list ap );
int wxCRT_VsprintfW( wchar_t *str, const wchar_t *format, va_list ap );
#else /* !wxNEED_WPRINTF */
#define wxCRT_FprintfW fwprintf
#define wxCRT_PrintfW wprintf
#define wxCRT_VfprintfW vfwprintf
#define wxCRT_VprintfW vwprintf
#if defined(__WINDOWS__) && !defined(HAVE_VSWPRINTF)
// only non-standard vswprintf() without buffer size argument can be used here
#define wxCRT_VsprintfW vswprintf
#endif
#endif /* wxNEED_WPRINTF */
/* Required for wxScanf() etc. */
#define wxCRT_ScanfA scanf
#define wxCRT_SscanfA sscanf
#define wxCRT_FscanfA fscanf
/* vsscanf() may have a wrong declaration with non-const first parameter, fix
* this by wrapping it if necessary. */
#if defined __cplusplus && defined HAVE_BROKEN_VSSCANF_DECL
inline int wxCRT_VsscanfA(const char *str, const char *format, va_list ap)
{
return vsscanf(const_cast<char *>(str), format, ap);
}
#else
wxDECL_FOR_STRICT_MINGW32(int, vsscanf, (const char*, const char*, va_list))
#define wxCRT_VsscanfA vsscanf
#endif
#if defined(wxNEED_WPRINTF)
int wxCRT_ScanfW(const wchar_t *format, ...);
int wxCRT_SscanfW(const wchar_t *str, const wchar_t *format, ...);
int wxCRT_FscanfW(FILE *stream, const wchar_t *format, ...);
#else
#define wxCRT_ScanfW wxVMS_USE_STD wscanf
#define wxCRT_SscanfW wxVMS_USE_STD swscanf
#define wxCRT_FscanfW wxVMS_USE_STD fwscanf
#endif
#ifdef wxNEED_VSWSCANF
int wxCRT_VsscanfW(const wchar_t *str, const wchar_t *format, va_list ap);
#else
wxDECL_FOR_STRICT_MINGW32(int, vswscanf, (const wchar_t*, const wchar_t*, va_list))
#define wxCRT_VsscanfW wxVMS_USE_STD vswscanf
#endif
// ----------------------------------------------------------------------------
// user-friendly wrappers to CRT functions
// ----------------------------------------------------------------------------
// FIXME-UTF8: remove this
#if wxUSE_UNICODE
#define wxCRT_PrintfNative wxCRT_PrintfW
#define wxCRT_FprintfNative wxCRT_FprintfW
#else
#define wxCRT_PrintfNative wxCRT_PrintfA
#define wxCRT_FprintfNative wxCRT_FprintfA
#endif
WX_DEFINE_VARARG_FUNC_SANS_N0(int, wxPrintf, 1, (const wxFormatString&),
wxCRT_PrintfNative, wxCRT_PrintfA)
inline int wxPrintf(const wxFormatString& s)
{
return wxPrintf("%s", s.InputAsString());
}
WX_DEFINE_VARARG_FUNC_SANS_N0(int, wxFprintf, 2, (FILE*, const wxFormatString&),
wxCRT_FprintfNative, wxCRT_FprintfA)
inline int wxFprintf(FILE *f, const wxFormatString& s)
{
return wxFprintf(f, "%s", s.InputAsString());
}
// va_list versions of printf functions simply forward to the respective
// CRT function; note that they assume that va_list was created using
// wxArgNormalizer<T>!
#if wxUSE_UNICODE_UTF8
#if wxUSE_UTF8_LOCALE_ONLY
#define WX_VARARG_VFOO_IMPL(args, implW, implA) \
return implA args
#else
#define WX_VARARG_VFOO_IMPL(args, implW, implA) \
if ( wxLocaleIsUtf8 ) return implA args; \
else return implW args
#endif
#elif wxUSE_UNICODE_WCHAR
#define WX_VARARG_VFOO_IMPL(args, implW, implA) \
return implW args
#else // ANSI
#define WX_VARARG_VFOO_IMPL(args, implW, implA) \
return implA args
#endif
inline int
wxVprintf(const wxString& format, va_list ap)
{
WX_VARARG_VFOO_IMPL((wxFormatString(format), ap),
wxCRT_VprintfW, wxCRT_VprintfA);
}
inline int
wxVfprintf(FILE *f, const wxString& format, va_list ap)
{
WX_VARARG_VFOO_IMPL((f, wxFormatString(format), ap),
wxCRT_VfprintfW, wxCRT_VfprintfA);
}
#undef WX_VARARG_VFOO_IMPL
// wxSprintf() and friends have to be implemented in two forms, one for
// writing to char* buffer and one for writing to wchar_t*:
#if !wxUSE_UTF8_LOCALE_ONLY
int WXDLLIMPEXP_BASE wxDoSprintfWchar(char *str, const wxChar *format, ...);
#endif
#if wxUSE_UNICODE_UTF8
int WXDLLIMPEXP_BASE wxDoSprintfUtf8(char *str, const char *format, ...);
#endif
WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (char*, const wxFormatString&),
wxDoSprintfWchar, wxDoSprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsprintf(char *str, const wxString& format, va_list argptr);
#if !wxUSE_UTF8_LOCALE_ONLY
int WXDLLIMPEXP_BASE wxDoSnprintfWchar(char *str, size_t size, const wxChar *format, ...);
#endif
#if wxUSE_UNICODE_UTF8
int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(char *str, size_t size, const char *format, ...);
#endif
WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (char*, size_t, const wxFormatString&),
wxDoSnprintfWchar, wxDoSnprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsnprintf(char *str, size_t size, const wxString& format, va_list argptr);
#if wxUSE_UNICODE
#if !wxUSE_UTF8_LOCALE_ONLY
int WXDLLIMPEXP_BASE wxDoSprintfWchar(wchar_t *str, const wxChar *format, ...);
#endif
#if wxUSE_UNICODE_UTF8
int WXDLLIMPEXP_BASE wxDoSprintfUtf8(wchar_t *str, const char *format, ...);
#endif
WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (wchar_t*, const wxFormatString&),
wxDoSprintfWchar, wxDoSprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsprintf(wchar_t *str, const wxString& format, va_list argptr);
#if !wxUSE_UTF8_LOCALE_ONLY
int WXDLLIMPEXP_BASE wxDoSnprintfWchar(wchar_t *str, size_t size, const wxChar *format, ...);
#endif
#if wxUSE_UNICODE_UTF8
int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...);
#endif
WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (wchar_t*, size_t, const wxFormatString&),
wxDoSnprintfWchar, wxDoSnprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argptr);
#endif // wxUSE_UNICODE
// We can't use wxArgNormalizer<T> for variadic arguments to wxScanf() etc.
// because they are writable, so instead of providing friendly template
// vararg-like functions, we just provide both char* and wchar_t* variants
// of these functions. The type of output variadic arguments for %s must match
// the type of 'str' and 'format' arguments.
//
// For compatibility with earlier wx versions, we also provide wxSscanf()
// version with the first argument (input string) wxString; for this version,
// the type of output string values is determined by the type of format string
// only.
#define _WX_SCANFUNC_EXTRACT_ARGS_1(x) x
#define _WX_SCANFUNC_EXTRACT_ARGS_2(x,y) x, y
#define _WX_SCANFUNC_EXTRACT_ARGS(N, args) _WX_SCANFUNC_EXTRACT_ARGS_##N args
#define _WX_VARARG_PASS_WRITABLE(i) a##i
#define _WX_DEFINE_SCANFUNC(N, dummy1, name, impl, passfixed, numfixed, fixed)\
template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)> \
int name(_WX_SCANFUNC_EXTRACT_ARGS(numfixed, fixed), \
_WX_VARARG_JOIN(N, _WX_VARARG_ARG)) \
{ \
return impl(_WX_SCANFUNC_EXTRACT_ARGS(numfixed, passfixed), \
_WX_VARARG_JOIN(N, _WX_VARARG_PASS_WRITABLE)); \
}
#define WX_DEFINE_SCANFUNC(name, numfixed, fixed, impl, passfixed) \
_WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
_WX_DEFINE_SCANFUNC, \
dummy1, name, impl, passfixed, numfixed, fixed)
// this is needed to normalize the format string, see src/common/strvararg.cpp
// for more details
#ifdef __WINDOWS__
#define wxScanfConvertFormatW(fmt) fmt
#else
const wxScopedWCharBuffer
WXDLLIMPEXP_BASE wxScanfConvertFormatW(const wchar_t *format);
#endif
WX_DEFINE_SCANFUNC(wxScanf, 1, (const char *format),
wxCRT_ScanfA, (format))
WX_DEFINE_SCANFUNC(wxScanf, 1, (const wchar_t *format),
wxCRT_ScanfW, (wxScanfConvertFormatW(format)))
WX_DEFINE_SCANFUNC(wxFscanf, 2, (FILE *stream, const char *format),
wxCRT_FscanfA, (stream, format))
WX_DEFINE_SCANFUNC(wxFscanf, 2, (FILE *stream, const wchar_t *format),
wxCRT_FscanfW, (stream, wxScanfConvertFormatW(format)))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const char *str, const char *format),
wxCRT_SscanfA, (str, format))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wchar_t *str, const wchar_t *format),
wxCRT_SscanfW, (str, wxScanfConvertFormatW(format)))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxScopedCharBuffer& str, const char *format),
wxCRT_SscanfA, (str.data(), format))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxScopedWCharBuffer& str, const wchar_t *format),
wxCRT_SscanfW, (str.data(), wxScanfConvertFormatW(format)))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxString& str, const char *format),
wxCRT_SscanfA, (str.mb_str(), format))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxString& str, const wchar_t *format),
wxCRT_SscanfW, (str.wc_str(), wxScanfConvertFormatW(format)))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxCStrData& str, const char *format),
wxCRT_SscanfA, (str.AsCharBuf(), format))
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxCStrData& str, const wchar_t *format),
wxCRT_SscanfW, (str.AsWCharBuf(), wxScanfConvertFormatW(format)))
// Visual C++ doesn't provide vsscanf()
#ifndef __VISUALC___
int WXDLLIMPEXP_BASE wxVsscanf(const char *str, const char *format, va_list ap);
int WXDLLIMPEXP_BASE wxVsscanf(const wchar_t *str, const wchar_t *format, va_list ap);
int WXDLLIMPEXP_BASE wxVsscanf(const wxScopedCharBuffer& str, const char *format, va_list ap);
int WXDLLIMPEXP_BASE wxVsscanf(const wxScopedWCharBuffer& str, const wchar_t *format, va_list ap);
int WXDLLIMPEXP_BASE wxVsscanf(const wxString& str, const char *format, va_list ap);
int WXDLLIMPEXP_BASE wxVsscanf(const wxString& str, const wchar_t *format, va_list ap);
int WXDLLIMPEXP_BASE wxVsscanf(const wxCStrData& str, const char *format, va_list ap);
int WXDLLIMPEXP_BASE wxVsscanf(const wxCStrData& str, const wchar_t *format, va_list ap);
#endif // !__VISUALC__
#endif /* _WX_WXCRTVARARG_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/debugrpt.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/debugrpt.h
// Purpose: declaration of wxDebugReport class
// Author: Vadim Zeitlin
// Created: 2005-01-17
// Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DEBUGRPT_H_
#define _WX_DEBUGRPT_H_
#include "wx/defs.h"
#if wxUSE_DEBUGREPORT && wxUSE_XML
#include "wx/string.h"
#include "wx/arrstr.h"
#include "wx/filename.h"
class WXDLLIMPEXP_FWD_XML wxXmlNode;
// ----------------------------------------------------------------------------
// wxDebugReport: generate a debug report, processing is done in derived class
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_QA wxDebugReport
{
friend class wxDebugReportDialog;
public:
// this is used for the functions which may report either the current state
// or the state during the last (fatal) exception
enum Context { Context_Current, Context_Exception };
// ctor creates a temporary directory where we create the files which will
// be included in the report, use IsOk() to check for errors
wxDebugReport();
// dtor normally destroys the temporary directory created in the ctor (with
// all the files it contains), call Reset() to prevent this from happening
virtual ~wxDebugReport();
// return the name of the directory used for this report
const wxString& GetDirectory() const { return m_dir; }
// return true if the object was successfully initialized
bool IsOk() const { return !GetDirectory().empty(); }
// reset the directory name we use, the object can't be used any more after
// this as it becomes invalid/uninitialized
void Reset() { m_dir.clear(); }
// add another file to the report: the file must already exist, its name
// can be either absolute in which case it is copied to the debug report
// directory or relative to GetDirectory()
//
// description is shown to the user in the report summary
virtual void AddFile(const wxString& filename, const wxString& description);
// convenience function: write the given text to a file with the given name
// and then add it to the report (the difference with AddFile() is that the
// file will be created by this function and doesn't have to already exist)
bool AddText(const wxString& filename,
const wxString& text,
const wxString& description);
#if wxUSE_STACKWALKER
// add an XML file containing the current or exception context and the
// stack trace
bool AddCurrentContext() { return AddContext(Context_Current); }
bool AddExceptionContext() { return AddContext(Context_Exception); }
virtual bool AddContext(Context ctx);
#endif
#if wxUSE_CRASHREPORT
// add a file with crash report
bool AddCurrentDump() { return AddDump(Context_Current); }
bool AddExceptionDump() { return AddDump(Context_Exception); }
virtual bool AddDump(Context ctx);
#endif // wxUSE_CRASHREPORT
// add all available information to the report
void AddAll(Context context = Context_Exception);
// process this report: the base class simply notifies the user that the
// report has been generated, this is usually not enough -- instead you
// should override this method to do something more useful to you
bool Process();
// get the name used as base name for various files, by default
// wxApp::GetName()
virtual wxString GetReportName() const;
// get the files in this report
size_t GetFilesCount() const { return m_files.GetCount(); }
bool GetFile(size_t n, wxString *name, wxString *desc) const;
// remove the file from report: this is used by wxDebugReportPreview to
// allow the user to remove files potentially containing private
// information from the report
void RemoveFile(const wxString& name);
protected:
#if wxUSE_STACKWALKER
// used by AddContext()
virtual bool DoAddSystemInfo(wxXmlNode *nodeSystemInfo);
virtual bool DoAddLoadedModules(wxXmlNode *nodeModules);
virtual bool DoAddExceptionInfo(wxXmlNode *nodeContext);
virtual void DoAddCustomContext(wxXmlNode * WXUNUSED(nodeRoot)) { }
#endif
// used by Process()
virtual bool DoProcess();
// return the location where the report will be saved
virtual wxFileName GetSaveLocation() const;
private:
// name of the report directory
wxString m_dir;
// the arrays of files in this report and their descriptions
wxArrayString m_files,
m_descriptions;
};
#if wxUSE_ZIPSTREAM
// ----------------------------------------------------------------------------
// wxDebugReportCompress: compress all files of this debug report in a .ZIP
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_QA wxDebugReportCompress : public wxDebugReport
{
public:
wxDebugReportCompress() { }
// you can optionally specify the directory and/or name of the file where
// the debug report should be generated, a default location under the
// directory containing temporary files will be used if you don't
//
// both of these functions should be called before Process()ing the report
// if they're called at all
void SetCompressedFileDirectory(const wxString& dir);
void SetCompressedFileBaseName(const wxString& name);
// returns the full path of the compressed file (empty if creation failed)
const wxString& GetCompressedFileName() const { return m_zipfile; }
protected:
virtual bool DoProcess() wxOVERRIDE;
// return the location where the report will be saved
wxFileName GetSaveLocation() const wxOVERRIDE;
private:
// user-specified file directory/base name, use defaults if empty
wxString m_zipDir,
m_zipName;
// full path to the ZIP file we created
wxString m_zipfile;
};
// ----------------------------------------------------------------------------
// wxDebugReportUploader: uploads compressed file using HTTP POST request
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_QA wxDebugReportUpload : public wxDebugReportCompress
{
public:
// this class will upload the compressed file created by its base class to
// an HTML multipart/form-data form at the specified address
//
// the URL is the base address, input is the name of the "type=file"
// control on the form used for the file name and action is the value of
// the form action field
wxDebugReportUpload(const wxString& url,
const wxString& input,
const wxString& action,
const wxString& curl = wxT("curl"));
protected:
virtual bool DoProcess() wxOVERRIDE;
// this function may be overridden in a derived class to show the output
// from curl: this may be an HTML page or anything else that the server
// returned
//
// return value becomes the return value of Process()
virtual bool OnServerReply(const wxArrayString& WXUNUSED(reply))
{
return true;
}
private:
// the full URL to use with HTTP POST request
wxString m_uploadURL;
// the name of the input field containing the file name in the form at
// above URL
wxString m_inputField;
// the curl command (by default it is just "curl" but could be full path to
// curl or a wrapper script with curl-compatible syntax)
wxString m_curlCmd;
};
#endif // wxUSE_ZIPSTREAM
// ----------------------------------------------------------------------------
// wxDebugReportPreview: presents the debug report to the user and allows him
// to veto report entirely or remove some parts of it
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_QA wxDebugReportPreview
{
public:
// ctor is trivial
wxDebugReportPreview() { }
// present the report to the user and allow him to modify it by removing
// some or all of the files and, potentially, adding some notes
//
// return true if the report should be processed or false if the user chose
// to cancel report generation or removed all files from it
virtual bool Show(wxDebugReport& dbgrpt) const = 0;
// dtor is trivial as well but should be virtual for a base class
virtual ~wxDebugReportPreview() { }
};
#if wxUSE_GUI
// ----------------------------------------------------------------------------
// wxDebugReportPreviewStd: standard debug report preview window
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_QA wxDebugReportPreviewStd : public wxDebugReportPreview
{
public:
wxDebugReportPreviewStd() { }
virtual bool Show(wxDebugReport& dbgrpt) const wxOVERRIDE;
};
#endif // wxUSE_GUI
#endif // wxUSE_DEBUGREPORT && wxUSE_XML
#endif // _WX_DEBUGRPT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/fontmap.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/fontmap.h
// Purpose: wxFontMapper class
// Author: Vadim Zeitlin
// Modified by:
// Created: 04.11.99
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONTMAPPER_H_
#define _WX_FONTMAPPER_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#if wxUSE_FONTMAP
#include "wx/fontenc.h" // for wxFontEncoding
#if wxUSE_GUI
#include "wx/fontutil.h" // for wxNativeEncodingInfo
#endif // wxUSE_GUI
#if wxUSE_CONFIG && wxUSE_FILECONFIG
class WXDLLIMPEXP_FWD_BASE wxConfigBase;
#endif // wxUSE_CONFIG
class WXDLLIMPEXP_FWD_CORE wxFontMapper;
#if wxUSE_GUI
class WXDLLIMPEXP_FWD_CORE wxWindow;
#endif // wxUSE_GUI
// ============================================================================
// wxFontMapper manages user-definable correspondence between wxWidgets font
// encodings and the fonts present on the machine.
//
// This is a singleton class, font mapper objects can only be accessed using
// wxFontMapper::Get().
// ============================================================================
// ----------------------------------------------------------------------------
// wxFontMapperBase: this is a non-interactive class which just uses its built
// in knowledge of the encodings equivalence
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxFontMapperBase
{
public:
// constructor and such
// ---------------------
// default ctor
wxFontMapperBase();
// virtual dtor for any base class
virtual ~wxFontMapperBase();
// return instance of the wxFontMapper singleton
// wxBase code only cares that it's a wxFontMapperBase
// In wxBase, wxFontMapper is only forward declared
// so one cannot implicitly cast from it to wxFontMapperBase.
static wxFontMapperBase *Get();
// set the singleton to 'mapper' instance and return previous one
static wxFontMapper *Set(wxFontMapper *mapper);
// delete the existing font mapper if any
static void Reset();
// translates charset strings to encoding
// --------------------------------------
// returns the encoding for the given charset (in the form of RFC 2046) or
// wxFONTENCODING_SYSTEM if couldn't decode it
//
// interactive parameter is ignored in the base class, we behave as if it
// were always false
virtual wxFontEncoding CharsetToEncoding(const wxString& charset,
bool interactive = true);
// information about supported encodings
// -------------------------------------
// get the number of font encodings we know about
static size_t GetSupportedEncodingsCount();
// get the n-th supported encoding
static wxFontEncoding GetEncoding(size_t n);
// return canonical name of this encoding (this is a short string,
// GetEncodingDescription() returns a longer one)
static wxString GetEncodingName(wxFontEncoding encoding);
// return a list of all names of this encoding (see GetEncodingName)
static const wxChar** GetAllEncodingNames(wxFontEncoding encoding);
// return user-readable string describing the given encoding
//
// NB: hard-coded now, but might change later (read it from config?)
static wxString GetEncodingDescription(wxFontEncoding encoding);
// find the encoding corresponding to the given name, inverse of
// GetEncodingName() and less general than CharsetToEncoding()
//
// returns wxFONTENCODING_MAX if the name is not a supported encoding
static wxFontEncoding GetEncodingFromName(const wxString& name);
// functions which allow to configure the config object used: by default,
// the global one (from wxConfigBase::Get() will be used) and the default
// root path for the config settings is the string returned by
// GetDefaultConfigPath()
// ----------------------------------------------------------------------
#if wxUSE_CONFIG && wxUSE_FILECONFIG
// set the root config path to use (should be an absolute path)
void SetConfigPath(const wxString& prefix);
// return default config path
static const wxString& GetDefaultConfigPath();
#endif // wxUSE_CONFIG
// returns true for the base class and false for a "real" font mapper object
// (implementation-only)
virtual bool IsDummy() { return true; }
protected:
#if wxUSE_CONFIG && wxUSE_FILECONFIG
// get the config object we're using -- either the global config object
// or a wxMemoryConfig object created by this class otherwise
wxConfigBase *GetConfig();
// gets the root path for our settings -- if it wasn't set explicitly, use
// GetDefaultConfigPath()
const wxString& GetConfigPath();
// change to the given (relative) path in the config, return true if ok
// (then GetConfig() will return something !NULL), false if no config
// object
//
// caller should provide a pointer to the string variable which should be
// later passed to RestorePath()
bool ChangePath(const wxString& pathNew, wxString *pathOld);
// restore the config path after use
void RestorePath(const wxString& pathOld);
// config object and path (in it) to use
wxConfigBase *m_configDummy;
wxString m_configRootPath;
#endif // wxUSE_CONFIG
// the real implementation of the base class version of CharsetToEncoding()
//
// returns wxFONTENCODING_UNKNOWN if encoding is unknown and we shouldn't
// ask the user about it, wxFONTENCODING_SYSTEM if it is unknown but we
// should/could ask the user
int NonInteractiveCharsetToEncoding(const wxString& charset);
private:
// the global fontmapper object or NULL
static wxFontMapper *sm_instance;
friend class wxFontMapperPathChanger;
wxDECLARE_NO_COPY_CLASS(wxFontMapperBase);
};
// ----------------------------------------------------------------------------
// wxFontMapper: interactive extension of wxFontMapperBase
//
// The default implementations of all functions will ask the user if they are
// not capable of finding the answer themselves and store the answer in a
// config file (configurable via SetConfigXXX functions). This behaviour may
// be disabled by giving the value of false to "interactive" parameter.
// However, the functions will always consult the config file to allow the
// user-defined values override the default logic and there is no way to
// disable this -- which shouldn't be ever needed because if "interactive" was
// never true, the config file is never created anyhow.
// ----------------------------------------------------------------------------
#if wxUSE_GUI
class WXDLLIMPEXP_CORE wxFontMapper : public wxFontMapperBase
{
public:
// default ctor
wxFontMapper();
// virtual dtor for a base class
virtual ~wxFontMapper();
// working with the encodings
// --------------------------
// returns the encoding for the given charset (in the form of RFC 2046) or
// wxFONTENCODING_SYSTEM if couldn't decode it
virtual wxFontEncoding CharsetToEncoding(const wxString& charset,
bool interactive = true) wxOVERRIDE;
// find an alternative for the given encoding (which is supposed to not be
// available on this system). If successful, return true and fill info
// structure with the parameters required to create the font, otherwise
// return false
virtual bool GetAltForEncoding(wxFontEncoding encoding,
wxNativeEncodingInfo *info,
const wxString& facename = wxEmptyString,
bool interactive = true);
// version better suitable for 'public' use. Returns wxFontEcoding
// that can be used it wxFont ctor
bool GetAltForEncoding(wxFontEncoding encoding,
wxFontEncoding *alt_encoding,
const wxString& facename = wxEmptyString,
bool interactive = true);
// checks whether given encoding is available in given face or not.
//
// if no facename is given (default), return true if it's available in any
// facename at alll.
virtual bool IsEncodingAvailable(wxFontEncoding encoding,
const wxString& facename = wxEmptyString);
// configure the appearance of the dialogs we may popup
// ----------------------------------------------------
// the parent window for modal dialogs
void SetDialogParent(wxWindow *parent) { m_windowParent = parent; }
// the title for the dialogs (note that default is quite reasonable)
void SetDialogTitle(const wxString& title) { m_titleDialog = title; }
// GUI code needs to know it's a wxFontMapper because there
// are additional methods in the subclass.
static wxFontMapper *Get();
// pseudo-RTTI since we aren't a wxObject.
virtual bool IsDummy() wxOVERRIDE { return false; }
protected:
// GetAltForEncoding() helper: tests for the existence of the given
// encoding and saves the result in config if ok - this results in the
// following (desired) behaviour: when an unknown/unavailable encoding is
// requested for the first time, the user is asked about a replacement,
// but if he doesn't choose any and the default logic finds one, it will
// be saved in the config so that the user won't be asked about it any
// more
bool TestAltEncoding(const wxString& configEntry,
wxFontEncoding encReplacement,
wxNativeEncodingInfo *info);
// the title for our dialogs
wxString m_titleDialog;
// the parent window for our dialogs
wxWindow *m_windowParent;
private:
wxDECLARE_NO_COPY_CLASS(wxFontMapper);
};
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// global variables
// ----------------------------------------------------------------------------
// the default font mapper for wxWidgets programs do NOT use! This is for
// backward compatibility, use wxFontMapper::Get() instead
#define wxTheFontMapper (wxFontMapper::Get())
#else // !wxUSE_FONTMAP
#if wxUSE_GUI
// wxEncodingToCodepage (utils.cpp) needs wxGetNativeFontEncoding
#include "wx/fontutil.h"
#endif
#endif // wxUSE_FONTMAP/!wxUSE_FONTMAP
#endif // _WX_FONTMAPPER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/image.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/image.h
// Purpose: wxImage class
// Author: Robert Roebling
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGE_H_
#define _WX_IMAGE_H_
#include "wx/defs.h"
#if wxUSE_IMAGE
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdicmn.h"
#include "wx/hashmap.h"
#include "wx/arrstr.h"
#if wxUSE_STREAMS
# include "wx/stream.h"
#endif
// on some systems (Unixware 7.x) index is defined as a macro in the headers
// which breaks the compilation below
#undef index
#define wxIMAGE_OPTION_QUALITY wxString(wxS("quality"))
#define wxIMAGE_OPTION_FILENAME wxString(wxS("FileName"))
#define wxIMAGE_OPTION_RESOLUTION wxString(wxS("Resolution"))
#define wxIMAGE_OPTION_RESOLUTIONX wxString(wxS("ResolutionX"))
#define wxIMAGE_OPTION_RESOLUTIONY wxString(wxS("ResolutionY"))
#define wxIMAGE_OPTION_RESOLUTIONUNIT wxString(wxS("ResolutionUnit"))
#define wxIMAGE_OPTION_MAX_WIDTH wxString(wxS("MaxWidth"))
#define wxIMAGE_OPTION_MAX_HEIGHT wxString(wxS("MaxHeight"))
#define wxIMAGE_OPTION_ORIGINAL_WIDTH wxString(wxS("OriginalWidth"))
#define wxIMAGE_OPTION_ORIGINAL_HEIGHT wxString(wxS("OriginalHeight"))
// constants used with wxIMAGE_OPTION_RESOLUTIONUNIT
//
// NB: don't change these values, they correspond to libjpeg constants
enum wxImageResolution
{
// Resolution not specified
wxIMAGE_RESOLUTION_NONE = 0,
// Resolution specified in inches
wxIMAGE_RESOLUTION_INCHES = 1,
// Resolution specified in centimeters
wxIMAGE_RESOLUTION_CM = 2
};
// Constants for wxImage::Scale() for determining the level of quality
enum wxImageResizeQuality
{
// different image resizing algorithms used by Scale() and Rescale()
wxIMAGE_QUALITY_NEAREST = 0,
wxIMAGE_QUALITY_BILINEAR = 1,
wxIMAGE_QUALITY_BICUBIC = 2,
wxIMAGE_QUALITY_BOX_AVERAGE = 3,
// default quality is low (but fast)
wxIMAGE_QUALITY_NORMAL = wxIMAGE_QUALITY_NEAREST,
// highest (but best) quality
wxIMAGE_QUALITY_HIGH = 4
};
// alpha channel values: fully transparent, default threshold separating
// transparent pixels from opaque for a few functions dealing with alpha and
// fully opaque
const unsigned char wxIMAGE_ALPHA_TRANSPARENT = 0;
const unsigned char wxIMAGE_ALPHA_THRESHOLD = 0x80;
const unsigned char wxIMAGE_ALPHA_OPAQUE = 0xff;
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxImageHandler;
class WXDLLIMPEXP_FWD_CORE wxImage;
class WXDLLIMPEXP_FWD_CORE wxPalette;
//-----------------------------------------------------------------------------
// wxVariant support
//-----------------------------------------------------------------------------
#if wxUSE_VARIANT
#include "wx/variant.h"
DECLARE_VARIANT_OBJECT_EXPORTED(wxImage,WXDLLIMPEXP_CORE)
#endif
//-----------------------------------------------------------------------------
// wxImageHandler
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxImageHandler: public wxObject
{
public:
wxImageHandler()
: m_name(wxEmptyString), m_extension(wxEmptyString), m_mime(), m_type(wxBITMAP_TYPE_INVALID)
{ }
#if wxUSE_STREAMS
// NOTE: LoadFile and SaveFile are not pure virtuals to allow derived classes
// to implement only one of the two
virtual bool LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream),
bool WXUNUSED(verbose)=true, int WXUNUSED(index)=-1 )
{ return false; }
virtual bool SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream),
bool WXUNUSED(verbose)=true )
{ return false; }
int GetImageCount( wxInputStream& stream );
// save the stream position, call DoGetImageCount() and restore the position
bool CanRead( wxInputStream& stream ) { return CallDoCanRead(stream); }
bool CanRead( const wxString& name );
#endif // wxUSE_STREAMS
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetAltExtensions(const wxArrayString& exts) { m_altExtensions = exts; }
void SetType(wxBitmapType type) { m_type = type; }
void SetMimeType(const wxString& type) { m_mime = type; }
const wxString& GetName() const { return m_name; }
const wxString& GetExtension() const { return m_extension; }
const wxArrayString& GetAltExtensions() const { return m_altExtensions; }
wxBitmapType GetType() const { return m_type; }
const wxString& GetMimeType() const { return m_mime; }
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED(
void SetType(long type) { SetType((wxBitmapType)type); }
)
#endif // WXWIN_COMPATIBILITY_2_8
protected:
#if wxUSE_STREAMS
// NOTE: this function is allowed to change the current stream position
// since GetImageCount() will take care of restoring it later
virtual int DoGetImageCount( wxInputStream& WXUNUSED(stream) )
{ return 1; } // default return value is 1 image
// NOTE: this function is allowed to change the current stream position
// since CallDoCanRead() will take care of restoring it later
virtual bool DoCanRead( wxInputStream& stream ) = 0;
// save the stream position, call DoCanRead() and restore the position
bool CallDoCanRead(wxInputStream& stream);
#endif // wxUSE_STREAMS
// helper for the derived classes SaveFile() implementations: returns the
// values of x- and y-resolution options specified as the image options if
// any
static wxImageResolution
GetResolutionFromOptions(const wxImage& image, int *x, int *y);
wxString m_name;
wxString m_extension;
wxArrayString m_altExtensions;
wxString m_mime;
wxBitmapType m_type;
private:
wxDECLARE_CLASS(wxImageHandler);
};
//-----------------------------------------------------------------------------
// wxImageHistogram
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxImageHistogramEntry
{
public:
wxImageHistogramEntry() { index = value = 0; }
unsigned long index;
unsigned long value;
};
WX_DECLARE_EXPORTED_HASH_MAP(unsigned long, wxImageHistogramEntry,
wxIntegerHash, wxIntegerEqual,
wxImageHistogramBase);
class WXDLLIMPEXP_CORE wxImageHistogram : public wxImageHistogramBase
{
public:
wxImageHistogram() : wxImageHistogramBase(256) { }
// get the key in the histogram for the given RGB values
static unsigned long MakeKey(unsigned char r,
unsigned char g,
unsigned char b)
{
return (r << 16) | (g << 8) | b;
}
// find first colour that is not used in the image and has higher
// RGB values than RGB(startR, startG, startB)
//
// returns true and puts this colour in r, g, b (each of which may be NULL)
// on success or returns false if there are no more free colours
bool FindFirstUnusedColour(unsigned char *r,
unsigned char *g,
unsigned char *b,
unsigned char startR = 1,
unsigned char startG = 0,
unsigned char startB = 0 ) const;
};
//-----------------------------------------------------------------------------
// wxImage
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxImage: public wxObject
{
public:
// red, green and blue are 8 bit unsigned integers in the range of 0..255
// We use the identifier RGBValue instead of RGB, since RGB is #defined
class RGBValue
{
public:
RGBValue(unsigned char r=0, unsigned char g=0, unsigned char b=0)
: red(r), green(g), blue(b) {}
unsigned char red;
unsigned char green;
unsigned char blue;
};
// hue, saturation and value are doubles in the range 0.0..1.0
class HSVValue
{
public:
HSVValue(double h=0.0, double s=0.0, double v=0.0)
: hue(h), saturation(s), value(v) {}
double hue;
double saturation;
double value;
};
wxImage() {}
wxImage( int width, int height, bool clear = true )
{ Create( width, height, clear ); }
wxImage( int width, int height, unsigned char* data, bool static_data = false )
{ Create( width, height, data, static_data ); }
wxImage( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data = false )
{ Create( width, height, data, alpha, static_data ); }
// ctor variants using wxSize:
wxImage( const wxSize& sz, bool clear = true )
{ Create( sz, clear ); }
wxImage( const wxSize& sz, unsigned char* data, bool static_data = false )
{ Create( sz, data, static_data ); }
wxImage( const wxSize& sz, unsigned char* data, unsigned char* alpha, bool static_data = false )
{ Create( sz, data, alpha, static_data ); }
wxImage( const wxString& name, wxBitmapType type = wxBITMAP_TYPE_ANY, int index = -1 )
{ LoadFile( name, type, index ); }
wxImage( const wxString& name, const wxString& mimetype, int index = -1 )
{ LoadFile( name, mimetype, index ); }
wxImage( const char* const* xpmData )
{ Create(xpmData); }
#if wxUSE_STREAMS
wxImage( wxInputStream& stream, wxBitmapType type = wxBITMAP_TYPE_ANY, int index = -1 )
{ LoadFile( stream, type, index ); }
wxImage( wxInputStream& stream, const wxString& mimetype, int index = -1 )
{ LoadFile( stream, mimetype, index ); }
#endif // wxUSE_STREAMS
bool Create( const char* const* xpmData );
#ifdef __BORLANDC__
// needed for Borland 5.5
wxImage( char** xpmData ) { Create(const_cast<const char* const*>(xpmData)); }
bool Create( char** xpmData ) { return Create(const_cast<const char* const*>(xpmData)); }
#endif
bool Create( int width, int height, bool clear = true );
bool Create( int width, int height, unsigned char* data, bool static_data = false );
bool Create( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data = false );
// Create() variants using wxSize:
bool Create( const wxSize& sz, bool clear = true )
{ return Create(sz.GetWidth(), sz.GetHeight(), clear); }
bool Create( const wxSize& sz, unsigned char* data, bool static_data = false )
{ return Create(sz.GetWidth(), sz.GetHeight(), data, static_data); }
bool Create( const wxSize& sz, unsigned char* data, unsigned char* alpha, bool static_data = false )
{ return Create(sz.GetWidth(), sz.GetHeight(), data, alpha, static_data); }
void Destroy();
// initialize the image data with zeroes
void Clear(unsigned char value = 0);
// creates an identical copy of the image (the = operator
// just raises the ref count)
wxImage Copy() const;
// return the new image with size width*height
wxImage GetSubImage( const wxRect& rect) const;
// Paste the image or part of this image into an image of the given size at the pos
// any newly exposed areas will be filled with the rgb colour
// by default if r = g = b = -1 then fill with this image's mask colour or find and
// set a suitable mask colour
wxImage Size( const wxSize& size, const wxPoint& pos,
int r = -1, int g = -1, int b = -1 ) const;
// pastes image into this instance and takes care of
// the mask colour and out of bounds problems
void Paste( const wxImage &image, int x, int y );
// return the new image with size width*height
wxImage Scale( int width, int height,
wxImageResizeQuality quality = wxIMAGE_QUALITY_NORMAL ) const;
// box averager and bicubic filters for up/down sampling
wxImage ResampleNearest(int width, int height) const;
wxImage ResampleBox(int width, int height) const;
wxImage ResampleBilinear(int width, int height) const;
wxImage ResampleBicubic(int width, int height) const;
// blur the image according to the specified pixel radius
wxImage Blur(int radius) const;
wxImage BlurHorizontal(int radius) const;
wxImage BlurVertical(int radius) const;
wxImage ShrinkBy( int xFactor , int yFactor ) const ;
// rescales the image in place
wxImage& Rescale( int width, int height,
wxImageResizeQuality quality = wxIMAGE_QUALITY_NORMAL )
{ return *this = Scale(width, height, quality); }
// resizes the image in place
wxImage& Resize( const wxSize& size, const wxPoint& pos,
int r = -1, int g = -1, int b = -1 ) { return *this = Size(size, pos, r, g, b); }
// Rotates the image about the given point, 'angle' radians.
// Returns the rotated image, leaving this image intact.
wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
bool interpolating = true, wxPoint * offset_after_rotation = NULL) const;
wxImage Rotate90( bool clockwise = true ) const;
wxImage Rotate180() const;
wxImage Mirror( bool horizontally = true ) const;
// replace one colour with another
void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
unsigned char r2, unsigned char g2, unsigned char b2 );
// Convert to greyscale image. Uses the luminance component (Y) of the image.
// The luma value (YUV) is calculated using (R * weight_r) + (G * weight_g) + (B * weight_b), defaults to ITU-T BT.601
wxImage ConvertToGreyscale(double weight_r, double weight_g, double weight_b) const;
wxImage ConvertToGreyscale(void) const;
// convert to monochrome image (<r,g,b> will be replaced by white,
// everything else by black)
wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;
// Convert to disabled (dimmed) image.
wxImage ConvertToDisabled(unsigned char brightness = 255) const;
// these routines are slow but safe
void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
void SetRGB( const wxRect& rect, unsigned char r, unsigned char g, unsigned char b );
unsigned char GetRed( int x, int y ) const;
unsigned char GetGreen( int x, int y ) const;
unsigned char GetBlue( int x, int y ) const;
void SetAlpha(int x, int y, unsigned char alpha);
unsigned char GetAlpha(int x, int y) const;
// find first colour that is not used in the image and has higher
// RGB values than <startR,startG,startB>
bool FindFirstUnusedColour( unsigned char *r, unsigned char *g, unsigned char *b,
unsigned char startR = 1, unsigned char startG = 0,
unsigned char startB = 0 ) const;
// Set image's mask to the area of 'mask' that has <r,g,b> colour
bool SetMaskFromImage(const wxImage & mask,
unsigned char mr, unsigned char mg, unsigned char mb);
// converts image's alpha channel to mask (choosing mask colour
// automatically or using the specified colour for the mask), if it has
// any, does nothing otherwise:
bool ConvertAlphaToMask(unsigned char threshold = wxIMAGE_ALPHA_THRESHOLD);
bool ConvertAlphaToMask(unsigned char mr, unsigned char mg, unsigned char mb,
unsigned char threshold = wxIMAGE_ALPHA_THRESHOLD);
// This method converts an image where the original alpha
// information is only available as a shades of a colour
// (actually shades of grey) typically when you draw anti-
// aliased text into a bitmap. The DC drawinf routines
// draw grey values on the black background although they
// actually mean to draw white with differnt alpha values.
// This method reverses it, assuming a black (!) background
// and white text (actually only the red channel is read).
// The method will then fill up the whole image with the
// colour given.
bool ConvertColourToAlpha( unsigned char r, unsigned char g, unsigned char b );
// Methods for controlling LoadFile() behaviour. Currently they allow to
// specify whether the function should log warnings if there are any
// problems with the image file not completely preventing it from being
// loaded. By default the warnings are logged, but this can be disabled
// either globally or for a particular image object.
enum
{
Load_Verbose = 1
};
static void SetDefaultLoadFlags(int flags);
static int GetDefaultLoadFlags();
void SetLoadFlags(int flags);
int GetLoadFlags() const;
static bool CanRead( const wxString& name );
static int GetImageCount( const wxString& name, wxBitmapType type = wxBITMAP_TYPE_ANY );
virtual bool LoadFile( const wxString& name, wxBitmapType type = wxBITMAP_TYPE_ANY, int index = -1 );
virtual bool LoadFile( const wxString& name, const wxString& mimetype, int index = -1 );
#if wxUSE_STREAMS
static bool CanRead( wxInputStream& stream );
static int GetImageCount( wxInputStream& stream, wxBitmapType type = wxBITMAP_TYPE_ANY );
virtual bool LoadFile( wxInputStream& stream, wxBitmapType type = wxBITMAP_TYPE_ANY, int index = -1 );
virtual bool LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 );
#endif
virtual bool SaveFile( const wxString& name ) const;
virtual bool SaveFile( const wxString& name, wxBitmapType type ) const;
virtual bool SaveFile( const wxString& name, const wxString& mimetype ) const;
#if wxUSE_STREAMS
virtual bool SaveFile( wxOutputStream& stream, wxBitmapType type ) const;
virtual bool SaveFile( wxOutputStream& stream, const wxString& mimetype ) const;
#endif
bool Ok() const { return IsOk(); }
bool IsOk() const;
int GetWidth() const;
int GetHeight() const;
wxSize GetSize() const
{ return wxSize(GetWidth(), GetHeight()); }
// Gets the type of image found by LoadFile or specified with SaveFile
wxBitmapType GetType() const;
// Set the image type, this is normally only called if the image is being
// created from data in the given format but not using LoadFile() (e.g.
// wxGIFDecoder uses this)
void SetType(wxBitmapType type);
// these functions provide fastest access to wxImage data but should be
// used carefully as no checks are done
unsigned char *GetData() const;
void SetData( unsigned char *data, bool static_data=false );
void SetData( unsigned char *data, int new_width, int new_height, bool static_data=false );
unsigned char *GetAlpha() const; // may return NULL!
bool HasAlpha() const { return GetAlpha() != NULL; }
void SetAlpha(unsigned char *alpha = NULL, bool static_data=false);
void InitAlpha();
void ClearAlpha();
// return true if this pixel is masked or has alpha less than specified
// threshold
bool IsTransparent(int x, int y,
unsigned char threshold = wxIMAGE_ALPHA_THRESHOLD) const;
// Mask functions
void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
// Get the current mask colour or find a suitable colour
// returns true if using current mask colour
bool GetOrFindMaskColour( unsigned char *r, unsigned char *g, unsigned char *b ) const;
unsigned char GetMaskRed() const;
unsigned char GetMaskGreen() const;
unsigned char GetMaskBlue() const;
void SetMask( bool mask = true );
bool HasMask() const;
#if wxUSE_PALETTE
// Palette functions
bool HasPalette() const;
const wxPalette& GetPalette() const;
void SetPalette(const wxPalette& palette);
#endif // wxUSE_PALETTE
// Option functions (arbitrary name/value mapping)
void SetOption(const wxString& name, const wxString& value);
void SetOption(const wxString& name, int value);
wxString GetOption(const wxString& name) const;
int GetOptionInt(const wxString& name) const;
bool HasOption(const wxString& name) const;
unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 ) const;
// Computes the histogram of the image and fills a hash table, indexed
// with integer keys built as 0xRRGGBB, containing wxImageHistogramEntry
// objects. Each of them contains an 'index' (useful to build a palette
// with the image colours) and a 'value', which is the number of pixels
// in the image with that colour.
// Returned value: # of entries in the histogram
unsigned long ComputeHistogram( wxImageHistogram &h ) const;
// Rotates the hue of each pixel of the image. angle is a double in the range
// -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
void RotateHue(double angle);
static wxList& GetHandlers() { return sm_handlers; }
static void AddHandler( wxImageHandler *handler );
static void InsertHandler( wxImageHandler *handler );
static bool RemoveHandler( const wxString& name );
static wxImageHandler *FindHandler( const wxString& name );
static wxImageHandler *FindHandler( const wxString& extension, wxBitmapType imageType );
static wxImageHandler *FindHandler( wxBitmapType imageType );
static wxImageHandler *FindHandlerMime( const wxString& mimetype );
static wxString GetImageExtWildcard();
static void CleanUpHandlers();
static void InitStandardHandlers();
static HSVValue RGBtoHSV(const RGBValue& rgb);
static RGBValue HSVtoRGB(const HSVValue& hsv);
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR(
wxImage(const wxString& name, long type, int index = -1)
{
LoadFile(name, (wxBitmapType)type, index);
}
)
#if wxUSE_STREAMS
wxDEPRECATED_CONSTRUCTOR(
wxImage(wxInputStream& stream, long type, int index = -1)
{
LoadFile(stream, (wxBitmapType)type, index);
}
)
wxDEPRECATED(
bool LoadFile(wxInputStream& stream, long type, int index = -1)
{
return LoadFile(stream, (wxBitmapType)type, index);
}
)
wxDEPRECATED(
bool SaveFile(wxOutputStream& stream, long type) const
{
return SaveFile(stream, (wxBitmapType)type);
}
)
#endif // wxUSE_STREAMS
wxDEPRECATED(
bool LoadFile(const wxString& name, long type, int index = -1)
{
return LoadFile(name, (wxBitmapType)type, index);
}
)
wxDEPRECATED(
bool SaveFile(const wxString& name, long type) const
{
return SaveFile(name, (wxBitmapType)type);
}
)
static wxDEPRECATED(
wxImageHandler *FindHandler(const wxString& ext, long type)
{
return FindHandler(ext, (wxBitmapType)type);
}
)
static wxDEPRECATED(
wxImageHandler *FindHandler(long imageType)
{
return FindHandler((wxBitmapType)imageType);
}
)
#endif // WXWIN_COMPATIBILITY_2_8
protected:
static wxList sm_handlers;
// return the index of the point with the given coordinates or -1 if the
// image is invalid of the coordinates are out of range
//
// note that index must be multiplied by 3 when using it with RGB array
long XYToIndex(int x, int y) const;
virtual wxObjectRefData* CreateRefData() const wxOVERRIDE;
virtual wxObjectRefData* CloneRefData(const wxObjectRefData* data) const wxOVERRIDE;
private:
friend class WXDLLIMPEXP_FWD_CORE wxImageHandler;
// Possible values for MakeEmptyClone() flags.
enum
{
// Create an image with the same orientation as this one. This is the
// default and only exists for symmetry with SwapOrientation.
Clone_SameOrientation = 0,
// Create an image with the same height as this image width and the
// same width as this image height.
Clone_SwapOrientation = 1
};
// Returns a new blank image with the same dimensions (or with width and
// height swapped if Clone_SwapOrientation flag is given), alpha, and mask
// as this image itself. This is used by several functions creating
// modified versions of this image.
wxImage MakeEmptyClone(int flags = Clone_SameOrientation) const;
#if wxUSE_STREAMS
// read the image from the specified stream updating image type if
// successful
bool DoLoad(wxImageHandler& handler, wxInputStream& stream, int index);
// write the image to the specified stream and also update the image type
// if successful
bool DoSave(wxImageHandler& handler, wxOutputStream& stream) const;
#endif // wxUSE_STREAMS
wxDECLARE_DYNAMIC_CLASS(wxImage);
};
extern void WXDLLIMPEXP_CORE wxInitAllImageHandlers();
extern WXDLLIMPEXP_DATA_CORE(wxImage) wxNullImage;
//-----------------------------------------------------------------------------
// wxImage handlers
//-----------------------------------------------------------------------------
#include "wx/imagbmp.h"
#include "wx/imagpng.h"
#include "wx/imaggif.h"
#include "wx/imagpcx.h"
#include "wx/imagjpeg.h"
#include "wx/imagtga.h"
#include "wx/imagtiff.h"
#include "wx/imagpnm.h"
#include "wx/imagxpm.h"
#include "wx/imagiff.h"
#endif // wxUSE_IMAGE
#endif
// _WX_IMAGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/statusbr.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/statusbr.h
// Purpose: wxStatusBar class interface
// Author: Vadim Zeitlin
// Modified by:
// Created: 05.02.00
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATUSBR_H_BASE_
#define _WX_STATUSBR_H_BASE_
#include "wx/defs.h"
#if wxUSE_STATUSBAR
#include "wx/control.h"
#include "wx/list.h"
#include "wx/dynarray.h"
extern WXDLLIMPEXP_DATA_CORE(const char) wxStatusBarNameStr[];
// ----------------------------------------------------------------------------
// wxStatusBar constants
// ----------------------------------------------------------------------------
// wxStatusBar styles
#define wxSTB_SIZEGRIP 0x0010
#define wxSTB_SHOW_TIPS 0x0020
#define wxSTB_ELLIPSIZE_START 0x0040
#define wxSTB_ELLIPSIZE_MIDDLE 0x0080
#define wxSTB_ELLIPSIZE_END 0x0100
#define wxSTB_DEFAULT_STYLE (wxSTB_SIZEGRIP|wxSTB_ELLIPSIZE_END|wxSTB_SHOW_TIPS|wxFULL_REPAINT_ON_RESIZE)
// old compat style name:
#define wxST_SIZEGRIP wxSTB_SIZEGRIP
// style flags for wxStatusBar fields
#define wxSB_NORMAL 0x0000
#define wxSB_FLAT 0x0001
#define wxSB_RAISED 0x0002
#define wxSB_SUNKEN 0x0003
// ----------------------------------------------------------------------------
// wxStatusBarPane: an helper for wxStatusBar
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStatusBarPane
{
public:
wxStatusBarPane(int style = wxSB_NORMAL, int width = 0)
: m_nStyle(style), m_nWidth(width)
{ m_bEllipsized = false; }
int GetWidth() const { return m_nWidth; }
int GetStyle() const { return m_nStyle; }
wxString GetText() const { return m_text; }
// implementation-only from now on
// -------------------------------
bool IsEllipsized() const
{ return m_bEllipsized; }
void SetIsEllipsized(bool isEllipsized) { m_bEllipsized = isEllipsized; }
void SetWidth(int width) { m_nWidth = width; }
void SetStyle(int style) { m_nStyle = style; }
// set text, return true if it changed or false if it was already set to
// this value
bool SetText(const wxString& text);
// save the existing text on top of our stack and make the new text
// current; return true if the text really changed
bool PushText(const wxString& text);
// restore the message saved by the last call to Push() (unless it was
// changed by an intervening call to SetText()) and return true if we
// really restored anything
bool PopText();
private:
int m_nStyle;
int m_nWidth; // may be negative, indicating a variable-width field
wxString m_text;
// the array used to keep the previous values of this pane after a
// PushStatusText() call, its top element is the value to restore after the
// next PopStatusText() call while the currently shown value is always in
// m_text
wxArrayString m_arrStack;
// is the currently shown value shown with ellipsis in the status bar?
bool m_bEllipsized;
};
WX_DECLARE_EXPORTED_OBJARRAY(wxStatusBarPane, wxStatusBarPaneArray);
// ----------------------------------------------------------------------------
// wxStatusBar: a window near the bottom of the frame used for status info
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStatusBarBase : public wxControl
{
public:
wxStatusBarBase();
virtual ~wxStatusBarBase();
// field count
// -----------
// set the number of fields and call SetStatusWidths(widths) if widths are
// given
virtual void SetFieldsCount(int number = 1, const int *widths = NULL);
int GetFieldsCount() const { return (int)m_panes.GetCount(); }
// field text
// ----------
// just change or get the currently shown text
void SetStatusText(const wxString& text, int number = 0);
wxString GetStatusText(int number = 0) const;
// change the currently shown text to the new one and save the current
// value to be restored by the next call to PopStatusText()
void PushStatusText(const wxString& text, int number = 0);
void PopStatusText(int number = 0);
// fields widths
// -------------
// set status field widths as absolute numbers: positive widths mean that
// the field has the specified absolute width, negative widths are
// interpreted as the sizer options, i.e. the extra space (total space
// minus the sum of fixed width fields) is divided between the fields with
// negative width according to the abs value of the width (field with width
// -2 grows twice as much as one with width -1 &c)
virtual void SetStatusWidths(int n, const int widths[]);
int GetStatusWidth(int n) const
{ return m_panes[n].GetWidth(); }
// field styles
// ------------
// Set the field border style to one of wxSB_XXX values.
virtual void SetStatusStyles(int n, const int styles[]);
int GetStatusStyle(int n) const
{ return m_panes[n].GetStyle(); }
// geometry
// --------
// Get the position and size of the field's internal bounding rectangle
virtual bool GetFieldRect(int i, wxRect& rect) const = 0;
// sets the minimal vertical size of the status bar
virtual void SetMinHeight(int height) = 0;
// get the dimensions of the horizontal and vertical borders
virtual int GetBorderX() const = 0;
virtual int GetBorderY() const = 0;
wxSize GetBorders() const
{ return wxSize(GetBorderX(), GetBorderY()); }
// miscellaneous
// -------------
const wxStatusBarPane& GetField(int n) const
{ return m_panes[n]; }
// wxWindow overrides:
// don't want status bars to accept the focus at all
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
// the client size of a toplevel window doesn't include the status bar
virtual bool CanBeOutsideClientArea() const wxOVERRIDE { return true; }
protected:
// called after the status bar pane text changed and should update its
// display
virtual void DoUpdateStatusText(int number) = 0;
// wxWindow overrides:
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE
{
wxASSERT_MSG(!HasFlag(wxSTB_SHOW_TIPS),
"Do not set tooltip(s) manually when using wxSTB_SHOW_TIPS!");
wxWindow::DoSetToolTip(tip);
}
#endif // wxUSE_TOOLTIPS
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// internal helpers & data:
// calculate the real field widths for the given total available size
wxArrayInt CalculateAbsWidths(wxCoord widthTotal) const;
// should be called to remember if the pane text is currently being show
// ellipsized or not
void SetEllipsizedFlag(int n, bool isEllipsized);
// the array with the pane infos:
wxStatusBarPaneArray m_panes;
// if true overrides the width info of the wxStatusBarPanes
bool m_bSameWidthForAllPanes;
wxDECLARE_NO_COPY_CLASS(wxStatusBarBase);
};
// ----------------------------------------------------------------------------
// include the actual wxStatusBar class declaration
// ----------------------------------------------------------------------------
#if defined(__WXUNIVERSAL__)
#define wxStatusBarUniv wxStatusBar
#include "wx/univ/statusbr.h"
#elif defined(__WXMSW__) && wxUSE_NATIVE_STATUSBAR
#include "wx/msw/statusbar.h"
#elif defined(__WXMAC__)
#define wxStatusBarMac wxStatusBar
#include "wx/generic/statusbr.h"
#include "wx/osx/statusbr.h"
#elif defined(__WXQT__)
#include "wx/qt/statusbar.h"
#else
#define wxStatusBarGeneric wxStatusBar
#include "wx/generic/statusbr.h"
#endif
#endif // wxUSE_STATUSBAR
#endif
// _WX_STATUSBR_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/xtixml.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xtixml.h
// Purpose: xml streaming runtime metadata information (extended class info)
// Author: Stefan Csomor
// Modified by:
// Created: 27/07/03
// Copyright: (c) 2003 Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XTIXMLH__
#define _WX_XTIXMLH__
#include "wx/defs.h"
#if wxUSE_EXTENDED_RTTI
#include "wx/string.h"
#include "wx/xtistrm.h"
/*
class WXDLLIMPEXP_XML wxXmlNode;
class WXDLLIMPEXP_BASE wxPropertyInfo;
class WXDLLIMPEXP_BASE wxObject;
class WXDLLIMPEXP_BASE wxClassInfo;
class WXDLLIMPEXP_BASE wxAnyList;
class WXDLLIMPEXP_BASE wxHandlerInfo;
class WXDLLIMPEXP_BASE wxObjectWriterCallback;
*/
class WXDLLIMPEXP_XML wxObjectXmlWriter: public wxObjectWriter
{
public:
wxObjectXmlWriter( wxXmlNode * parent );
virtual ~wxObjectXmlWriter();
//
// streaming callbacks
//
// these callbacks really write out the values in the stream format
//
//
// streaming callbacks
//
// these callbacks really write out the values in the stream format
// begins writing out a new toplevel entry which has the indicated unique name
virtual void DoBeginWriteTopLevelEntry( const wxString &name );
// ends writing out a new toplevel entry which has the indicated unique name
virtual void DoEndWriteTopLevelEntry( const wxString &name );
// start of writing an object having the passed in ID
virtual void DoBeginWriteObject(const wxObject *object,
const wxClassInfo *classInfo, int objectID, const wxStringToAnyHashMap &metadata );
// end of writing an toplevel object name param is used for unique
// identification within the container
virtual void DoEndWriteObject(const wxObject *object,
const wxClassInfo *classInfo, int objectID );
// writes a simple property in the stream format
virtual void DoWriteSimpleType( const wxAny &value );
// start of writing a complex property into the stream (
virtual void DoBeginWriteProperty( const wxPropertyInfo *propInfo );
// end of writing a complex property into the stream
virtual void DoEndWriteProperty( const wxPropertyInfo *propInfo );
virtual void DoBeginWriteElement();
virtual void DoEndWriteElement();
// insert an object reference to an already written object
virtual void DoWriteRepeatedObject( int objectID );
// insert a null reference
virtual void DoWriteNullObject();
// writes a delegate in the stream format
virtual void DoWriteDelegate( const wxObject *object,
const wxClassInfo* classInfo, const wxPropertyInfo *propInfo,
const wxObject *eventSink, int sinkObjectID,
const wxClassInfo* eventSinkClassInfo, const wxHandlerInfo* handlerIndo );
private:
struct wxObjectXmlWriterInternal;
wxObjectXmlWriterInternal* m_data;
};
/*
wxObjectXmlReader handles streaming in a class from XML
*/
class WXDLLIMPEXP_XML wxObjectXmlReader: public wxObjectReader
{
public:
wxObjectXmlReader(wxXmlNode *parent) { m_parent = parent; }
virtual ~wxObjectXmlReader() {}
// Reads a component from XML. The return value is the root object ID, which can
// then be used to ask the readercallback about that object
virtual int ReadObject( const wxString &name, wxObjectReaderCallback *readercallback );
private:
int ReadComponent(wxXmlNode *parent, wxObjectReaderCallback *callbacks);
// read the content of this node (simple type) and return the corresponding value
wxAny ReadValue(wxXmlNode *Node, const wxTypeInfo *type );
wxXmlNode * m_parent;
};
#endif // wxUSE_EXTENDED_RTTI
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/memtext.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/memtext.h
// Purpose: wxMemoryText allows to use wxTextBuffer without a file
// Created: 14.11.01
// Author: Morten Hanssen
// Copyright: (c) 2001 Morten Hanssen
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MEMTEXT_H
#define _WX_MEMTEXT_H
#include "wx/defs.h"
// there is no separate setting for wxMemoryText, it's smallish anyhow
#if wxUSE_TEXTBUFFER
// ----------------------------------------------------------------------------
// wxMemoryText
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxMemoryText : public wxTextBuffer
{
public:
// Constructors.
wxMemoryText() { }
wxMemoryText(const wxString& name) : wxTextBuffer(name) { }
protected:
virtual bool OnExists() const wxOVERRIDE
{ return false; }
virtual bool OnOpen(const wxString & WXUNUSED(strBufferName),
wxTextBufferOpenMode WXUNUSED(OpenMode)) wxOVERRIDE
{ return true; }
virtual bool OnClose() wxOVERRIDE
{ return true; }
virtual bool OnRead(const wxMBConv& WXUNUSED(conv)) wxOVERRIDE
{ return true; }
virtual bool OnWrite(wxTextFileType WXUNUSED(typeNew),
const wxMBConv& WXUNUSED(conv) = wxMBConvUTF8()) wxOVERRIDE
{ return true; }
private:
wxDECLARE_NO_COPY_CLASS(wxMemoryText);
};
#endif // wxUSE_TEXTBUFFER
#endif // _WX_MEMTEXT_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/debug.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/debug.h
// Purpose: Misc debug functions and macros
// Author: Vadim Zeitlin
// Created: 29/01/98
// Copyright: (c) 1998-2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DEBUG_H_
#define _WX_DEBUG_H_
#include <assert.h>
#include <limits.h> // for CHAR_BIT used below
#include "wx/chartype.h" // for __TFILE__ and wxChar
#include "wx/cpp.h" // for __WXFUNCTION__
#include "wx/dlimpexp.h" // for WXDLLIMPEXP_FWD_BASE
class WXDLLIMPEXP_FWD_BASE wxString;
class WXDLLIMPEXP_FWD_BASE wxCStrData;
// ----------------------------------------------------------------------------
// Defines controlling the debugging macros
// ----------------------------------------------------------------------------
/*
wxWidgets can be built with several different levels of debug support
specified by the value of wxDEBUG_LEVEL constant:
0: No assertion macros at all, this should only be used when optimizing
for resource-constrained systems (typically embedded ones).
1: Default level, most of the assertions are enabled.
2: Maximal (at least for now): asserts which are "expensive"
(performance-wise) or only make sense for finding errors in wxWidgets
itself, as opposed to bugs in applications using it, are also enabled.
*/
// unless wxDEBUG_LEVEL is predefined (by configure or via wx/setup.h under
// Windows), use the default
#if !defined(wxDEBUG_LEVEL)
#define wxDEBUG_LEVEL 1
#endif // !defined(wxDEBUG_LEVEL)
/*
__WXDEBUG__ is defined when wxDEBUG_LEVEL != 0. This is done mostly for
compatibility but it also provides a simpler way to check if asserts and
debug logging is enabled at all.
*/
#if wxDEBUG_LEVEL > 0
#ifndef __WXDEBUG__
#define __WXDEBUG__
#endif
#else
#undef __WXDEBUG__
#endif
// Finally there is also a very old WXDEBUG macro not used anywhere at all, it
// is only defined for compatibility.
#ifdef __WXDEBUG__
#if !defined(WXDEBUG) || !WXDEBUG
#undef WXDEBUG
#define WXDEBUG 1
#endif // !WXDEBUG
#endif // __WXDEBUG__
// ----------------------------------------------------------------------------
// Handling assertion failures
// ----------------------------------------------------------------------------
/*
Type for the function called in case of assert failure, see
wxSetAssertHandler().
*/
typedef void (*wxAssertHandler_t)(const wxString& file,
int line,
const wxString& func,
const wxString& cond,
const wxString& msg);
#if wxDEBUG_LEVEL
// the global assert handler function, if it is NULL asserts don't check their
// conditions
extern WXDLLIMPEXP_DATA_BASE(wxAssertHandler_t) wxTheAssertHandler;
/*
Sets the function to be called in case of assertion failure.
The default assert handler forwards to wxApp::OnAssertFailure() whose
default behaviour is, in turn, to show the standard assertion failure
dialog if a wxApp object exists or shows the same dialog itself directly
otherwise.
While usually it is enough -- and more convenient -- to just override
OnAssertFailure(), to handle all assertion failures, including those
occurring even before wxApp object creation or after its destruction you
need to provide your assertion handler function.
This function also provides a simple way to disable all asserts: simply
pass NULL pointer to it. Doing this will result in not even evaluating
assert conditions at all, avoiding almost all run-time cost of asserts.
Notice that this function is not MT-safe, so you should call it before
starting any other threads.
The return value of this function is the previous assertion handler. It can
be called after any pre-processing by your handler and can also be restored
later if you uninstall your handler.
*/
inline wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t handler)
{
const wxAssertHandler_t old = wxTheAssertHandler;
wxTheAssertHandler = handler;
return old;
}
/*
Reset the default assert handler.
This may be used to enable asserts, which are disabled by default in this
case, for programs built in release build (NDEBUG defined).
*/
extern void WXDLLIMPEXP_BASE wxSetDefaultAssertHandler();
#else // !wxDEBUG_LEVEL
// provide empty stubs in case assertions are completely disabled
//
// NB: can't use WXUNUSED() here as we're included from wx/defs.h before it is
// defined
inline wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t /* handler */)
{
return NULL;
}
inline void wxSetDefaultAssertHandler() { }
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
// simply a synonym for wxSetAssertHandler(NULL)
inline void wxDisableAsserts() { wxSetAssertHandler(NULL); }
/*
A macro which disables asserts for applications compiled in release build.
By default, wxIMPLEMENT_APP (or rather wxIMPLEMENT_WXWIN_MAIN) disable the
asserts in the applications compiled in the release build by calling this.
It does nothing if NDEBUG is not defined.
*/
#ifdef NDEBUG
#define wxDISABLE_ASSERTS_IN_RELEASE_BUILD() wxDisableAsserts()
#else
#define wxDISABLE_ASSERTS_IN_RELEASE_BUILD()
#endif
#if wxDEBUG_LEVEL
/*
wxOnAssert() is used by the debugging macros defined below. Different
overloads are needed because these macros can be used with or without wxT().
All of them are implemented in src/common/appcmn.cpp and unconditionally
call wxTheAssertHandler so the caller must check that it is non-NULL
(assert macros do it).
*/
#if wxUSE_UNICODE
// these overloads are the ones typically used by debugging macros: we have to
// provide wxChar* msg version because it's common to use wxT() in the macros
// and finally, we can't use const wx(char)* msg = NULL, because that would
// be ambiguous
//
// also notice that these functions can't be inline as wxString is not defined
// yet (and can't be as wxString code itself may use assertions)
extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file,
int line,
const char *func,
const char *cond);
extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const char *msg);
extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxChar *msg) ;
#endif /* wxUSE_UNICODE */
// this version is for compatibility with wx 2.8 Unicode build only, we don't
// use it ourselves any more except in ANSI-only build in which case it is all
// we need
extern WXDLLIMPEXP_BASE void wxOnAssert(const wxChar *file,
int line,
const char *func,
const wxChar *cond,
const wxChar *msg = NULL);
// these overloads work when msg passed to debug macro is a string and we
// also have to provide wxCStrData overload to resolve ambiguity which would
// otherwise arise from wxASSERT( s.c_str() )
extern WXDLLIMPEXP_BASE void wxOnAssert(const wxString& file,
int line,
const wxString& func,
const wxString& cond,
const wxString& msg);
extern WXDLLIMPEXP_BASE void wxOnAssert(const wxString& file,
int line,
const wxString& func,
const wxString& cond);
extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxCStrData& msg);
extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxString& msg);
#endif // wxDEBUG_LEVEL
// ----------------------------------------------------------------------------
// Debugging macros
// ----------------------------------------------------------------------------
/*
Assertion macros: check if the condition is true and call assert handler
(which will by default notify the user about failure) if it isn't.
wxASSERT and wxFAIL macros as well as wxTrap() function do nothing at all
if wxDEBUG_LEVEL is 0 however they do check their conditions at default
debug level 1, unlike the previous wxWidgets versions.
wxASSERT_LEVEL_2 is meant to be used for "expensive" asserts which should
normally be disabled because they have a big impact on performance and so
this macro only does anything if wxDEBUG_LEVEL >= 2.
*/
#if wxDEBUG_LEVEL
// wxTrap() can be used to break into the debugger unconditionally
// (assuming the program is running under debugger, of course).
//
// If possible, we prefer to define it as a macro rather than as a function
// to open the debugger at the position where we trapped and not inside the
// trap function itself which is not very useful.
#ifdef __VISUALC__
#define wxTrap() __debugbreak()
#elif defined(__GNUC__)
#if defined(__i386) || defined(__x86_64)
#define wxTrap() asm volatile ("int $3")
#endif
#endif
#ifndef wxTrap
// For all the other cases, use a generic function.
extern WXDLLIMPEXP_BASE void wxTrap();
#endif
// Global flag used to indicate that assert macros should call wxTrap(): it
// is set by the default assert handler if the user answers yes to the
// question of whether to trap.
extern WXDLLIMPEXP_DATA_BASE(bool) wxTrapInAssert;
// This macro checks if the condition is true and calls the assert handler
// with the provided message if it isn't and finally traps if the special
// flag indicating that it should do it was set by the handler.
//
// Notice that we don't use the handler return value for compatibility
// reasons (if we changed its return type, we'd need to change wxApp::
// OnAssertFailure() too which would break user code overriding it), hence
// the need for the ugly global flag.
#define wxASSERT_MSG_AT(cond, msg, file, line, func) \
wxSTATEMENT_MACRO_BEGIN \
if ( wxTheAssertHandler && !(cond) && \
(wxOnAssert(file, line, func, #cond, msg), \
wxTrapInAssert) ) \
{ \
wxTrapInAssert = false; \
wxTrap(); \
} \
wxSTATEMENT_MACRO_END
// A version asserting at the current location.
#define wxASSERT_MSG(cond, msg) \
wxASSERT_MSG_AT(cond, msg, __FILE__, __LINE__, __WXFUNCTION__)
// a version without any additional message, don't use unless condition
// itself is fully self-explanatory
#define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
// wxFAIL is a special form of assert: it always triggers (and so is
// usually used in normally unreachable code)
#define wxFAIL_COND_MSG_AT(cond, msg, file, line, func) \
wxSTATEMENT_MACRO_BEGIN \
if ( wxTheAssertHandler && \
(wxOnAssert(file, line, func, #cond, msg), \
wxTrapInAssert) ) \
{ \
wxTrapInAssert = false; \
wxTrap(); \
} \
wxSTATEMENT_MACRO_END
#define wxFAIL_MSG_AT(msg, file, line, func) \
wxFAIL_COND_MSG_AT("Assert failure", msg, file, line, func)
#define wxFAIL_COND_MSG(cond, msg) \
wxFAIL_COND_MSG_AT(cond, msg, __FILE__, __LINE__, __WXFUNCTION__)
#define wxFAIL_MSG(msg) wxFAIL_COND_MSG("Assert failure", msg)
#define wxFAIL wxFAIL_MSG((const char*)NULL)
#else // !wxDEBUG_LEVEL
#define wxTrap()
#define wxASSERT(cond)
#define wxASSERT_MSG(cond, msg)
#define wxFAIL
#define wxFAIL_MSG(msg)
#define wxFAIL_COND_MSG(cond, msg)
#endif // wxDEBUG_LEVEL
#if wxDEBUG_LEVEL >= 2
#define wxASSERT_LEVEL_2_MSG(cond, msg) wxASSERT_MSG(cond, msg)
#define wxASSERT_LEVEL_2(cond) wxASSERT(cond)
#else // wxDEBUG_LEVEL < 2
#define wxASSERT_LEVEL_2_MSG(cond, msg)
#define wxASSERT_LEVEL_2(cond)
#endif
// This is simply a wrapper for the standard abort() which is not available
// under all platforms.
//
// It isn't really debug-related but there doesn't seem to be any better place
// for it, so declare it here and define it in appbase.cpp, together with
// wxTrap().
extern void WXDLLIMPEXP_BASE wxAbort();
/*
wxCHECK macros always check their conditions, setting debug level to 0 only
makes them silent in case of failure, otherwise -- including at default
debug level 1 -- they call the assert handler if the condition is false
They are supposed to be used only in invalid situation: for example, an
invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
dereferencing it and causing core dump the function might use
wxCHECK_RET( p != NULL, "pointer can't be NULL" )
*/
// the generic macro: takes the condition to check, the statement to be executed
// in case the condition is false and the message to pass to the assert handler
#define wxCHECK2_MSG(cond, op, msg) \
if ( cond ) \
{} \
else \
{ \
wxFAIL_COND_MSG(#cond, msg); \
op; \
} \
struct wxDummyCheckStruct /* just to force a semicolon */
// check which returns with the specified return code if the condition fails
#define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
// check that expression is true, "return" if not (also FAILs in debug mode)
#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
// check that expression is true, perform op if not
#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
// special form of wxCHECK2: as wxCHECK, but for use in void functions
//
// NB: there is only one form (with msg parameter) and it's intentional:
// there is no other way to tell the caller what exactly went wrong
// from the void function (of course, the function shouldn't be void
// to begin with...)
#define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
// ----------------------------------------------------------------------------
// Compile time asserts
//
// Unlike the normal assert and related macros above which are checked during
// the program run-time the macros below will result in a compilation error if
// the condition they check is false. This is usually used to check the
// expressions containing sizeof()s which cannot be tested with the
// preprocessor. If you can use the #if's, do use them as you can give a more
// detailed error message then.
// ----------------------------------------------------------------------------
/*
How this works (you don't have to understand it to be able to use the
macros): we rely on the fact that it is invalid to define a named bit field
in a struct of width 0. All the rest are just the hacks to minimize the
possibility of the compiler warnings when compiling this macro: in
particular, this is why we define a struct and not an object (which would
result in a warning about unused variable) and a named struct (otherwise we'd
get a warning about an unnamed struct not used to define an object!).
*/
#define wxMAKE_UNIQUE_ASSERT_NAME wxMAKE_UNIQUE_NAME(wxAssert_)
/*
The second argument of this macro must be a valid C++ identifier and not a
string. I.e. you should use it like this:
wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
It may be used both within a function and in the global scope.
*/
#if defined( __VMS )
namespace wxdebug{
// HP aCC cannot deal with missing names for template value parameters
template <bool x> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
// HP aCC cannot deal with missing names for template value parameters
template<int x> struct static_assert_test{};
}
#define WX_JOIN( X, Y ) X##Y
#define WX_STATIC_ASSERT_BOOL_CAST(x) (bool)(x)
#define wxCOMPILE_TIME_ASSERT(expr, msg) \
typedef ::wxdebug::static_assert_test<\
sizeof(::wxdebug::STATIC_ASSERTION_FAILURE< WX_STATIC_ASSERT_BOOL_CAST( expr ) >)>\
WX_JOIN(wx_static_assert_typedef_, __LINE__)
#else
#define wxCOMPILE_TIME_ASSERT(expr, msg) \
struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
#endif
/*
When using VC++ 6 with "Edit and Continue" on, the compiler completely
mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
way to make "unique" assert names by specifying a unique prefix explicitly
*/
#define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
#define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
// helpers for wxCOMPILE_TIME_ASSERT below, for private use only
#define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
// a special case of compile time assert: check that the size of the given type
// is at least the given number of bits
#define wxASSERT_MIN_BITSIZE(type, size) \
wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
wxMAKE_BITSIZE_MSG(type, size))
// ----------------------------------------------------------------------------
// other miscellaneous debugger-related functions
// ----------------------------------------------------------------------------
/*
Return true if we're running under debugger.
Currently only really works under Win32 and just returns false elsewhere.
*/
#if defined(__WIN32__)
extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
#else // !Mac
inline bool wxIsDebuggerRunning() { return false; }
#endif // Mac/!Mac
// An assert helper used to avoid warning when testing constant expressions,
// i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about
// expression being always true, but not using
// wxASSERT( wxAssertIsEqual(sizeof(int), 4) )
//
// NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no
// longer be used.
extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
// Use of wxFalse instead of false suppresses compiler warnings about testing
// constant expression
extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
#define wxAssertFailure wxFalse
// This is similar to WXUNUSED() and useful for parameters which are only used
// in assertions.
#if wxDEBUG_LEVEL
#define WXUNUSED_UNLESS_DEBUG(param) param
#else
#define WXUNUSED_UNLESS_DEBUG(param) WXUNUSED(param)
#endif
#endif // _WX_DEBUG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/imaggif.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/imaggif.h
// Purpose: wxImage GIF handler
// Author: Vaclav Slavik, Guillermo Rodriguez Garcia, Gershon Elber, Troels K
// Copyright: (c) 1999-2011 Vaclav Slavik, Guillermo Rodriguez Garcia, Gershon Elber, Troels K
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGGIF_H_
#define _WX_IMAGGIF_H_
#include "wx/image.h"
//-----------------------------------------------------------------------------
// wxGIFHandler
//-----------------------------------------------------------------------------
#if wxUSE_GIF
#define wxIMAGE_OPTION_GIF_COMMENT wxT("GifComment")
#define wxIMAGE_OPTION_GIF_TRANSPARENCY wxS("Transparency")
#define wxIMAGE_OPTION_GIF_TRANSPARENCY_HIGHLIGHT wxS("Highlight")
#define wxIMAGE_OPTION_GIF_TRANSPARENCY_UNCHANGED wxS("Unchanged")
struct wxRGB;
struct GifHashTableType;
class WXDLLIMPEXP_FWD_CORE wxImageArray; // anidecod.h
class WXDLLIMPEXP_CORE wxGIFHandler : public wxImageHandler
{
public:
inline wxGIFHandler()
{
m_name = wxT("GIF file");
m_extension = wxT("gif");
m_type = wxBITMAP_TYPE_GIF;
m_mime = wxT("image/gif");
m_hashTable = NULL;
}
#if wxUSE_STREAMS
virtual bool LoadFile(wxImage *image, wxInputStream& stream,
bool verbose = true, int index = -1) wxOVERRIDE;
virtual bool SaveFile(wxImage *image, wxOutputStream& stream,
bool verbose=true) wxOVERRIDE;
// Save animated gif
bool SaveAnimation(const wxImageArray& images, wxOutputStream *stream,
bool verbose = true, int delayMilliSecs = 1000);
protected:
virtual int DoGetImageCount(wxInputStream& stream) wxOVERRIDE;
virtual bool DoCanRead(wxInputStream& stream) wxOVERRIDE;
bool DoSaveFile(const wxImage&, wxOutputStream *, bool verbose,
bool first, int delayMilliSecs, bool loop,
const wxRGB *pal, int palCount,
int mask_index);
#endif // wxUSE_STREAMS
protected:
// Declarations for saving
unsigned long m_crntShiftDWord; /* For bytes decomposition into codes. */
int m_pixelCount;
struct GifHashTableType *m_hashTable;
wxInt16
m_EOFCode, /* The EOF LZ code. */
m_clearCode, /* The CLEAR LZ code. */
m_runningCode, /* The next code algorithm can generate. */
m_runningBits, /* The number of bits required to represent RunningCode. */
m_maxCode1, /* 1 bigger than max. possible code, in RunningBits bits. */
m_crntCode, /* Current algorithm code. */
m_crntShiftState; /* Number of bits in CrntShiftDWord. */
wxUint8 m_LZBuf[256]; /* Compressed input is buffered here. */
bool InitHashTable();
void ClearHashTable();
void InsertHashTable(unsigned long key, int code);
int ExistsHashTable(unsigned long key);
#if wxUSE_STREAMS
bool CompressOutput(wxOutputStream *, int code);
bool SetupCompress(wxOutputStream *, int bpp);
bool CompressLine(wxOutputStream *, const wxUint8 *line, int lineLen);
#endif
private:
wxDECLARE_DYNAMIC_CLASS(wxGIFHandler);
};
#endif // wxUSE_GIF
#endif // _WX_IMAGGIF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/simplebook.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/simplebook.h
// Purpose: wxBookCtrlBase-derived class without any controller.
// Author: Vadim Zeitlin
// Created: 2012-08-21
// Copyright: (c) 2012 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SIMPLEBOOK_H_
#define _WX_SIMPLEBOOK_H_
#include "wx/bookctrl.h"
#if wxUSE_BOOKCTRL
#include "wx/vector.h"
// ----------------------------------------------------------------------------
// wxSimplebook: a book control without any user-actionable controller.
// ----------------------------------------------------------------------------
// NB: This class doesn't use DLL export declaration as it's fully inline.
class wxSimplebook : public wxBookCtrlBase
{
public:
wxSimplebook()
{
Init();
}
wxSimplebook(wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxEmptyString)
: wxBookCtrlBase(parent, winid, pos, size, style | wxBK_TOP, name)
{
Init();
}
bool Create(wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxEmptyString)
{
return wxBookCtrlBase::Create(parent, winid, pos, size, style | wxBK_TOP, name);
}
// Methods specific to this class.
// A method allowing to add a new page without any label (which is unused
// by this control) and show it immediately.
bool ShowNewPage(wxWindow* page)
{
return AddPage(page, wxString(), true /* select it */);
}
// Set effect to use for showing/hiding pages.
void SetEffects(wxShowEffect showEffect, wxShowEffect hideEffect)
{
m_showEffect = showEffect;
m_hideEffect = hideEffect;
}
// Or the same effect for both of them.
void SetEffect(wxShowEffect effect)
{
SetEffects(effect, effect);
}
// And the same for time outs.
void SetEffectsTimeouts(unsigned showTimeout, unsigned hideTimeout)
{
m_showTimeout = showTimeout;
m_hideTimeout = hideTimeout;
}
void SetEffectTimeout(unsigned timeout)
{
SetEffectsTimeouts(timeout, timeout);
}
// Implement base class pure virtual methods.
// Page management
virtual bool InsertPage(size_t n,
wxWindow *page,
const wxString& text,
bool bSelect = false,
int imageId = NO_IMAGE) wxOVERRIDE
{
if ( !wxBookCtrlBase::InsertPage(n, page, text, bSelect, imageId) )
return false;
m_pageTexts.insert(m_pageTexts.begin() + n, text);
if ( !DoSetSelectionAfterInsertion(n, bSelect) )
page->Hide();
return true;
}
virtual int SetSelection(size_t n) wxOVERRIDE
{
return DoSetSelection(n, SetSelection_SendEvent);
}
virtual int ChangeSelection(size_t n) wxOVERRIDE
{
return DoSetSelection(n);
}
// Neither labels nor images are supported but we still store the labels
// just in case the user code attaches some importance to them.
virtual bool SetPageText(size_t n, const wxString& strText) wxOVERRIDE
{
wxCHECK_MSG( n < GetPageCount(), false, wxS("Invalid page") );
m_pageTexts[n] = strText;
return true;
}
virtual wxString GetPageText(size_t n) const wxOVERRIDE
{
wxCHECK_MSG( n < GetPageCount(), wxString(), wxS("Invalid page") );
return m_pageTexts[n];
}
virtual bool SetPageImage(size_t WXUNUSED(n), int WXUNUSED(imageId)) wxOVERRIDE
{
return false;
}
virtual int GetPageImage(size_t WXUNUSED(n)) const wxOVERRIDE
{
return NO_IMAGE;
}
// Override some wxWindow methods too.
virtual void SetFocus() wxOVERRIDE
{
wxWindow* const page = GetCurrentPage();
if ( page )
page->SetFocus();
}
protected:
virtual void UpdateSelectedPage(size_t WXUNUSED(newsel)) wxOVERRIDE
{
// Nothing to do here, but must be overridden to avoid the assert in
// the base class version.
}
virtual wxBookCtrlEvent* CreatePageChangingEvent() const wxOVERRIDE
{
return new wxBookCtrlEvent(wxEVT_BOOKCTRL_PAGE_CHANGING,
GetId());
}
virtual void MakeChangedEvent(wxBookCtrlEvent& event) wxOVERRIDE
{
event.SetEventType(wxEVT_BOOKCTRL_PAGE_CHANGED);
}
virtual wxWindow *DoRemovePage(size_t page) wxOVERRIDE
{
wxWindow* const win = wxBookCtrlBase::DoRemovePage(page);
if ( win )
{
m_pageTexts.erase(m_pageTexts.begin() + page);
DoSetSelectionAfterRemoval(page);
}
return win;
}
virtual void DoSize() wxOVERRIDE
{
wxWindow* const page = GetCurrentPage();
if ( page )
page->SetSize(GetPageRect());
}
virtual void DoShowPage(wxWindow* page, bool show) wxOVERRIDE
{
if ( show )
page->ShowWithEffect(m_showEffect, m_showTimeout);
else
page->HideWithEffect(m_hideEffect, m_hideTimeout);
}
private:
void Init()
{
// We don't need any border as we don't have anything to separate the
// page contents from.
SetInternalBorder(0);
// No effects by default.
m_showEffect =
m_hideEffect = wxSHOW_EFFECT_NONE;
m_showTimeout =
m_hideTimeout = 0;
}
wxVector<wxString> m_pageTexts;
wxShowEffect m_showEffect,
m_hideEffect;
unsigned m_showTimeout,
m_hideTimeout;
wxDECLARE_NO_COPY_CLASS(wxSimplebook);
};
#endif // wxUSE_BOOKCTRL
#endif // _WX_SIMPLEBOOK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/xtiprop.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xtiprop.h
// Purpose: XTI properties
// Author: Stefan Csomor
// Modified by: Francesco Montorsi
// Created: 27/07/03
// Copyright: (c) 1997 Julian Smart
// (c) 2003 Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _XTIPROP_H_
#define _XTIPROP_H_
#include "wx/defs.h"
#if wxUSE_EXTENDED_RTTI
#include "wx/xti.h"
#include "wx/any.h"
/*
class WXDLLIMPEXP_BASE wxObject;
class WXDLLIMPEXP_BASE wxClassInfo;
class WXDLLIMPEXP_BASE wxDynamicClassInfo;
*/
class WXDLLIMPEXP_BASE wxHashTable;
class WXDLLIMPEXP_BASE wxHashTable_Node;
class WXDLLIMPEXP_BASE wxEvent;
class WXDLLIMPEXP_BASE wxEvtHandler;
// ----------------------------------------------------------------------------
// Property Accessors
//
// wxPropertySetter/Getter/CollectionGetter/CollectionAdder are all property
// accessors which are managed by wxPropertyAccessor class which in turn is
// handled by wxPropertyInfo.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxPropertySetter
{
public:
wxPropertySetter( const wxString name ) { m_name = name; }
virtual ~wxPropertySetter() {}
virtual void Set( wxObject *object, const wxAny &variantValue ) const = 0;
const wxString& GetName() const { return m_name; }
private:
wxString m_name;
};
class WXDLLIMPEXP_BASE wxPropertyGetter
{
public:
wxPropertyGetter( const wxString name ) { m_name = name; }
virtual ~wxPropertyGetter() {}
virtual void Get( const wxObject *object, wxAny& result) const = 0;
const wxString& GetName() const { return m_name; }
private:
wxString m_name;
};
class WXDLLIMPEXP_BASE wxPropertyCollectionGetter
{
public:
wxPropertyCollectionGetter( const wxString name ) { m_name = name; }
virtual ~wxPropertyCollectionGetter() {}
virtual void Get( const wxObject *object, wxAnyList& result) const = 0;
const wxString& GetName() const { return m_name; }
private:
wxString m_name;
};
template<typename coll_t> void WXDLLIMPEXP_BASE \
wxCollectionToVariantArray( const coll_t& coll, wxAnyList& result );
class WXDLLIMPEXP_BASE wxPropertyCollectionAdder
{
public:
wxPropertyCollectionAdder( const wxString name ) { m_name = name; }
virtual ~wxPropertyCollectionAdder() {}
virtual void Add( wxObject *object, const wxAny &variantValue ) const= 0;
const wxString& GetName() const { return m_name; }
private:
wxString m_name;
};
#define wxPROPERTY_SETTER( property, Klass, valueType, setterMethod ) \
class wxPropertySetter##property : public wxPropertySetter \
{ \
public: \
wxPropertySetter##property() : wxPropertySetter( wxT(#setterMethod) ) {} \
virtual ~wxPropertySetter##property() {} \
\
void Set( wxObject *object, const wxAny &variantValue ) const \
{ \
Klass *obj = dynamic_cast<Klass*>(object); \
valueType tempobj; \
if ( variantValue.GetAs(&tempobj) ) \
obj->setterMethod(tempobj); \
else \
obj->setterMethod(*variantValue.As<valueType*>()); \
} \
};
#define wxPROPERTY_GETTER( property, Klass, valueType, gettermethod ) \
class wxPropertyGetter##property : public wxPropertyGetter \
{ \
public: \
wxPropertyGetter##property() : wxPropertyGetter( wxT(#gettermethod) ) {} \
virtual ~wxPropertyGetter##property() {} \
\
void Get( const wxObject *object, wxAny &result) const \
{ \
const Klass *obj = dynamic_cast<const Klass*>(object); \
result = wxAny( obj->gettermethod() ); \
} \
};
#define wxPROPERTY_COLLECTION_ADDER( property, Klass, valueType, addermethod ) \
class wxPropertyCollectionAdder##property : public wxPropertyCollectionAdder \
{ \
public: \
wxPropertyCollectionAdder##property() : wxPropertyCollectionAdder( wxT(#addermethod) ) {} \
virtual ~wxPropertyCollectionAdder##property() {} \
\
void Add( wxObject *object, const wxAny &variantValue ) const \
{ \
Klass *obj = dynamic_cast<Klass*>(object); \
valueType tempobj; \
if ( variantValue.GetAs(&tempobj) ) \
obj->addermethod(tempobj); \
else \
obj->addermethod(*variantValue.As<valueType*>()); \
} \
};
#define wxPROPERTY_COLLECTION_GETTER( property, Klass, valueType, gettermethod ) \
class wxPropertyCollectionGetter##property : public wxPropertyCollectionGetter \
{ \
public: \
wxPropertyCollectionGetter##property() : wxPropertyCollectionGetter( wxT(#gettermethod) ) {} \
virtual ~wxPropertyCollectionGetter##property() {} \
\
void Get( const wxObject *object, wxAnyList &result) const \
{ \
const Klass *obj = dynamic_cast<const Klass*>(object); \
wxCollectionToVariantArray( obj->gettermethod(), result ); \
} \
};
class WXDLLIMPEXP_BASE wxPropertyAccessor
{
public:
wxPropertyAccessor( wxPropertySetter *setter, wxPropertyGetter *getter,
wxPropertyCollectionAdder *adder, wxPropertyCollectionGetter *collectionGetter )
{ m_setter = setter; m_getter = getter; m_adder = adder;
m_collectionGetter = collectionGetter; }
virtual ~wxPropertyAccessor() {}
// Setting a simple property (non-collection)
virtual void SetProperty(wxObject *object, const wxAny &value) const
{
if ( m_setter )
m_setter->Set( object, value );
else
wxLogError( wxGetTranslation("SetProperty called w/o valid setter") );
}
// Getting a simple property (non-collection)
virtual void GetProperty(const wxObject *object, wxAny &result) const
{
if ( m_getter )
m_getter->Get( object, result );
else
wxLogError( wxGetTranslation("GetProperty called w/o valid getter") );
}
// Adding an element to a collection property
virtual void AddToPropertyCollection(wxObject *object, const wxAny &value) const
{
if ( m_adder )
m_adder->Add( object, value );
else
wxLogError( wxGetTranslation("AddToPropertyCollection called w/o valid adder") );
}
// Getting a collection property
virtual void GetPropertyCollection( const wxObject *obj, wxAnyList &result) const
{
if ( m_collectionGetter )
m_collectionGetter->Get( obj, result);
else
wxLogError( wxGetTranslation("GetPropertyCollection called w/o valid collection getter") );
}
virtual bool HasSetter() const { return m_setter != NULL; }
virtual bool HasCollectionGetter() const { return m_collectionGetter != NULL; }
virtual bool HasGetter() const { return m_getter != NULL; }
virtual bool HasAdder() const { return m_adder != NULL; }
virtual const wxString& GetCollectionGetterName() const
{ return m_collectionGetter->GetName(); }
virtual const wxString& GetGetterName() const
{ return m_getter->GetName(); }
virtual const wxString& GetSetterName() const
{ return m_setter->GetName(); }
virtual const wxString& GetAdderName() const
{ return m_adder->GetName(); }
protected:
wxPropertySetter *m_setter;
wxPropertyCollectionAdder *m_adder;
wxPropertyGetter *m_getter;
wxPropertyCollectionGetter* m_collectionGetter;
};
class WXDLLIMPEXP_BASE wxGenericPropertyAccessor : public wxPropertyAccessor
{
public:
wxGenericPropertyAccessor( const wxString &propName );
virtual ~wxGenericPropertyAccessor();
void RenameProperty( const wxString& WXUNUSED_UNLESS_DEBUG(oldName),
const wxString& newName )
{
wxASSERT( oldName == m_propertyName ); m_propertyName = newName;
}
virtual bool HasSetter() const { return true; }
virtual bool HasGetter() const { return true; }
virtual bool HasAdder() const { return false; }
virtual bool HasCollectionGetter() const { return false; }
virtual const wxString& GetGetterName() const
{ return m_getterName; }
virtual const wxString& GetSetterName() const
{ return m_setterName; }
virtual void SetProperty(wxObject *object, const wxAny &value) const;
virtual void GetProperty(const wxObject *object, wxAny &value) const;
// Adding an element to a collection property
virtual void AddToPropertyCollection(wxObject *WXUNUSED(object),
const wxAny &WXUNUSED(value)) const
{
wxLogError( wxGetTranslation("AddToPropertyCollection called on a generic accessor") );
}
// Getting a collection property
virtual void GetPropertyCollection( const wxObject *WXUNUSED(obj),
wxAnyList &WXUNUSED(result)) const
{
wxLogError ( wxGetTranslation("GetPropertyCollection called on a generic accessor") );
}
private:
struct wxGenericPropertyAccessorInternal;
wxGenericPropertyAccessorInternal* m_data;
wxString m_propertyName;
wxString m_setterName;
wxString m_getterName;
};
typedef long wxPropertyInfoFlags;
enum
{
// will be removed in future releases
wxPROP_DEPRECATED = 0x00000001,
// object graph property, will be streamed with priority (after constructor properties)
wxPROP_OBJECT_GRAPH = 0x00000002,
// this will only be streamed out and in as enum/set, the internal representation
// is still a long
wxPROP_ENUM_STORE_LONG = 0x00000004,
// don't stream out this property, needed eg to avoid streaming out children
// that are always created by their parents
wxPROP_DONT_STREAM = 0x00000008
};
// ----------------------------------------------------------------------------
// Property Support
//
// wxPropertyInfo is used to inquire of the property by name. It doesn't
// provide access to the property, only information about it. If you
// want access, look at wxPropertyAccessor.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxPropertyInfo
{
friend class /* WXDLLIMPEXP_BASE */ wxDynamicClassInfo;
public:
wxPropertyInfo(wxPropertyInfo* &iter,
wxClassInfo* itsClass,
const wxString& name,
const wxString& typeName,
wxPropertyAccessor *accessor,
wxAny dv,
wxPropertyInfoFlags flags = 0,
const wxString& helpString = wxEmptyString,
const wxString& groupString = wxEmptyString) :
m_itsClass(itsClass),
m_name(name),
m_typeInfo(NULL),
m_typeName(typeName),
m_collectionElementTypeInfo(NULL),
m_accessor(accessor),
m_defaultValue(dv),
m_flags(flags),
m_helpString(helpString),
m_groupString(groupString)
{
Insert(iter);
}
wxPropertyInfo(wxPropertyInfo* &iter,
wxClassInfo* itsClass,
const wxString& name,
wxEventSourceTypeInfo* type,
wxPropertyAccessor *accessor,
wxAny dv,
wxPropertyInfoFlags flags = 0,
const wxString& helpString = wxEmptyString,
const wxString& groupString = wxEmptyString) :
m_itsClass(itsClass),
m_name(name),
m_typeInfo(type),
m_collectionElementTypeInfo(NULL),
m_accessor(accessor),
m_defaultValue(dv),
m_flags(flags),
m_helpString(helpString),
m_groupString(groupString)
{
Insert(iter);
}
wxPropertyInfo(wxPropertyInfo* &iter,
wxClassInfo* itsClass, const wxString& name,
const wxString& collectionTypeName,
const wxString& elementTypeName,
wxPropertyAccessor *accessor,
wxPropertyInfoFlags flags = 0,
const wxString& helpString = wxEmptyString,
const wxString& groupString = wxEmptyString) :
m_itsClass(itsClass),
m_name(name),
m_typeInfo(NULL),
m_typeName(collectionTypeName),
m_collectionElementTypeInfo(NULL),
m_collectionElementTypeName(elementTypeName),
m_accessor(accessor),
m_flags(flags),
m_helpString(helpString),
m_groupString(groupString)
{
Insert(iter);
}
~wxPropertyInfo()
{ Remove(); }
// return the class this property is declared in
const wxClassInfo* GetDeclaringClass() const { return m_itsClass; }
// return the name of this property
const wxString& GetName() const { return m_name; }
// returns the flags of this property
wxPropertyInfoFlags GetFlags() const { return m_flags; }
// returns the short help string of this property
const wxString& GetHelpString() const { return m_helpString; }
// returns the group string of this property
const wxString& GetGroupString() const { return m_groupString; }
// return the element type info of this property (for collections, otherwise NULL)
const wxTypeInfo * GetCollectionElementTypeInfo() const
{
if ( m_collectionElementTypeInfo == NULL )
m_collectionElementTypeInfo = wxTypeInfo::FindType(m_collectionElementTypeName);
return m_collectionElementTypeInfo;
}
// return the type info of this property
const wxTypeInfo * GetTypeInfo() const
{
if ( m_typeInfo == NULL )
m_typeInfo = wxTypeInfo::FindType(m_typeName);
return m_typeInfo;
}
// return the accessor for this property
wxPropertyAccessor* GetAccessor() const { return m_accessor; }
// returns NULL if this is the last property of this class
wxPropertyInfo* GetNext() const { return m_next; }
// returns the default value of this property, its kind may be wxT_VOID if it is not valid
wxAny GetDefaultValue() const { return m_defaultValue; }
private:
// inserts this property at the end of the linked chain which begins
// with "iter" property.
void Insert(wxPropertyInfo* &iter);
// removes this property from the linked chain of the m_itsClass properties.
void Remove();
wxClassInfo* m_itsClass;
wxString m_name;
mutable wxTypeInfo* m_typeInfo;
wxString m_typeName;
mutable wxTypeInfo* m_collectionElementTypeInfo;
wxString m_collectionElementTypeName;
wxPropertyAccessor* m_accessor;
wxAny m_defaultValue;
wxPropertyInfoFlags m_flags;
wxString m_helpString;
wxString m_groupString;
wxPropertyInfo* m_next;
// FIXME: what's this comment about??
// string representation of the default value
// to be assigned by the designer to the property
// when the component is dropped on the container.
};
// stl is giving problems when forwarding declarations, therefore we define it as a subclass
WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxPropertyInfo*, wxPropertyInfoMapBase,
class WXDLLIMPEXP_BASE );
class WXDLLIMPEXP_BASE wxPropertyInfoMap : public wxPropertyInfoMapBase {
};
WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxAny, wxStringToAnyHashMapBase,
class WXDLLIMPEXP_BASE );
class WXDLLIMPEXP_FWD_BASE wxStringToAnyHashMap : public wxStringToAnyHashMapBase {
};
#define wxBEGIN_PROPERTIES_TABLE(theClass) \
wxPropertyInfo *theClass::GetPropertiesStatic() \
{ \
typedef theClass class_t; \
static wxPropertyInfo* first = NULL;
#define wxEND_PROPERTIES_TABLE() \
return first; }
#define wxHIDE_PROPERTY( pname ) \
static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
wxT(#pname), typeid(void).name(), NULL, wxAny(), wxPROP_DONT_STREAM, \
wxEmptyString, wxEmptyString );
#define wxPROPERTY( pname, type, setter, getter, defaultValue, flags, help, group) \
wxPROPERTY_SETTER( pname, class_t, type, setter ) \
static wxPropertySetter##pname _setter##pname; \
wxPROPERTY_GETTER( pname, class_t, type, getter ) \
static wxPropertyGetter##pname _getter##pname; \
static wxPropertyAccessor _accessor##pname( &_setter##pname, \
&_getter##pname, NULL, NULL ); \
static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
wxT(#pname), typeid(type).name(), &_accessor##pname, \
wxAny(defaultValue), flags, group, help );
#define wxPROPERTY_FLAGS( pname, flags, type, setter, getter,defaultValue, \
pflags, help, group) \
wxPROPERTY_SETTER( pname, class_t, type, setter ) \
static wxPropertySetter##pname _setter##pname; \
wxPROPERTY_GETTER( pname, class_t, type, getter ) \
static wxPropertyGetter##pname _getter##pname; \
static wxPropertyAccessor _accessor##pname( &_setter##pname, \
&_getter##pname, NULL, NULL ); \
static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
wxT(#pname), typeid(flags).name(), &_accessor##pname, \
wxAny(defaultValue), wxPROP_ENUM_STORE_LONG | pflags, help, group );
#define wxREADONLY_PROPERTY( pname, type, getter,defaultValue, flags, help, group) \
wxPROPERTY_GETTER( pname, class_t, type, getter ) \
static wxPropertyGetter##pname _getter##pname; \
static wxPropertyAccessor _accessor##pname( NULL, &_getter##pname, NULL, NULL ); \
static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
wxT(#pname), typeid(type).name(),&_accessor##pname, \
wxAny(defaultValue), flags, help, group );
#define wxREADONLY_PROPERTY_FLAGS( pname, flags, type, getter,defaultValue, \
pflags, help, group) \
wxPROPERTY_GETTER( pname, class_t, type, getter ) \
static wxPropertyGetter##pname _getter##pname; \
static wxPropertyAccessor _accessor##pname( NULL, &_getter##pname, NULL, NULL ); \
static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
wxT(#pname), typeid(flags).name(),&_accessor##pname, \
wxAny(defaultValue), wxPROP_ENUM_STORE_LONG | pflags, help, group );
#define wxPROPERTY_COLLECTION( pname, colltype, addelemtype, adder, getter, \
flags, help, group ) \
wxPROPERTY_COLLECTION_ADDER( pname, class_t, addelemtype, adder ) \
static wxPropertyCollectionAdder##pname _adder##pname; \
wxPROPERTY_COLLECTION_GETTER( pname, class_t, colltype, getter ) \
static wxPropertyCollectionGetter##pname _collectionGetter##pname; \
static wxPropertyAccessor _accessor##pname( NULL, NULL,&_adder##pname, \
&_collectionGetter##pname ); \
static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
wxT(#pname), typeid(colltype).name(),typeid(addelemtype).name(), \
&_accessor##pname, flags, help, group );
#define wxREADONLY_PROPERTY_COLLECTION( pname, colltype, addelemtype, getter, \
flags, help, group) \
wxPROPERTY_COLLECTION_GETTER( pname, class_t, colltype, getter ) \
static wxPropertyCollectionGetter##pname _collectionGetter##pname; \
static wxPropertyAccessor _accessor##pname( NULL, NULL, NULL, \
&_collectionGetter##pname ); \
static wxPropertyInfo _propertyInfo##pname( first,class_t::GetClassInfoStatic(), \
wxT(#pname), typeid(colltype).name(),typeid(addelemtype).name(), \
&_accessor##pname, flags, help, group );
#define wxEVENT_PROPERTY( name, eventType, eventClass ) \
static wxEventSourceTypeInfo _typeInfo##name( eventType, wxCLASSINFO( eventClass ) ); \
static wxPropertyInfo _propertyInfo##name( first,class_t::GetClassInfoStatic(), \
wxT(#name), &_typeInfo##name, NULL, wxAny() );
#define wxEVENT_RANGE_PROPERTY( name, eventType, lastEventType, eventClass ) \
static wxEventSourceTypeInfo _typeInfo##name( eventType, lastEventType, \
wxCLASSINFO( eventClass ) ); \
static wxPropertyInfo _propertyInfo##name( first, class_t::GetClassInfoStatic(), \
wxT(#name), &_typeInfo##name, NULL, wxAny() );
// ----------------------------------------------------------------------------
// Implementation Helper for Simple Properties
// ----------------------------------------------------------------------------
#define wxIMPLEMENT_PROPERTY(name, type) \
private: \
type m_##name; \
public: \
void Set##name( type const & p) { m_##name = p; } \
type const & Get##name() const { return m_##name; }
#endif // wxUSE_EXTENDED_RTTI
#endif // _XTIPROP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/xpmhand.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xpmhand.h
// Purpose: XPM handler base header
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XPMHAND_H_BASE_
#define _WX_XPMHAND_H_BASE_
// Only wxMSW currently defines a separate XPM handler, since
// mostly Windows apps won't need XPMs.
#if defined(__WXMSW__)
#error xpmhand.h is no longer needed since wxImage now handles XPMs.
#endif
#endif
// _WX_XPMHAND_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/clntdata.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/clntdata.h
// Purpose: A mixin class for holding a wxClientData or void pointer
// Author: Robin Dunn
// Modified by:
// Created: 9-Oct-2001
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CLNTDATAH__
#define _WX_CLNTDATAH__
#include "wx/defs.h"
#include "wx/string.h"
#include "wx/hashmap.h"
typedef int (*wxShadowObjectMethod)(void*, void*);
WX_DECLARE_STRING_HASH_MAP_WITH_DECL(
wxShadowObjectMethod,
wxShadowObjectMethods,
class WXDLLIMPEXP_BASE
);
WX_DECLARE_STRING_HASH_MAP_WITH_DECL(
void *,
wxShadowObjectFields,
class WXDLLIMPEXP_BASE
);
class WXDLLIMPEXP_BASE wxShadowObject
{
public:
wxShadowObject() { }
void AddMethod( const wxString &name, wxShadowObjectMethod method )
{
wxShadowObjectMethods::iterator it = m_methods.find( name );
if (it == m_methods.end())
m_methods[ name ] = method;
else
it->second = method;
}
bool InvokeMethod( const wxString &name, void* window, void* param, int* returnValue )
{
wxShadowObjectMethods::iterator it = m_methods.find( name );
if (it == m_methods.end())
return false;
wxShadowObjectMethod method = it->second;
const int ret = (*method)(window, param);
if (returnValue)
*returnValue = ret;
return true;
}
void AddField( const wxString &name, void* initialValue = NULL )
{
wxShadowObjectFields::iterator it = m_fields.find( name );
if (it == m_fields.end())
m_fields[ name ] = initialValue;
else
it->second = initialValue;
}
void SetField( const wxString &name, void* value )
{
wxShadowObjectFields::iterator it = m_fields.find( name );
if (it == m_fields.end())
return;
it->second = value;
}
void* GetField( const wxString &name, void *defaultValue = NULL )
{
wxShadowObjectFields::iterator it = m_fields.find( name );
if (it == m_fields.end())
return defaultValue;
return it->second;
}
private:
wxShadowObjectMethods m_methods;
wxShadowObjectFields m_fields;
};
// ----------------------------------------------------------------------------
// what kind of client data do we have?
enum wxClientDataType
{
wxClientData_None, // we don't know yet because we don't have it at all
wxClientData_Object, // our client data is typed and we own it
wxClientData_Void // client data is untyped and we don't own it
};
class WXDLLIMPEXP_BASE wxClientData
{
public:
wxClientData() { }
virtual ~wxClientData() { }
};
class WXDLLIMPEXP_BASE wxStringClientData : public wxClientData
{
public:
wxStringClientData() : m_data() { }
wxStringClientData( const wxString &data ) : m_data(data) { }
void SetData( const wxString &data ) { m_data = data; }
const wxString& GetData() const { return m_data; }
private:
wxString m_data;
};
// This class is a mixin that provides storage and management of "client
// data." The client data stored can either be a pointer to a wxClientData
// object in which case it is managed by the container (i.e. it will delete
// the data when it's destroyed) or an untyped pointer which won't be deleted
// by the container - but not both of them
//
// NOTE: This functionality is currently duplicated in wxEvtHandler in order
// to avoid having more than one vtable in that class hierarchy.
class WXDLLIMPEXP_BASE wxClientDataContainer
{
public:
wxClientDataContainer();
virtual ~wxClientDataContainer();
void SetClientObject( wxClientData *data ) { DoSetClientObject(data); }
wxClientData *GetClientObject() const { return DoGetClientObject(); }
void SetClientData( void *data ) { DoSetClientData(data); }
void *GetClientData() const { return DoGetClientData(); }
protected:
// The user data: either an object which will be deleted by the container
// when it's deleted or some raw pointer which we do nothing with. Only
// one type of data can be used with the given window, i.e. you cannot set
// the void data and then associate the container with wxClientData or vice
// versa.
union
{
wxClientData *m_clientObject;
void *m_clientData;
};
// client data accessors
virtual void DoSetClientObject( wxClientData *data );
virtual wxClientData *DoGetClientObject() const;
virtual void DoSetClientData( void *data );
virtual void *DoGetClientData() const;
// what kind of data do we have?
wxClientDataType m_clientDataType;
};
#endif // _WX_CLNTDATAH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/imaglist.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/imaglist.h
// Purpose: wxImageList base header
// Author: Julian Smart
// Modified by:
// Created:
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGLIST_H_BASE_
#define _WX_IMAGLIST_H_BASE_
#include "wx/defs.h"
/*
* wxImageList is used for wxListCtrl, wxTreeCtrl. These controls refer to
* images for their items by an index into an image list.
* A wxImageList is capable of creating images with optional masks from
* a variety of sources - a single bitmap plus a colour to indicate the mask,
* two bitmaps, or an icon.
*
* Image lists can also create and draw images used for drag and drop functionality.
* This is not yet implemented in wxImageList. We need to discuss a generic API
* for doing drag and drop.
* See below for candidate functions and an explanation of how they might be
* used.
*/
// Flag values for Set/GetImageList
enum
{
wxIMAGE_LIST_NORMAL, // Normal icons
wxIMAGE_LIST_SMALL, // Small icons
wxIMAGE_LIST_STATE // State icons: unimplemented (see WIN32 documentation)
};
// Flags for Draw
#define wxIMAGELIST_DRAW_NORMAL 0x0001
#define wxIMAGELIST_DRAW_TRANSPARENT 0x0002
#define wxIMAGELIST_DRAW_SELECTED 0x0004
#define wxIMAGELIST_DRAW_FOCUSED 0x0008
#if defined(__WXMSW__)
#include "wx/msw/imaglist.h"
#define wxHAS_NATIVE_IMAGELIST
#else
#include "wx/generic/imaglist.h"
#endif
#endif // _WX_IMAGLIST_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/valgen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/valgen.h
// Purpose: wxGenericValidator class
// Author: Kevin Smith
// Created: Jan 22 1999
// Copyright: (c) 1999 Julian Smart (assigned from Kevin)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_VALGENH__
#define _WX_VALGENH__
#include "wx/validate.h"
#if wxUSE_VALIDATORS
class WXDLLIMPEXP_FWD_BASE wxDateTime;
class WXDLLIMPEXP_FWD_BASE wxFileName;
// ----------------------------------------------------------------------------
// wxGenericValidator performs data transfer between many standard controls and
// variables of the type corresponding to their values.
//
// It doesn't do any validation so its name is a slight misnomer.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGenericValidator: public wxValidator
{
public:
// Different constructors: each of them creates a validator which can only
// be used with some controls, the comments before each constructor
// indicate which ones:
// wxCheckBox, wxRadioButton, wx(Bitmap)ToggleButton
wxGenericValidator(bool* val);
// wxChoice, wxGauge, wxRadioBox, wxScrollBar, wxSlider, wxSpinButton
wxGenericValidator(int* val);
// wxComboBox, wxTextCtrl, wxButton, wxStaticText (read-only)
wxGenericValidator(wxString* val);
// wxListBox, wxCheckListBox
wxGenericValidator(wxArrayInt* val);
#if wxUSE_DATETIME
// wxDatePickerCtrl
wxGenericValidator(wxDateTime* val);
#endif // wxUSE_DATETIME
// wxTextCtrl
wxGenericValidator(wxFileName* val);
// wxTextCtrl
wxGenericValidator(float* val);
// wxTextCtrl
wxGenericValidator(double* val);
wxGenericValidator(const wxGenericValidator& copyFrom);
virtual ~wxGenericValidator(){}
// Make a clone of this validator (or return NULL) - currently necessary
// if you're passing a reference to a validator.
// Another possibility is to always pass a pointer to a new validator
// (so the calling code can use a copy constructor of the relevant class).
virtual wxObject *Clone() const wxOVERRIDE { return new wxGenericValidator(*this); }
bool Copy(const wxGenericValidator& val);
// Called when the value in the window must be validated: this is not used
// by this class
virtual bool Validate(wxWindow * WXUNUSED(parent)) wxOVERRIDE { return true; }
// Called to transfer data to the window
virtual bool TransferToWindow() wxOVERRIDE;
// Called to transfer data to the window
virtual bool TransferFromWindow() wxOVERRIDE;
protected:
void Initialize();
bool* m_pBool;
int* m_pInt;
wxString* m_pString;
wxArrayInt* m_pArrayInt;
#if wxUSE_DATETIME
wxDateTime* m_pDateTime;
#endif // wxUSE_DATETIME
wxFileName* m_pFileName;
float* m_pFloat;
double* m_pDouble;
private:
wxDECLARE_CLASS(wxGenericValidator);
wxDECLARE_NO_ASSIGN_CLASS(wxGenericValidator);
};
#endif // wxUSE_VALIDATORS
#endif // _WX_VALGENH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/cmdargs.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/cmdargs.h
// Purpose: declaration of wxCmdLineArgsArray helper class
// Author: Vadim Zeitlin
// Created: 2007-11-12
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CMDARGS_H_
#define _WX_CMDARGS_H_
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// wxCmdLineArgsArray: helper class used by wxApp::argv
// ----------------------------------------------------------------------------
#if wxUSE_UNICODE
// this class is used instead of either "char **" or "wchar_t **" (neither of
// which would be backwards compatible with all the existing code) for argv
// field of wxApp
//
// as it's used for compatibility, it tries to look as much as traditional
// (char **) argv as possible, in particular it provides implicit conversions
// to "char **" and also array-like operator[]
class WXDLLIMPEXP_BASE wxCmdLineArgsArray
{
public:
wxCmdLineArgsArray() { m_argsA = NULL; m_argsW = NULL; }
template <typename T>
void Init(int argc, T **argv)
{
FreeArgs();
m_args.clear();
m_args.reserve(argc);
for ( int i = 0; i < argc; i++ )
{
m_args.push_back(argv[i]);
}
}
operator char**() const
{
if ( !m_argsA )
{
const size_t count = m_args.size();
m_argsA = new char *[count + 1];
for ( size_t n = 0; n < count; n++ )
m_argsA[n] = wxStrdup(m_args[n].ToAscii());
m_argsA[count] = NULL;
}
return m_argsA;
}
operator wchar_t**() const
{
if ( !m_argsW )
{
const size_t count = m_args.size();
m_argsW = new wchar_t *[count + 1];
for ( size_t n = 0; n < count; n++ )
m_argsW[n] = wxStrdup(m_args[n].wc_str());
m_argsW[count] = NULL;
}
return m_argsW;
}
// existing code does checks like "if ( argv )" and we want it to continue
// to compile, so provide this conversion even if it is pretty dangerous
operator bool() const
{
return !m_args.empty();
}
// and the same for "if ( !argv )" checks
bool operator!() const
{
return m_args.empty();
}
wxString operator[](size_t n) const
{
return m_args[n];
}
// we must provide this overload for g++ 3.4 which can't choose between
// our operator[](size_t) and ::operator[](char**, int) otherwise
wxString operator[](int n) const
{
return m_args[n];
}
// convenience methods, i.e. not existing only for backwards compatibility
// do we have any arguments at all?
bool IsEmpty() const { return m_args.empty(); }
// access the arguments as a convenient array of wxStrings
const wxArrayString& GetArguments() const { return m_args; }
~wxCmdLineArgsArray()
{
FreeArgs();
}
private:
template <typename T>
void Free(T**& args)
{
if ( !args )
return;
const size_t count = m_args.size();
for ( size_t n = 0; n < count; n++ )
free(args[n]);
delete [] args;
args = NULL;
}
void FreeArgs()
{
Free(m_argsA);
Free(m_argsW);
}
wxArrayString m_args;
mutable char **m_argsA;
mutable wchar_t **m_argsW;
wxDECLARE_NO_COPY_CLASS(wxCmdLineArgsArray);
};
// provide global operator overload for compatibility with the existing code
// doing things like "if ( condition && argv )"
inline bool operator&&(bool cond, const wxCmdLineArgsArray& array)
{
return cond && !array.IsEmpty();
}
#endif // wxUSE_UNICODE
#endif // _WX_CMDARGS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/webviewarchivehandler.h | /////////////////////////////////////////////////////////////////////////////
// Name: webviewarchivehandler.h
// Purpose: Custom webview handler to allow archive browsing
// Author: Steven Lamerton
// Copyright: (c) 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WEBVIEW_FILE_HANDLER_H_
#define _WX_WEBVIEW_FILE_HANDLER_H_
#include "wx/setup.h"
#if wxUSE_WEBVIEW
class wxFSFile;
class wxFileSystem;
#include "wx/webview.h"
//Loads from uris such as scheme:///C:/example/example.html or archives such as
//scheme:///C:/example/example.zip;protocol=zip/example.html
class WXDLLIMPEXP_WEBVIEW wxWebViewArchiveHandler : public wxWebViewHandler
{
public:
wxWebViewArchiveHandler(const wxString& scheme);
virtual ~wxWebViewArchiveHandler();
virtual wxFSFile* GetFile(const wxString &uri) wxOVERRIDE;
private:
wxFileSystem* m_fileSystem;
};
#endif // wxUSE_WEBVIEW
#endif // _WX_WEBVIEW_FILE_HANDLER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/preferences.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/preferences.h
// Purpose: Declaration of wxPreferencesEditor class.
// Author: Vaclav Slavik
// Created: 2013-02-19
// Copyright: (c) 2013 Vaclav Slavik <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PREFERENCES_H_
#define _WX_PREFERENCES_H_
#include "wx/defs.h"
#if wxUSE_PREFERENCES_EDITOR
#include "wx/bitmap.h"
#include "wx/vector.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
class wxPreferencesEditorImpl;
#if defined(__WXOSX_COCOA__)
// GetLargeIcon() is used
#define wxHAS_PREF_EDITOR_ICONS
// Changes should be applied immediately
#define wxHAS_PREF_EDITOR_APPLY_IMMEDIATELY
// The dialog is shown non-modally.
#define wxHAS_PREF_EDITOR_MODELESS
#elif defined(__WXGTK__)
// Changes should be applied immediately
#define wxHAS_PREF_EDITOR_APPLY_IMMEDIATELY
// The dialog is shown non-modally.
#define wxHAS_PREF_EDITOR_MODELESS
#endif
// ----------------------------------------------------------------------------
// wxPreferencesEditor: Native preferences editing
// ----------------------------------------------------------------------------
// One page of a preferences window
class WXDLLIMPEXP_CORE wxPreferencesPage
{
public:
wxPreferencesPage() {}
virtual ~wxPreferencesPage() {}
// Name of the page, used e.g. for tabs
virtual wxString GetName() const = 0;
// Return 32x32 icon used for the page. Currently only used on OS X, where
// implementation is required; unused on other platforms. Because of this,
// the method is only pure virtual on platforms that use it.
#ifdef wxHAS_PREF_EDITOR_ICONS
virtual wxBitmap GetLargeIcon() const = 0;
#else
virtual wxBitmap GetLargeIcon() const { return wxBitmap(); }
#endif
// Create a window (usually a wxPanel) for this page. The caller takes
// ownership of the returned window.
virtual wxWindow *CreateWindow(wxWindow *parent) = 0;
wxDECLARE_NO_COPY_CLASS(wxPreferencesPage);
};
// Helper for implementing some common pages (General, Advanced)
class WXDLLIMPEXP_CORE wxStockPreferencesPage : public wxPreferencesPage
{
public:
enum Kind
{
Kind_General,
Kind_Advanced
};
wxStockPreferencesPage(Kind kind) : m_kind(kind) {}
Kind GetKind() const { return m_kind; }
virtual wxString GetName() const wxOVERRIDE;
#ifdef __WXOSX_COCOA__
virtual wxBitmap GetLargeIcon() const wxOVERRIDE;
#endif
private:
Kind m_kind;
};
// Notice that this class does not inherit from wxWindow.
class WXDLLIMPEXP_CORE wxPreferencesEditor
{
public:
// Ctor creates an empty editor, use AddPage() to add controls to it.
wxPreferencesEditor(const wxString& title = wxString());
// Dtor destroys the dialog if still shown.
virtual ~wxPreferencesEditor();
// Add a new page to the editor. The editor takes ownership of the page
// and won't delete it until it is destroyed itself.
void AddPage(wxPreferencesPage *page);
// Show the preferences dialog or bring it to the top if it's already
// shown. Notice that this method may or may not block depending on the
// platform, i.e. depending on whether the dialog is modal or not.
virtual void Show(wxWindow* parent);
// Hide the currently shown dialog, if any. This is typically used to
// dismiss the dialog if the object whose preferences it is editing was
// closed.
void Dismiss();
// Whether changes to values in the pages should be applied immediately
// (OS X, GTK+) or only when the user clicks OK/Apply (Windows)
static bool ShouldApplyChangesImmediately()
{
#ifdef wxHAS_PREF_EDITOR_APPLY_IMMEDIATELY
return true;
#else
return false;
#endif
}
// Whether the dialog is shown modally, i.e. Show() blocks, or not.
static bool ShownModally()
{
#ifdef wxHAS_PREF_EDITOR_MODELESS
return false;
#else
return true;
#endif
}
private:
wxPreferencesEditorImpl* m_impl;
wxDECLARE_NO_COPY_CLASS(wxPreferencesEditor);
};
#endif // wxUSE_PREFERENCES_EDITOR
#endif // _WX_PREFERENCES_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/xlocale.h | //////////////////////////////////////////////////////////////////////////////
// Name: wx/xlocale.h
// Purpose: Header to provide some xlocale wrappers
// Author: Brian Vanderburg II, Vadim Zeitlin
// Created: 2008-01-07
// Copyright: (c) 2008 Brian Vanderburg II
// 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
/*
This header defines portable wrappers around xlocale foo_l() functions or
their MSVC proprietary _foo_l() equivalents when they are available and
implements these functions for the "C" locale [only] if they are not. This
allows the program running under the default user locale to still use "C"
locale for operations such as reading data from files where they are stored
using decimal point &c.
TODO: Currently only the character classification and transformation
functions and number <-> string functions, are implemented,
we also need at least
- formatted IO: scanf_l(), printf_l() &c
- time: strftime_l(), strptime_l()
*/
#ifndef _WX_XLOCALE_H_
#define _WX_XLOCALE_H_
#include "wx/defs.h" // wxUSE_XLOCALE
#if wxUSE_XLOCALE
#include "wx/crt.h" // Includes wx/chartype.h, wx/wxcrt.h(wx/string.h)
#include "wx/intl.h" // wxLanguage
// The platform-specific locale type
// If wxXLocale_t is not defined, then only "C" locale support is provided
#ifdef wxHAS_XLOCALE_SUPPORT
#if wxCHECK_VISUALC_VERSION(8)
typedef _locale_t wxXLocale_t;
#define wxXLOCALE_IDENT(name) _ ## name
#elif defined(HAVE_LOCALE_T)
// Some systems (notably macOS) require including a separate header for
// locale_t and related functions.
#ifdef HAVE_XLOCALE_H
#include <xlocale.h>
#endif
#include <locale.h>
#include <ctype.h>
#include <stdlib.h>
#if wxUSE_UNICODE
#include <wctype.h>
#endif
// Locale type and identifier name
typedef locale_t wxXLocale_t;
#define wxXLOCALE_IDENT(name) name
#else
#error "Unknown xlocale support"
#endif
#endif // wxHAS_XLOCALE_SUPPORT
// wxXLocale is a wrapper around the native type representing a locale.
//
// It is not to be confused with wxLocale, which handles actually changing the
// locale, loading message catalogs, etc. This just stores a locale value.
// The similarity of names is unfortunate, but there doesn't seem to be any
// better alternative right now. Perhaps by wxWidgets 4.0 better naming could
// be used, or this class could become wxLocale (a wrapper for the value), and
// some other class could be used to load the language catalogs or something
// that would be clearer
#ifdef wxHAS_XLOCALE_SUPPORT
class WXDLLIMPEXP_BASE wxXLocale
{
public:
// Construct an uninitialized locale
wxXLocale() { m_locale = NULL; }
#if wxUSE_INTL
// Construct from a symbolic language constant
wxXLocale(wxLanguage lang);
#endif
// Construct from the given language string
wxXLocale(const char *loc) { Init(loc); }
// Destroy the locale
~wxXLocale() { Free(); }
// Get the global "C" locale object
static wxXLocale& GetCLocale();
// Check if the object represents a valid locale (notice that without
// wxHAS_XLOCALE_SUPPORT the only valid locale is the "C" one)
bool IsOk() const { return m_locale != NULL; }
// Get the type
wxXLocale_t Get() const { return m_locale; }
bool operator== (const wxXLocale& loc) const
{ return m_locale == loc.m_locale; }
private:
// Special ctor for the "C" locale, it's only used internally as the user
// code is supposed to use GetCLocale()
wxXLocale(struct wxXLocaleCTag * WXUNUSED(dummy)) { Init("C"); }
// Create from the given language string (called from ctors)
void Init(const char *loc);
// Free the locale if it's non-NULL
void Free();
// The corresponding locale handle, NULL if invalid
wxXLocale_t m_locale;
// POSIX xlocale API provides a duplocale() function but MSVC locale API
// doesn't give us any means to copy a _locale_t object so we reduce the
// functionality to least common denominator here -- it shouldn't be a
// problem as copying the locale objects shouldn't be often needed
wxDECLARE_NO_COPY_CLASS(wxXLocale);
};
#else // !wxHAS_XLOCALE_SUPPORT
// Skeleton version supporting only the "C" locale for the systems without
// xlocale support
class WXDLLIMPEXP_BASE wxXLocale
{
public:
// Construct an uninitialized locale
wxXLocale() { m_isC = false; }
// Construct from a symbolic language constant: unless the language is
// wxLANGUAGE_ENGLISH_US (which we suppose to be the same as "C" locale)
// the object will be invalid
wxXLocale(wxLanguage lang)
{
m_isC = lang == wxLANGUAGE_ENGLISH_US;
}
// Construct from the given language string: unless the string is "C" or
// "POSIX" the object will be invalid
wxXLocale(const char *loc)
{
m_isC = loc && (strcmp(loc, "C") == 0 || strcmp(loc, "POSIX") == 0);
}
// Default copy ctor, assignment operator and dtor are ok (or would be if
// we didn't use wxDECLARE_NO_COPY_CLASS() for consistency with the
// xlocale version)
// Get the global "C" locale object
static wxXLocale& GetCLocale();
// Check if the object represents a valid locale (notice that without
// wxHAS_XLOCALE_SUPPORT the only valid locale is the "C" one)
bool IsOk() const { return m_isC; }
private:
// Special ctor for the "C" locale, it's only used internally as the user
// code is supposed to use GetCLocale()
wxXLocale(struct wxXLocaleCTag * WXUNUSED(dummy)) { m_isC = true; }
// Without xlocale support this class can only represent "C" locale, if
// this is false the object is invalid
bool m_isC;
// although it's not a problem to copy the objects of this class, we use
// this macro in this implementation for consistency with the xlocale-based
// one which can't be copied when using MSVC locale API
wxDECLARE_NO_COPY_CLASS(wxXLocale);
};
#endif // wxHAS_XLOCALE_SUPPORT/!wxHAS_XLOCALE_SUPPORT
// A shorter synonym for the most commonly used locale object
#define wxCLocale (wxXLocale::GetCLocale())
extern WXDLLIMPEXP_DATA_BASE(wxXLocale) wxNullXLocale;
// Wrappers for various functions:
#ifdef wxHAS_XLOCALE_SUPPORT
// ctype functions
#define wxCRT_Isalnum_lA wxXLOCALE_IDENT(isalnum_l)
#define wxCRT_Isalpha_lA wxXLOCALE_IDENT(isalpha_l)
#define wxCRT_Iscntrl_lA wxXLOCALE_IDENT(iscntrl_l)
#define wxCRT_Isdigit_lA wxXLOCALE_IDENT(isdigit_l)
#define wxCRT_Isgraph_lA wxXLOCALE_IDENT(isgraph_l)
#define wxCRT_Islower_lA wxXLOCALE_IDENT(islower_l)
#define wxCRT_Isprint_lA wxXLOCALE_IDENT(isprint_l)
#define wxCRT_Ispunct_lA wxXLOCALE_IDENT(ispunct_l)
#define wxCRT_Isspace_lA wxXLOCALE_IDENT(isspace_l)
#define wxCRT_Isupper_lA wxXLOCALE_IDENT(isupper_l)
#define wxCRT_Isxdigit_lA wxXLOCALE_IDENT(isxdigit_l)
#define wxCRT_Tolower_lA wxXLOCALE_IDENT(tolower_l)
#define wxCRT_Toupper_lA wxXLOCALE_IDENT(toupper_l)
inline int wxIsalnum_l(char c, const wxXLocale& loc)
{ return wxCRT_Isalnum_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIsalpha_l(char c, const wxXLocale& loc)
{ return wxCRT_Isalpha_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIscntrl_l(char c, const wxXLocale& loc)
{ return wxCRT_Iscntrl_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIsdigit_l(char c, const wxXLocale& loc)
{ return wxCRT_Isdigit_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIsgraph_l(char c, const wxXLocale& loc)
{ return wxCRT_Isgraph_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIslower_l(char c, const wxXLocale& loc)
{ return wxCRT_Islower_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIsprint_l(char c, const wxXLocale& loc)
{ return wxCRT_Isprint_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIspunct_l(char c, const wxXLocale& loc)
{ return wxCRT_Ispunct_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIsspace_l(char c, const wxXLocale& loc)
{ return wxCRT_Isspace_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIsupper_l(char c, const wxXLocale& loc)
{ return wxCRT_Isupper_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxIsxdigit_l(char c, const wxXLocale& loc)
{ return wxCRT_Isxdigit_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxTolower_l(char c, const wxXLocale& loc)
{ return wxCRT_Tolower_lA(static_cast<unsigned char>(c), loc.Get()); }
inline int wxToupper_l(char c, const wxXLocale& loc)
{ return wxCRT_Toupper_lA(static_cast<unsigned char>(c), loc.Get()); }
// stdlib functions for numeric <-> string conversion
// NOTE: GNU libc does not have ato[fil]_l functions;
// MSVC++8 does not have _strto[u]ll_l functions;
// thus we take the minimal set of functions provided in both environments:
#define wxCRT_Strtod_lA wxXLOCALE_IDENT(strtod_l)
#define wxCRT_Strtol_lA wxXLOCALE_IDENT(strtol_l)
#define wxCRT_Strtoul_lA wxXLOCALE_IDENT(strtoul_l)
inline double wxStrtod_lA(const char *c, char **endptr, const wxXLocale& loc)
{ return wxCRT_Strtod_lA(c, endptr, loc.Get()); }
inline long wxStrtol_lA(const char *c, char **endptr, int base, const wxXLocale& loc)
{ return wxCRT_Strtol_lA(c, endptr, base, loc.Get()); }
inline unsigned long wxStrtoul_lA(const char *c, char **endptr, int base, const wxXLocale& loc)
{ return wxCRT_Strtoul_lA(c, endptr, base, loc.Get()); }
#if wxUSE_UNICODE
// ctype functions
#define wxCRT_Isalnum_lW wxXLOCALE_IDENT(iswalnum_l)
#define wxCRT_Isalpha_lW wxXLOCALE_IDENT(iswalpha_l)
#define wxCRT_Iscntrl_lW wxXLOCALE_IDENT(iswcntrl_l)
#define wxCRT_Isdigit_lW wxXLOCALE_IDENT(iswdigit_l)
#define wxCRT_Isgraph_lW wxXLOCALE_IDENT(iswgraph_l)
#define wxCRT_Islower_lW wxXLOCALE_IDENT(iswlower_l)
#define wxCRT_Isprint_lW wxXLOCALE_IDENT(iswprint_l)
#define wxCRT_Ispunct_lW wxXLOCALE_IDENT(iswpunct_l)
#define wxCRT_Isspace_lW wxXLOCALE_IDENT(iswspace_l)
#define wxCRT_Isupper_lW wxXLOCALE_IDENT(iswupper_l)
#define wxCRT_Isxdigit_lW wxXLOCALE_IDENT(iswxdigit_l)
#define wxCRT_Tolower_lW wxXLOCALE_IDENT(towlower_l)
#define wxCRT_Toupper_lW wxXLOCALE_IDENT(towupper_l)
inline int wxIsalnum_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isalnum_lW(c, loc.Get()); }
inline int wxIsalpha_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isalpha_lW(c, loc.Get()); }
inline int wxIscntrl_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Iscntrl_lW(c, loc.Get()); }
inline int wxIsdigit_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isdigit_lW(c, loc.Get()); }
inline int wxIsgraph_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isgraph_lW(c, loc.Get()); }
inline int wxIslower_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Islower_lW(c, loc.Get()); }
inline int wxIsprint_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isprint_lW(c, loc.Get()); }
inline int wxIspunct_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Ispunct_lW(c, loc.Get()); }
inline int wxIsspace_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isspace_lW(c, loc.Get()); }
inline int wxIsupper_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isupper_lW(c, loc.Get()); }
inline int wxIsxdigit_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Isxdigit_lW(c, loc.Get()); }
inline wchar_t wxTolower_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Tolower_lW(c, loc.Get()); }
inline wchar_t wxToupper_l(wchar_t c, const wxXLocale& loc)
{ return wxCRT_Toupper_lW(c, loc.Get()); }
// stdlib functions for numeric <-> string conversion
// (see notes above about missing functions)
#define wxCRT_Strtod_lW wxXLOCALE_IDENT(wcstod_l)
#define wxCRT_Strtol_lW wxXLOCALE_IDENT(wcstol_l)
#define wxCRT_Strtoul_lW wxXLOCALE_IDENT(wcstoul_l)
inline double wxStrtod_l(const wchar_t *c, wchar_t **endptr, const wxXLocale& loc)
{ return wxCRT_Strtod_lW(c, endptr, loc.Get()); }
inline long wxStrtol_l(const wchar_t *c, wchar_t **endptr, int base, const wxXLocale& loc)
{ return wxCRT_Strtol_lW(c, endptr, base, loc.Get()); }
inline unsigned long wxStrtoul_l(const wchar_t *c, wchar_t **endptr, int base, const wxXLocale& loc)
{ return wxCRT_Strtoul_lW(c, endptr, base, loc.Get()); }
#else // !wxUSE_UNICODE
inline double wxStrtod_l(const char *c, char **endptr, const wxXLocale& loc)
{ return wxCRT_Strtod_lA(c, endptr, loc.Get()); }
inline long wxStrtol_l(const char *c, char **endptr, int base, const wxXLocale& loc)
{ return wxCRT_Strtol_lA(c, endptr, base, loc.Get()); }
inline unsigned long wxStrtoul_l(const char *c, char **endptr, int base, const wxXLocale& loc)
{ return wxCRT_Strtoul_lA(c, endptr, base, loc.Get()); }
#endif // wxUSE_UNICODE
#else // !wxHAS_XLOCALE_SUPPORT
// ctype functions
int WXDLLIMPEXP_BASE wxIsalnum_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIsalpha_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIscntrl_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIsdigit_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIsgraph_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIslower_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIsprint_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIspunct_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIsspace_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIsupper_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxIsxdigit_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxTolower_l(const wxUniChar& c, const wxXLocale& loc);
int WXDLLIMPEXP_BASE wxToupper_l(const wxUniChar& c, const wxXLocale& loc);
// stdlib functions
double WXDLLIMPEXP_BASE wxStrtod_l(const wchar_t* str, wchar_t **endptr, const wxXLocale& loc);
double WXDLLIMPEXP_BASE wxStrtod_l(const char* str, char **endptr, const wxXLocale& loc);
long WXDLLIMPEXP_BASE wxStrtol_l(const wchar_t* str, wchar_t **endptr, int base, const wxXLocale& loc);
long WXDLLIMPEXP_BASE wxStrtol_l(const char* str, char **endptr, int base, const wxXLocale& loc);
unsigned long WXDLLIMPEXP_BASE wxStrtoul_l(const wchar_t* str, wchar_t **endptr, int base, const wxXLocale& loc);
unsigned long WXDLLIMPEXP_BASE wxStrtoul_l(const char* str, char **endptr, int base, const wxXLocale& loc);
#endif // wxHAS_XLOCALE_SUPPORT/!wxHAS_XLOCALE_SUPPORT
#endif // wxUSE_XLOCALE
#endif // _WX_XLOCALE_H_
| h |
Subsets and Splits