Amebis/wxExtend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Doxygen documentation update

Browse Source
This commit is contained in:
Simon Rozman 2016-11-02 00:58:06 +01:00
parent 7f31e51fb0
commit a6b34f122d
15 changed files with 259 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Doxyfile
View File

@ -32,7 +32,7 @@ DOXYFILE_ENCODING = UTF-8
# title of most generated pages and in a few other places.
# The default value is: My Project.
PROJECT_NAME = "atlex"
PROJECT_NAME = "wxExtend"
# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
# could be handy for archiving the generated documentation or if some version
@ -694,7 +694,7 @@ CITE_BIB_FILES =
# messages are off.
# The default value is: NO.
QUIET = NO
QUIET = YES
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES

86
include/wxex/appbar.h
View File

@ -32,10 +32,23 @@
#include <ShlObj.h>
#define wxABT_AUTOHIDETIMERID 1
#define wxABT_AUTOHIDETIME 300
#define wxABT_AUTOHIDETIMERINTERVAL 3000
/// \addtogroup wxExtend
/// @{
///
/// Application bar auto-hide timer ID
///
#define wxABT_AUTOHIDETIMERID 1
///
/// Application bar auto-hide timer timeout
///
#define wxABT_AUTOHIDETIME 300
///
/// Application bar auto-hide timer interval
///
#define wxABT_AUTOHIDETIMERINTERVAL 3000
///
/// Posted to notify application bar about system changes
@ -100,16 +113,21 @@ enum wxAppBarFlags {
template <class W>
class wxAppBar : public W
{
protected:
// common part of all ctors
void Init();
public:
///
/// Creates new application bar
///
wxAppBar();
///
/// Destructor
///
virtual ~wxAppBar();
protected:
/// \cond internal
void PreCreate(wxAppBarState& state, int& flags, const wxSize& size, long& style);
/// \endcond
public:
/// \name Application bar general management
@ -191,9 +209,14 @@ public:
/// Restore application bar from the edge of the desktop.
///
/// \param[in] rect The desired coordinates of the restored window. If NULL internally saved coordinates are used.
/// \param[in] wnd When the undocked and docked window is different, this parameter denotes the undocked version.
///
void MaximiseFromEdge(const RECT* rect = NULL);
///
/// Restore application bar from the edge of the desktop.
///
/// \param[in] wnd When the undocked and docked window is different, this parameter denotes the undocked version.
///
void MaximiseFromEdge(wxWindow *wnd);
///
@ -251,15 +274,19 @@ protected:
/// @}
protected:
/// \cond internal
virtual WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
/// \endcond
private:
/// \cond internal
inline bool DockAppBar(wxAppBarState state);
inline bool UndockAppBar();
inline bool RegisterAutoHide(wxAppBarState state);
inline bool UnregisterAutoHide(wxAppBarState state);
inline bool GetDockedRect(wxAppBarState state, LPRECT rect) const;
inline bool GetAutoHideRect(wxAppBarState state, bool bAutoHidden, LPRECT rect) const;
/// \endcond
protected:
wxAppBarState m_state; ///< Current state of the application bar
@ -289,7 +316,14 @@ protected:
class WXEXTEND_API wxAppBarFrame : public wxAppBar<wxFrame>
{
public:
///
/// Creates application bar frame
///
wxAppBarFrame();
///
/// Creates application bar frame
///
wxAppBarFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
@ -300,6 +334,9 @@ public:
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
///
/// Creates application bar frame
///
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
@ -318,7 +355,14 @@ public:
class WXEXTEND_API wxAppBarDialog : public wxAppBar<wxDialog>
{
public:
///
/// Creates application bar dialog
///
wxAppBarDialog();
///
/// Creates application bar dialog
///
wxAppBarDialog(wxWindow *parent,
wxWindowID id,
const wxString& title,
@ -329,6 +373,9 @@ public:
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxDialogNameStr);
///
/// Creates application bar dialog
///
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
@ -460,22 +507,17 @@ inline UINT_PTR wxAppBarGetTaskBarState()
}
/// @}
//////////////////////////////////////////////////////////////////////////
// wxAppBar
//////////////////////////////////////////////////////////////////////////
template <class W>
void wxAppBar<W>::Init()
wxAppBar<W>::wxAppBar() :
m_taskbarList(NULL),
m_timerID(0)
{
m_taskbarList = NULL;
m_timerID = 0;
}
template <class W>
wxAppBar<W>::wxAppBar()
{
Init();
}
@ -487,6 +529,7 @@ wxAppBar<W>::~wxAppBar()
}
/// \cond internal
template <class W>
void wxAppBar<W>::PreCreate(wxAppBarState& state, int& flags, const wxSize& size, long& style)
{
@ -539,6 +582,7 @@ void wxAppBar<W>::PreCreate(wxAppBarState& state, int& flags, const wxSize& size
} else
wxFAIL_MSG(wxString::Format(wxT("TaskbarList creation failed 0x%x"), hr));
}
/// \endcond
template <class W>
@ -993,6 +1037,7 @@ void wxAppBar<W>::OnAutoHideDenied()
}
/// \cond internal
template <class W>
WXLRESULT wxAppBar<W>::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
@ -1387,8 +1432,11 @@ WXLRESULT wxAppBar<W>::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM l
return W::MSWWindowProc(message, wParam, lParam);
}
}
/// \endcond
/// \cond internal
template <class W>
inline bool wxAppBar<W>::DockAppBar(wxAppBarState state)
{
@ -1571,3 +1619,5 @@ inline bool wxAppBar<W>::GetAutoHideRect(wxAppBarState state, bool bAutoHidden,
return true;
}
/// \endcond

4
include/wxex/aui/framemanager.h
View File

@ -25,6 +25,8 @@
#include <wx/aui/framemanager.h>
#include <wx/string.h>
/// \addtogroup wxExtend
/// @{
///
/// Updates perspective captions with matching captions from panes.
@ -37,3 +39,5 @@
/// - \c false otherwise
///
bool WXEXTEND_API wxAuiManagerUpdatePerspectiveCaptions(wxAuiManager& mgr, wxString& perspective);
/// @}

29
include/wxex/common.h
View File

@ -21,20 +21,23 @@
#if !defined(__wxEXTEND_common_h__)
#define __wxEXTEND_common_h__
/// \addtogroup wxExtend
/// @{
///
/// wxExtend Version
///
#define wxEXTEND_VERSION 0x01050100
#define wxEXTEND_VERSION_MAJ 1
#define wxEXTEND_VERSION_MIN 5
#define wxEXTEND_VERSION_REV 1
#define wxEXTEND_VERSION_BUILD 0
#define wxEXTEND_VERSION_MAJ 1 ///< wxExtend Major Version
#define wxEXTEND_VERSION_MIN 5 ///< wxExtend Minor Version
#define wxEXTEND_VERSION_REV 1 ///< wxExtend Revision
#define wxEXTEND_VERSION_BUILD 0 ///< wxExtend Build
#define wxEXTEND_VERSION_STR "1.5.1"
#define wxEXTEND_BUILD_YEAR_STR "2016"
#define wxEXTEND_VERSION_STR "1.5.1" ///< wxExtend Displayable Version
#define wxEXTEND_BUILD_YEAR_STR "2016" ///< wxExtend Build Year
#define wxExtendVersion "15"
#define wxExtendVersion "15" ///< wxExtend API Version
#if !defined(RC_INVOKED) && !defined(MIDL_PASS)
@ -45,7 +48,6 @@
#include <wx/defs.h>
#include <wx/intl.h>
///
/// Public function calling convention
///
@ -61,7 +63,7 @@
///
/// Debug macros
/// Test if condition is true. When not true, raise debug assertion with the given message.
///
#if wxDEBUG_LEVEL
#define wxVERIFY_MSG(cond, msg) \
@ -74,7 +76,13 @@
wxTrap(); \
} \
wxSTATEMENT_MACRO_END
#endif
///
/// Test if condition is true. When not true, raise debug assertion.
///
#if wxDEBUG_LEVEL
#define wxVERIFY(cond) wxVERIFY_MSG(cond, (const char*)NULL)
#else
#define wxVERIFY(cond) (cond)
@ -164,4 +172,7 @@ inline bool wxInitializeLocale(wxLocale &locale, wxLanguage *language = NULL)
}
#endif // !defined(RC_INVOKED) && !defined(MIDL_PASS)
/// @}
#endif // !defined(__wxEXTEND_common_h__)

6
include/wxex/comutils.h
View File

@ -22,6 +22,8 @@
#include "common.h"
/// \addtogroup wxExtend
/// @{
///
/// Create an object of this class on stack to initialize/cleanup the COM automatically.
@ -32,7 +34,7 @@ public:
///
/// Initialize the COM
///
/// \param[in] dwCoInit The concurrency model and initialization options for the thread to pass to \c CoInitializeEx
/// \param[in] dwCoInit The concurrency model and initialization options for the thread to pass to `CoInitializeEx()`
///
wxCoInitializer(DWORD dwCoInit = COINIT_MULTITHREADED);
@ -62,3 +64,5 @@ public:
private:
bool m_ok;
};
/// @}

48
include/wxex/crypto.h
View File

@ -29,6 +29,8 @@
#include <Wincrypt.h>
/// \addtogroup wxExtend
/// @{
///
/// Cryptographics Session Base Class
@ -39,7 +41,15 @@ protected:
HCRYPTPROV m_h; ///< Session Handle
public:
///
/// Creates a new cryptographics session
///
wxCryptoSession();
///
/// Destructor
///
virtual ~wxCryptoSession();
@ -72,6 +82,9 @@ public:
class WXEXTEND_API wxCryptoSessionRSAAES : public wxCryptoSession
{
public:
///
/// Creates a new RSA AES cryptographics session
///
wxCryptoSessionRSAAES();
};
@ -85,7 +98,15 @@ protected:
HCRYPTHASH m_h; ///< Hash Handle
public:
///
/// Creates a new cryptographics hash
///
wxCryptoHash();
///
/// Destructor
///
virtual ~wxCryptoHash();
@ -226,6 +247,9 @@ public:
class WXEXTEND_API wxCryptoHashSHA1 : public wxCryptoHash
{
public:
///
/// Creates a new cryptographics SHA-1 hash
///
wxCryptoHashSHA1(wxCryptoSession &session);
@ -247,8 +271,19 @@ public:
///
class WXEXTEND_API wxCryptoKey
{
protected:
HCRYPTKEY m_h; ///< Key Handle
public:
///
/// Creates a new cryptographics key
///
wxCryptoKey();
///
/// Destructor
///
virtual ~wxCryptoKey();
@ -274,11 +309,16 @@ public:
}
///
/// Imports private key
///
bool ImportPrivate(wxCryptoSession &session, const void *data, size_t size);
bool ImportPublic(wxCryptoSession &session, const void *data, size_t size);
protected:
HCRYPTKEY m_h;
///
/// Imports public key
///
bool ImportPublic(wxCryptoSession &session, const void *data, size_t size);
};
@ -312,3 +352,5 @@ inline bool wxCryptoVerifySignature(const wxCryptoHash &hash, const wxMemoryBuff
{
return wxCryptoVerifySignature(hash, signature.GetData(), signature.GetDataLen(), key);
}
/// @}

15
include/wxex/hex.h
View File

@ -30,6 +30,9 @@
// Encoding Functions
// ----------------------------------------------------------------------------
/// \addtogroup wxExtend
/// @{
///
/// Return the size needed for the buffer containing the encoded representation
/// of a buffer of given length
@ -55,7 +58,7 @@ inline size_t wxHexEncodedSize(size_t len)
///
/// \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 \c{wxHexEncodedSize(srcLen)} size or call the function with NULL buffer in
/// of `wxHexEncodedSize(srcLen)` size or call the function with NULL buffer in
/// which case the required size will be returned
///
size_t WXEXTEND_API wxHexEncode(char *dst, size_t dstLen, const void *src, size_t srcLen);
@ -135,7 +138,7 @@ inline size_t wxHexDecodedSize(size_t len)
/// \param[in] dstLen Length of \p dst buffer (in bytes)
/// \param[in] src Source buffer to decode
/// \param[in] srcLen Length of \p src buffer (in characters) or wxNO_LEN for zero terminated strings
/// \param[in] mode Desired behaviour on invalid characters (one of \c wxHexDecodeMode constants)
/// \param[in] mode Desired behaviour on invalid characters (one of `wxHexDecodeMode` constants)
/// \param[out] posErr Error offset in source buffer (in characters)
///
/// \returns The length of the decoded data or wxCONV_FAILED if an error occurs
@ -156,7 +159,7 @@ size_t WXEXTEND_API wxHexDecode(void *dst, size_t dstLen, const char *src, size_
/// \param[out] dst Destination buffer to receive decoded data
/// \param[in] dstLen Length of \p dst buffer (in bytes)
/// \param[in] src Source string to decode
/// \param[in] mode Desired behaviour on invalid characters (one of \c wxHexDecodeMode constants)
/// \param[in] mode Desired behaviour on invalid characters (one of `wxHexDecodeMode` constants)
/// \param[out] posErr Error offset in source buffer (in characters)
///
/// \returns The length of the decoded data or wxCONV_FAILED if an error occurs
@ -182,7 +185,7 @@ inline size_t wxHexDecode(void *dst, size_t dstLen, const wxString& src, wxHexDe
///
/// \param[in] src Source buffer to decode
/// \param[in] srcLen Length of \p src buffer (in characters) or wxNO_LEN for zero terminated strings
/// \param[in] mode Desired behaviour on invalid characters (one of \c wxHexDecodeMode constants)
/// \param[in] mode Desired behaviour on invalid characters (one of `wxHexDecodeMode` constants)
/// \param[out] posErr Error offset in source buffer (in characters)
///
/// \returns Destination buffer with decoded data or an empty buffer if an error occured during decoding
@ -198,7 +201,7 @@ wxMemoryBuffer WXEXTEND_API wxHexDecode(const char *src, size_t srcLen = wxNO_LE
/// whitespace or all invalid characters using its \p mode argument
///
/// \param[in] src Source string to decode
/// \param[in] mode Desired behaviour on invalid characters (one of \c wxHexDecodeMode constants)
/// \param[in] mode Desired behaviour on invalid characters (one of `wxHexDecodeMode` constants)
/// \param[out] posErr Error offset in source buffer (in characters)
///
/// \returns Destination buffer with decoded data or an empty buffer if an error occured during decoding
@ -209,3 +212,5 @@ inline wxMemoryBuffer wxHexDecode(const wxString& src, wxHexDecodeMode mode = wx
// strings with embedded NULs
return wxHexDecode(src.ToAscii(), wxNO_LEN, mode, posErr);
}
/// @}

32
include/wxex/persist/auimanager.h
View File

@ -28,43 +28,61 @@
#include <wx/aui/framemanager.h>
// ----------------------------------------------------------------------------
// string constants used by wxPersistentAuiManager
// ----------------------------------------------------------------------------
/// \addtogroup wxExtend
/// @{
///
/// `wxPersistentAuiManager` kind for persistent storage
///
#define wxPERSIST_AUIMGR_KIND "AuiManager"
// names for persistent options
///
/// Name of the persistent storage variable for saving Aui manager state
///
#define wxPERSIST_AUIMGR_PERSPECTIVE "perspective"
///
/// Supports saving/restoring wxAuiManager state
///
class wxPersistentAuiManager : public wxPersistentObject
{
public:
///
/// Constructs a persistent Aui manager object
///
wxPersistentAuiManager(wxAuiManager *mgr) : wxPersistentObject(mgr)
{
}
///
/// \returns `wxT(wxPERSIST_AUIMGR_KIND)`
///
virtual wxString GetKind() const
{
return wxT(wxPERSIST_AUIMGR_KIND);
}
///
/// Returns name of the window
///
virtual wxString GetName() const
{
// Borrow the name of wxAguiManager from its window.
return GetManager()->GetManagedWindow()->GetName();
}
///
/// Saves Aui manager state
///
virtual void Save() const
{
// Save perspective string to configuration.
SaveValue(wxT(wxPERSIST_AUIMGR_PERSPECTIVE), GetManager()->SavePerspective());
}
///
/// Restores Aui manager state
///
virtual bool Restore()
{
// Load perspective string from configuration.
@ -80,10 +98,12 @@ public:
}
protected:
/// \cond internal
wxAuiManager *GetManager() const
{
return static_cast<wxAuiManager*>(GetObject());
}
/// \endcond
private:
wxDECLARE_NO_COPY_CLASS(wxPersistentAuiManager);
@ -97,3 +117,5 @@ inline wxPersistentObject *wxCreatePersistentObject(wxAuiManager *mgr)
{
return new wxPersistentAuiManager(mgr);
}
/// @}

24
include/wxex/persist/dialog.h
View File

@ -27,29 +27,38 @@
#include <wx/persist/window.h>
#include <wx/dialog.h>
/// \addtogroup wxExtend
/// @{
// ----------------------------------------------------------------------------
// string constants used by wxPersistentDialog
// ----------------------------------------------------------------------------
///
/// `wxPersistentDialog` kind for persistent storage
///
#define wxPERSIST_DIALOG_KIND "Dialog"
///
/// Supports saving/restoring wxDialog state
///
class wxPersistentDialog : public wxPersistentWindow<wxDialog>
{
public:
///
/// Constructs a persistent dialog object
///
wxPersistentDialog(wxDialog *mgr) : wxPersistentWindow<wxDialog>(mgr)
{
}
///
/// \returns `wxT(wxPERSIST_DIALOG_KIND)`
///
virtual wxString GetKind() const
{
return wxT(wxPERSIST_DIALOG_KIND);
}
///
/// Saves dialog state
///
virtual void Save() const
{
const wxDialog * const wnd = Get();
@ -60,6 +69,9 @@ public:
SaveValue(wxPERSIST_TLW_Y, pos.y);
}
///
/// Restores dialog state
///
virtual bool Restore()
{
wxDialog * const wnd = Get();
@ -102,3 +114,5 @@ inline wxPersistentObject *wxCreatePersistentObject(wxDialog *mgr)
{
return new wxPersistentDialog(mgr);
}
/// @}

15
include/wxex/url.h
View File

@ -25,9 +25,11 @@
#include "wx/string.h"
#include "wx/buffer.h"
/// \addtogroup wxExtend
/// @{
///
/// Return if given character should be protected for URL encoding
/// Test if given character should be protected for URL encoding
///
/// \param[in] chr ASCII character
///
@ -67,8 +69,7 @@ inline bool wxURLIsProtected(char chr)
/// Return the size needed for the buffer containing the encoded representation
/// of a string of given length
///
/// \param[in] src Source string to encode
/// \param[in] srcLen Length of \p src string (in bytes)
/// \param[in] len Length of string (in bytes)
///
/// \returns Maximum encoded representation size (in characters)
///
@ -89,7 +90,7 @@ inline size_t wxURLEncodedSize(size_t len)
///
/// \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 \c{wxURLEncodedSize(srcLen)} size or call the function with NULL string in
/// of `wxURLEncodedSize(srcLen)` size or call the function with NULL string in
/// which case the required size will be returned
///
size_t WXEXTEND_API wxURLEncode(char *dst, size_t dstLen, const char *src, size_t srcLen);
@ -169,7 +170,7 @@ inline size_t wxURLDecodedSize(size_t len)
///
/// \returns The length of the decoded data or wxCONV_FAILED if the buffer is not
/// large enough; to determine the needed size you can either allocate a buffer
/// of \c{wxURLDecodedSize(srcLen)} size or call the function with NULL string in
/// of `wxURLDecodedSize(srcLen)` size or call the function with NULL string in
/// which case the required size will be returned
///
size_t WXEXTEND_API wxURLDecode(char *dst, size_t dstLen, const char *src, size_t srcLen = wxNO_LEN);
@ -184,7 +185,7 @@ size_t WXEXTEND_API wxURLDecode(char *dst, size_t dstLen, const char *src, size_
///
/// \returns The length of the decoded data or wxCONV_FAILED if the buffer is not
/// large enough; to determine the needed size you can either allocate a buffer
/// of \c{wxURLDecodedSize(srcLen)} size or call the function with NULL string in
/// of `wxURLDecodedSize(srcLen)` size or call the function with NULL string in
/// which case the required size will be returned
///
inline size_t wxURLDecode(char *dst, size_t dstLen, const wxString& src)
@ -220,3 +221,5 @@ inline wxMemoryBuffer wxURLDecode(const wxString& src)
// strings with embedded NULs
return wxURLDecode(src.ToAscii(), wxNO_LEN);
}
/// @}

39
include/wxex/valhex.h
View File

@ -24,6 +24,8 @@
#include <wx/valnum.h>
/// \addtogroup wxExtend
/// @{
///
/// Bit masks used for hexadecimal validator styles.
@ -48,22 +50,49 @@ enum wxHexValidatorStyle
class WXEXTEND_API wxHexValidatorBase : public wxIntegerValidatorBase
{
protected:
///
/// Constructs new hexadecimal validator
///
wxHexValidatorBase(int style);
///
/// Copies a hexadecimal validator
///
wxHexValidatorBase(const wxHexValidatorBase& other);
///
/// Tests whether minus is acceptable at given position
///
/// \returns Always `false`
///
bool IsMinusOk(const wxString& val, int pos) const;
///
/// Converts string to long
///
static bool FromString(const wxString& s, long *value);
#ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
///
/// Converts string to long long
///
static bool FromString(const wxString &s, wxLongLong_t *value);
#endif
///
/// Converts number to string
///
wxString ToString(LongestValueType value) const;
protected:
/// \cond internal
void DoSetWidth(unsigned int width) { m_width = width; }
/// \endcond
private:
/// \cond internal
virtual bool IsCharOk(const wxString& val, int pos, wxChar ch) const;
/// \endcond
private:
unsigned int m_width; ///< Preferred width of the string - zero padding (<=1 disables padding)
@ -81,8 +110,11 @@ template <typename T>
class wxHexValidator : public wxPrivate::wxNumValidator<wxHexValidatorBase, T>
{
public:
typedef wxPrivate::wxNumValidator<wxHexValidatorBase, T> Base;
typedef wxPrivate::wxNumValidator<wxHexValidatorBase, T> Base; ///< Base class type
///
/// Constructs new hexadecimal validator
///
wxHexValidator(ValueType *value = NULL, int style = wxNUM_VAL_DEFAULT, unsigned int width = 0) : Base(value, style)
{
this->DoSetWidth(width);
@ -90,8 +122,13 @@ public:
this->DoSetMax(std::numeric_limits<ValueType>::max());
}
///
/// Clones this validator
///
virtual wxObject *Clone() const { return new wxHexValidator(*this); }
private:
wxDECLARE_NO_ASSIGN_CLASS(wxHexValidator);
};
/// @}

4
include/wxex/valnet.h
View File

@ -26,6 +26,8 @@
#include <wx/textctrl.h>
#include <wx/validate.h>
/// \addtogroup wxExtend
/// @{
#ifdef __VISUALC__
// non dll-interface class 'xxx' used as base for dll-interface class 'yyy'
@ -170,3 +172,5 @@ private:
#ifdef __VISUALC__
#pragma warning(pop)
#endif
/// @}

5
include/wxex/xml.h
View File

@ -27,6 +27,8 @@
#include <wx/string.h>
#include <wx/xml/xml.h>
/// \addtogroup wxExtend
/// @{
///
/// Escapes text string for XML insertion
@ -108,7 +110,6 @@ inline wxString wxXmlEscapeAttr(_In_ const wxString& str)
}
///
/// Calculates hash of the node and all its children
///
@ -117,3 +118,5 @@ inline wxString wxXmlEscapeAttr(_In_ const wxString& str)
///
///
bool WXEXTEND_API wxXmlHashNode(_In_ wxCryptoHash &hash, const wxXmlNode *node);
/// @}

4
src/appbar.cpp
View File

@ -28,13 +28,11 @@
wxAppBarFrame::wxAppBarFrame()
{
Init();
}
wxAppBarFrame::wxAppBarFrame(wxWindow *parent, wxWindowID id, const wxString& title, wxAppBarState state, int flags, const wxPoint& pos, const wxSize& size, long style, const wxString& name)
{
Init();
Create(parent, id, title, state, flags, pos, size, style, name);
}
@ -57,13 +55,11 @@ bool wxAppBarFrame::Create(wxWindow *parent, wxWindowID id, const wxString& titl
wxAppBarDialog::wxAppBarDialog()
{
Init();
}
wxAppBarDialog::wxAppBarDialog(wxWindow *parent, wxWindowID id, const wxString& title, wxAppBarState state, int flags, const wxPoint& pos, const wxSize& size, long style, const wxString& name)
{
Init();
Create(parent, id, title, state, flags, pos, size, style, name);
}

2
src/valhex.cpp
View File

@ -88,6 +88,7 @@ wxString wxHexValidatorBase::ToString(LongestValueType value) const
}
/// \cond internal
bool wxHexValidatorBase::IsCharOk(const wxString& val, int pos, wxChar ch) const
{
// We only accept hexadecimal digits here.
@ -101,3 +102,4 @@ bool wxHexValidatorBase::IsCharOk(const wxString& val, int pos, wxChar ch) const
return IsInRange(value);
}
/// \endcond