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/checkeddelete.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/checkeddelete.h
// Purpose: wxCHECKED_DELETE() macro
// Author: Vadim Zeitlin
// Created: 2009-02-03
// Copyright: (c) 2002-2009 wxWidgets dev team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHECKEDDELETE_H_
#define _WX_CHECKEDDELETE_H_
#include "wx/cpp.h"
// TODO: provide wxCheckedDelete[Array]() template functions too
// ----------------------------------------------------------------------------
// wxCHECKED_DELETE and wxCHECKED_DELETE_ARRAY macros
// ----------------------------------------------------------------------------
/*
checked deleters are used to make sure that the type being deleted is really
a complete type.: otherwise sizeof() would result in a compile-time error
do { ... } while ( 0 ) construct is used to have an anonymous scope
(otherwise we could have name clashes between different "complete"s) but
still force a semicolon after the macro
*/
#define wxCHECKED_DELETE(ptr) \
wxSTATEMENT_MACRO_BEGIN \
typedef char complete[sizeof(*ptr)] WX_ATTRIBUTE_UNUSED; \
delete ptr; \
wxSTATEMENT_MACRO_END
#define wxCHECKED_DELETE_ARRAY(ptr) \
wxSTATEMENT_MACRO_BEGIN \
typedef char complete[sizeof(*ptr)] WX_ATTRIBUTE_UNUSED; \
delete [] ptr; \
wxSTATEMENT_MACRO_END
#endif // _WX_CHECKEDDELETE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/ownerdrw.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ownerdrw.h
// Purpose: interface for owner-drawn GUI elements
// Author: Vadim Zeitlin
// Modified by: Marcin Malich
// Created: 11.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OWNERDRW_H_BASE
#define _WX_OWNERDRW_H_BASE
#include "wx/defs.h"
#if wxUSE_OWNER_DRAWN
#include "wx/font.h"
#include "wx/colour.h"
class WXDLLIMPEXP_FWD_CORE wxDC;
// ----------------------------------------------------------------------------
// wxOwnerDrawn - a mix-in base class, derive from it to implement owner-drawn
// behaviour
//
// wxOwnerDrawn supports drawing of an item with non standard font, color and
// also supports 3 bitmaps: either a checked/unchecked bitmap for a checkable
// element or one unchangeable bitmap otherwise.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxOwnerDrawnBase
{
public:
wxOwnerDrawnBase()
{
m_ownerDrawn = false;
m_margin = ms_defaultMargin;
}
virtual ~wxOwnerDrawnBase() {}
void SetFont(const wxFont& font)
{ m_font = font; m_ownerDrawn = true; }
wxFont& GetFont() const
{ return (wxFont&) m_font; }
void SetTextColour(const wxColour& colText)
{ m_colText = colText; m_ownerDrawn = true; }
wxColour& GetTextColour() const
{ return (wxColour&) m_colText; }
void SetBackgroundColour(const wxColour& colBack)
{ m_colBack = colBack; m_ownerDrawn = true; }
wxColour& GetBackgroundColour() const
{ return (wxColour&) m_colBack ; }
void SetMarginWidth(int width)
{ m_margin = width; }
int GetMarginWidth() const
{ return m_margin; }
static int GetDefaultMarginWidth()
{ return ms_defaultMargin; }
// get item name (with mnemonics if exist)
virtual wxString GetName() const = 0;
// this function might seem strange, but if it returns false it means that
// no non-standard attribute are set, so there is no need for this control
// to be owner-drawn. Moreover, you can force owner-drawn to false if you
// want to change, say, the color for the item but only if it is owner-drawn
// (see wxMenuItem::wxMenuItem for example)
bool IsOwnerDrawn() const
{ return m_ownerDrawn; }
// switch on/off owner-drawing the item
void SetOwnerDrawn(bool ownerDrawn = true)
{ m_ownerDrawn = ownerDrawn; }
// constants used in OnDrawItem
// (they have the same values as corresponding Win32 constants)
enum wxODAction
{
wxODDrawAll = 0x0001, // redraw entire control
wxODSelectChanged = 0x0002, // selection changed (see Status.Select)
wxODFocusChanged = 0x0004 // keyboard focus changed (see Status.Focus)
};
enum wxODStatus
{
wxODSelected = 0x0001, // control is currently selected
wxODGrayed = 0x0002, // item is to be grayed
wxODDisabled = 0x0004, // item is to be drawn as disabled
wxODChecked = 0x0008, // item is to be checked
wxODHasFocus = 0x0010, // item has the keyboard focus
wxODDefault = 0x0020, // item is the default item
wxODHidePrefix= 0x0100 // hide keyboard cues (w2k and xp only)
};
// virtual functions to implement drawing (return true if processed)
virtual bool OnMeasureItem(size_t *width, size_t *height);
virtual bool OnDrawItem(wxDC& dc, const wxRect& rc, wxODAction act, wxODStatus stat) = 0;
protected:
// get the font and colour to use, whether it is set or not
virtual void GetFontToUse(wxFont& font) const;
virtual void GetColourToUse(wxODStatus stat, wxColour& colText, wxColour& colBack) const;
private:
bool m_ownerDrawn; // true if something is non standard
wxFont m_font; // font to use for drawing
wxColour m_colText, // color ----"---"---"----
m_colBack; // background color
int m_margin; // space occupied by bitmap to the left of the item
static int ms_defaultMargin;
};
// ----------------------------------------------------------------------------
// include the platform-specific class declaration
// ----------------------------------------------------------------------------
#if defined(__WXMSW__)
#include "wx/msw/ownerdrw.h"
#endif
#endif // wxUSE_OWNER_DRAWN
#endif // _WX_OWNERDRW_H_BASE
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/textbuf.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/textbuf.h
// Purpose: class wxTextBuffer to work with text buffers of _small_ size
// (buffer is fully loaded in memory) and which understands CR/LF
// differences between platforms.
// Created: 14.11.01
// Author: Morten Hanssen, Vadim Zeitlin
// Copyright: (c) 1998-2001 Morten Hanssen, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TEXTBUFFER_H
#define _WX_TEXTBUFFER_H
#include "wx/defs.h"
#include "wx/arrstr.h"
#include "wx/convauto.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// the line termination type (kept wxTextFileType name for compatibility)
enum wxTextFileType
{
wxTextFileType_None, // incomplete (the last line of the file only)
wxTextFileType_Unix, // line is terminated with 'LF' = 0xA = 10 = '\n'
wxTextFileType_Dos, // 'CR' 'LF'
wxTextFileType_Mac, // 'CR' = 0xD = 13 = '\r'
wxTextFileType_Os2 // 'CR' 'LF'
};
#include "wx/string.h"
#if wxUSE_TEXTBUFFER
#include "wx/dynarray.h"
// ----------------------------------------------------------------------------
// wxTextBuffer
// ----------------------------------------------------------------------------
WX_DEFINE_USER_EXPORTED_ARRAY_INT(wxTextFileType,
wxArrayLinesType,
class WXDLLIMPEXP_BASE);
#endif // wxUSE_TEXTBUFFER
class WXDLLIMPEXP_BASE wxTextBuffer
{
public:
// constants and static functions
// default type for current platform (determined at compile time)
static const wxTextFileType typeDefault;
// this function returns a string which is identical to "text" passed in
// except that the line terminator characters are changed to correspond the
// given type. Called with the default argument, the function translates
// the string to the native format (Unix for Unix, DOS for Windows, ...).
static wxString Translate(const wxString& text,
wxTextFileType type = typeDefault);
// get the buffer termination string
static const wxChar *GetEOL(wxTextFileType type = typeDefault);
// the static methods of this class are compiled in even when
// !wxUSE_TEXTBUFFER because they are used by the library itself, but the
// rest can be left out
#if wxUSE_TEXTBUFFER
// buffer operations
// -----------------
// buffer exists?
bool Exists() const;
// create the buffer if it doesn't already exist
bool Create();
// same as Create() but with (another) buffer name
bool Create(const wxString& strBufferName);
// Open() also loads buffer in memory on success
bool Open(const wxMBConv& conv = wxConvAuto());
// same as Open() but with (another) buffer name
bool Open(const wxString& strBufferName, const wxMBConv& conv = wxConvAuto());
// closes the buffer and frees memory, losing all changes
bool Close();
// is buffer currently opened?
bool IsOpened() const { return m_isOpened; }
// accessors
// ---------
// get the number of lines in the buffer
size_t GetLineCount() const { return m_aLines.size(); }
// the returned line may be modified (but don't add CR/LF at the end!)
wxString& GetLine(size_t n) { return m_aLines[n]; }
const wxString& GetLine(size_t n) const { return m_aLines[n]; }
wxString& operator[](size_t n) { return m_aLines[n]; }
const wxString& operator[](size_t n) const { return m_aLines[n]; }
// the current line has meaning only when you're using
// GetFirstLine()/GetNextLine() functions, it doesn't get updated when
// you're using "direct access" i.e. GetLine()
size_t GetCurrentLine() const { return m_nCurLine; }
void GoToLine(size_t n) { m_nCurLine = n; }
bool Eof() const { return m_nCurLine == m_aLines.size(); }
// these methods allow more "iterator-like" traversal of the list of
// lines, i.e. you may write something like:
// for ( str = GetFirstLine(); !Eof(); str = GetNextLine() ) { ... }
// NB: const is commented out because not all compilers understand
// 'mutable' keyword yet (m_nCurLine should be mutable)
wxString& GetFirstLine() /* const */
{ return m_aLines.empty() ? ms_eof : m_aLines[m_nCurLine = 0]; }
wxString& GetNextLine() /* const */
{ return ++m_nCurLine == m_aLines.size() ? ms_eof
: m_aLines[m_nCurLine]; }
wxString& GetPrevLine() /* const */
{ wxASSERT(m_nCurLine > 0); return m_aLines[--m_nCurLine]; }
wxString& GetLastLine() /* const */
{ return m_aLines.empty() ? ms_eof : m_aLines[m_nCurLine = m_aLines.size() - 1]; }
// get the type of the line (see also GetEOL)
wxTextFileType GetLineType(size_t n) const { return m_aTypes[n]; }
// guess the type of buffer
wxTextFileType GuessType() const;
// get the name of the buffer
const wxString& GetName() const { return m_strBufferName; }
// add/remove lines
// ----------------
// add a line to the end
void AddLine(const wxString& str, wxTextFileType type = typeDefault)
{ m_aLines.push_back(str); m_aTypes.push_back(type); }
// insert a line before the line number n
void InsertLine(const wxString& str,
size_t n,
wxTextFileType type = typeDefault)
{
m_aLines.insert(m_aLines.begin() + n, str);
m_aTypes.insert(m_aTypes.begin()+n, type);
}
// delete one line
void RemoveLine(size_t n)
{
m_aLines.erase(m_aLines.begin() + n);
m_aTypes.erase(m_aTypes.begin() + n);
}
// remove all lines
void Clear() { m_aLines.clear(); m_aTypes.clear(); m_nCurLine = 0; }
// change the buffer (default argument means "don't change type")
// possibly in another format
bool Write(wxTextFileType typeNew = wxTextFileType_None,
const wxMBConv& conv = wxConvAuto());
// dtor
virtual ~wxTextBuffer();
protected:
// ctors
// -----
// default ctor, use Open(string)
wxTextBuffer() { m_nCurLine = 0; m_isOpened = false; }
// ctor from filename
wxTextBuffer(const wxString& strBufferName);
enum wxTextBufferOpenMode { ReadAccess, WriteAccess };
// Must implement these in derived classes.
virtual bool OnExists() const = 0;
virtual bool OnOpen(const wxString &strBufferName,
wxTextBufferOpenMode openmode) = 0;
virtual bool OnClose() = 0;
virtual bool OnRead(const wxMBConv& conv) = 0;
virtual bool OnWrite(wxTextFileType typeNew, const wxMBConv& conv) = 0;
static wxString ms_eof; // dummy string returned at EOF
wxString m_strBufferName; // name of the buffer
private:
wxArrayLinesType m_aTypes; // type of each line
wxArrayString m_aLines; // lines of file
size_t m_nCurLine; // number of current line in the buffer
bool m_isOpened; // was the buffer successfully opened the last time?
#endif // wxUSE_TEXTBUFFER
// copy ctor/assignment operator not implemented
wxTextBuffer(const wxTextBuffer&);
wxTextBuffer& operator=(const wxTextBuffer&);
};
#endif // _WX_TEXTBUFFER_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/fontenum.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/fontenum.h
// Purpose: wxFontEnumerator class for getting available fonts
// Author: Julian Smart, Vadim Zeitlin
// Modified by: extended to enumerate more than just font facenames and works
// not only on Windows now (VZ)
// Created: 04/01/98
// Copyright: (c) Julian Smart, Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONTENUM_H_
#define _WX_FONTENUM_H_
#include "wx/defs.h"
#if wxUSE_FONTENUM
#include "wx/fontenc.h"
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// wxFontEnumerator enumerates all available fonts on the system or only the
// fonts with given attributes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFontEnumerator
{
public:
wxFontEnumerator() {}
// virtual dtor for the base class
virtual ~wxFontEnumerator() {}
// start enumerating font facenames (either all of them or those which
// support the given encoding) - will result in OnFacename() being
// called for each available facename (until they are exhausted or
// OnFacename returns false)
virtual bool EnumerateFacenames
(
wxFontEncoding encoding = wxFONTENCODING_SYSTEM, // all
bool fixedWidthOnly = false
);
// enumerate the different encodings either for given font facename or for
// all facenames - will result in OnFontEncoding() being called for each
// available (facename, encoding) couple
virtual bool EnumerateEncodings(const wxString& facename = wxEmptyString);
// callbacks which are called after one of EnumerateXXX() functions from
// above is invoked - all of them may return false to stop enumeration or
// true to continue with it
// called by EnumerateFacenames
virtual bool OnFacename(const wxString& WXUNUSED(facename))
{ return true; }
// called by EnumerateEncodings
virtual bool OnFontEncoding(const wxString& WXUNUSED(facename),
const wxString& WXUNUSED(encoding))
{ return true; }
// convenience function that returns array of facenames.
static wxArrayString
GetFacenames(wxFontEncoding encoding = wxFONTENCODING_SYSTEM, // all
bool fixedWidthOnly = false);
// convenience function that returns array of all available encodings.
static wxArrayString GetEncodings(const wxString& facename = wxEmptyString);
// convenience function that returns true if the given face name exist
// in the user's system
static bool IsValidFacename(const wxString &str);
// Invalidate cache used by some of the methods of this class internally.
// This should be called if the list of the fonts available on the system
// changes, for whatever reason.
static void InvalidateCache();
private:
#ifdef wxHAS_UTF8_FONTS
// helper for ports that only use UTF-8 encoding natively
bool EnumerateEncodingsUTF8(const wxString& facename);
#endif
wxDECLARE_NO_COPY_CLASS(wxFontEnumerator);
};
#endif // wxUSE_FONTENUM
#endif // _WX_FONTENUM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/textwrapper.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/textwrapper.h
// Purpose: declaration of wxTextWrapper class
// Author: Vadim Zeitlin
// Created: 2009-05-31 (extracted from dlgcmn.cpp via wx/private/stattext.h)
// Copyright: (c) 1999, 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TEXTWRAPPER_H_
#define _WX_TEXTWRAPPER_H_
#include "wx/window.h"
// ----------------------------------------------------------------------------
// wxTextWrapper
// ----------------------------------------------------------------------------
// this class is used to wrap the text on word boundary: wrapping is done by
// calling OnStartLine() and OnOutputLine() functions
class WXDLLIMPEXP_CORE wxTextWrapper
{
public:
wxTextWrapper() { m_eol = false; }
// win is used for getting the font, text is the text to wrap, width is the
// max line width or -1 to disable wrapping
void Wrap(wxWindow *win, const wxString& text, int widthMax);
// we don't need it, but just to avoid compiler warnings
virtual ~wxTextWrapper() { }
protected:
// line may be empty
virtual void OnOutputLine(const wxString& line) = 0;
// called at the start of every new line (except the very first one)
virtual void OnNewLine() { }
private:
// call OnOutputLine() and set m_eol to true
void DoOutputLine(const wxString& line)
{
OnOutputLine(line);
m_eol = true;
}
// this function is a destructive inspector: when it returns true it also
// resets the flag to false so calling it again wouldn't return true any
// more
bool IsStartOfNewLine()
{
if ( !m_eol )
return false;
m_eol = false;
return true;
}
bool m_eol;
wxDECLARE_NO_COPY_CLASS(wxTextWrapper);
};
#if wxUSE_STATTEXT
#include "wx/sizer.h"
#include "wx/stattext.h"
// A class creating a sizer with one static text per line of text. Creation of
// the controls used for each line can be customized by overriding
// OnCreateLine() function.
//
// This class is currently private to wxWidgets and used only by wxDialog
// itself. We may make it public later if there is sufficient interest.
class wxTextSizerWrapper : public wxTextWrapper
{
public:
wxTextSizerWrapper(wxWindow *win)
{
m_win = win;
m_hLine = 0;
}
wxSizer *CreateSizer(const wxString& text, int widthMax)
{
m_sizer = new wxBoxSizer(wxVERTICAL);
Wrap(m_win, text, widthMax);
return m_sizer;
}
wxWindow *GetParent() const { return m_win; }
protected:
virtual wxWindow *OnCreateLine(const wxString& line)
{
return new wxStaticText(m_win, wxID_ANY,
wxControl::EscapeMnemonics(line));
}
virtual void OnOutputLine(const wxString& line) wxOVERRIDE
{
if ( !line.empty() )
{
m_sizer->Add(OnCreateLine(line));
}
else // empty line, no need to create a control for it
{
if ( !m_hLine )
m_hLine = m_win->GetCharHeight();
m_sizer->Add(5, m_hLine);
}
}
private:
wxWindow *m_win;
wxSizer *m_sizer;
int m_hLine;
};
#endif // wxUSE_STATTEXT
#endif // _WX_TEXTWRAPPER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/headercol.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/headercol.h
// Purpose: declaration of wxHeaderColumn class
// Author: Vadim Zeitlin
// Created: 2008-12-02
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HEADERCOL_H_
#define _WX_HEADERCOL_H_
#include "wx/bitmap.h"
#if wxUSE_HEADERCTRL
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
enum
{
// special value for column width meaning unspecified/default
wxCOL_WIDTH_DEFAULT = -1,
// size the column automatically to fit all values
wxCOL_WIDTH_AUTOSIZE = -2
};
// bit masks for the various column attributes
enum
{
// column can be resized (included in default flags)
wxCOL_RESIZABLE = 1,
// column can be clicked to toggle the sort order by its contents
wxCOL_SORTABLE = 2,
// column can be dragged to change its order (included in default)
wxCOL_REORDERABLE = 4,
// column is not shown at all
wxCOL_HIDDEN = 8,
// default flags for wxHeaderColumn ctor
wxCOL_DEFAULT_FLAGS = wxCOL_RESIZABLE | wxCOL_REORDERABLE
};
// ----------------------------------------------------------------------------
// wxHeaderColumn: interface for a column in a header of controls such as
// wxListCtrl, wxDataViewCtrl or wxGrid
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxHeaderColumn
{
public:
// ctors and dtor
// --------------
/*
Derived classes must provide ctors with the following signatures
(notice that they shouldn't be explicit to allow passing strings/bitmaps
directly to methods such wxHeaderCtrl::AppendColumn()):
wxHeaderColumn(const wxString& title,
int width = wxCOL_WIDTH_DEFAULT,
wxAlignment align = wxALIGN_NOT,
int flags = wxCOL_DEFAULT_FLAGS);
wxHeaderColumn(const wxBitmap &bitmap,
int width = wxDVC_DEFAULT_WIDTH,
wxAlignment align = wxALIGN_CENTER,
int flags = wxCOL_DEFAULT_FLAGS);
*/
// virtual dtor for the base class to avoid gcc warnings even though we
// don't normally delete the objects of this class via a pointer to
// wxHeaderColumn so it's not necessary, strictly speaking
virtual ~wxHeaderColumn() { }
// getters for various attributes
// ------------------------------
// notice that wxHeaderColumn only provides getters as this is all the
// wxHeaderCtrl needs, various derived class must also provide some way to
// change these attributes but this can be done either at the column level
// (in which case they should inherit from wxSettableHeaderColumn) or via
// the methods of the main control in which case you don't need setters in
// the column class at all
// title is the string shown for this column
virtual wxString GetTitle() const = 0;
// bitmap shown (instead of text) in the column header
virtual wxBitmap GetBitmap() const = 0; \
// width of the column in pixels, can be set to wxCOL_WIDTH_DEFAULT meaning
// unspecified/default
virtual int GetWidth() const = 0;
// minimal width can be set for resizable columns to forbid resizing them
// below the specified size (set to 0 to remove)
virtual int GetMinWidth() const = 0;
// alignment of the text: wxALIGN_CENTRE, wxALIGN_LEFT or wxALIGN_RIGHT
virtual wxAlignment GetAlignment() const = 0;
// flags manipulations:
// --------------------
// notice that while we make GetFlags() pure virtual here and implement the
// individual flags access in terms of it, for some derived classes it is
// more natural to implement access to each flag individually, in which
// case they can use our GetFromIndividualFlags() helper below to implement
// GetFlags()
// retrieve all column flags at once: combination of wxCOL_XXX values above
virtual int GetFlags() const = 0;
bool HasFlag(int flag) const { return (GetFlags() & flag) != 0; }
// wxCOL_RESIZABLE
virtual bool IsResizeable() const
{ return HasFlag(wxCOL_RESIZABLE); }
// wxCOL_SORTABLE
virtual bool IsSortable() const
{ return HasFlag(wxCOL_SORTABLE); }
// wxCOL_REORDERABLE
virtual bool IsReorderable() const
{ return HasFlag(wxCOL_REORDERABLE); }
// wxCOL_HIDDEN
virtual bool IsHidden() const
{ return HasFlag(wxCOL_HIDDEN); }
bool IsShown() const
{ return !IsHidden(); }
// sorting
// -------
// return true if the column is the one currently used for sorting
virtual bool IsSortKey() const = 0;
// for sortable columns indicate whether we should sort in ascending or
// descending order (this should only be taken into account if IsSortKey())
virtual bool IsSortOrderAscending() const = 0;
protected:
// helper for the class overriding IsXXX()
int GetFromIndividualFlags() const;
};
// ----------------------------------------------------------------------------
// wxSettableHeaderColumn: column which allows to change its fields too
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSettableHeaderColumn : public wxHeaderColumn
{
public:
virtual void SetTitle(const wxString& title) = 0;
virtual void SetBitmap(const wxBitmap& bitmap) = 0;
virtual void SetWidth(int width) = 0;
virtual void SetMinWidth(int minWidth) = 0;
virtual void SetAlignment(wxAlignment align) = 0;
// see comment for wxHeaderColumn::GetFlags() about the relationship
// between SetFlags() and Set{Sortable,Reorderable,...}
// change, set, clear, toggle or test for any individual flag
virtual void SetFlags(int flags) = 0;
void ChangeFlag(int flag, bool set);
void SetFlag(int flag);
void ClearFlag(int flag);
void ToggleFlag(int flag);
virtual void SetResizeable(bool resizable)
{ ChangeFlag(wxCOL_RESIZABLE, resizable); }
virtual void SetSortable(bool sortable)
{ ChangeFlag(wxCOL_SORTABLE, sortable); }
virtual void SetReorderable(bool reorderable)
{ ChangeFlag(wxCOL_REORDERABLE, reorderable); }
virtual void SetHidden(bool hidden)
{ ChangeFlag(wxCOL_HIDDEN, hidden); }
// This function can be called to indicate that this column is not used for
// sorting any more. Under some platforms it's not necessary to do anything
// in this case as just setting another column as a sort key takes care of
// everything but under MSW we currently need to call this explicitly to
// reset the sort indicator displayed on the column.
virtual void UnsetAsSortKey() { }
virtual void SetSortOrder(bool ascending) = 0;
void ToggleSortOrder() { SetSortOrder(!IsSortOrderAscending()); }
protected:
// helper for the class overriding individual SetXXX() methods instead of
// overriding SetFlags()
void SetIndividualFlags(int flags);
};
// ----------------------------------------------------------------------------
// wxHeaderColumnSimple: trivial generic implementation of wxHeaderColumn
// ----------------------------------------------------------------------------
class wxHeaderColumnSimple : public wxSettableHeaderColumn
{
public:
// ctors and dtor
wxHeaderColumnSimple(const wxString& title,
int width = wxCOL_WIDTH_DEFAULT,
wxAlignment align = wxALIGN_NOT,
int flags = wxCOL_DEFAULT_FLAGS)
: m_title(title),
m_width(width),
m_align(align),
m_flags(flags)
{
Init();
}
wxHeaderColumnSimple(const wxBitmap& bitmap,
int width = wxCOL_WIDTH_DEFAULT,
wxAlignment align = wxALIGN_CENTER,
int flags = wxCOL_DEFAULT_FLAGS)
: m_bitmap(bitmap),
m_width(width),
m_align(align),
m_flags(flags)
{
Init();
}
// implement base class pure virtuals
virtual void SetTitle(const wxString& title) wxOVERRIDE { m_title = title; }
virtual wxString GetTitle() const wxOVERRIDE { return m_title; }
virtual void SetBitmap(const wxBitmap& bitmap) wxOVERRIDE { m_bitmap = bitmap; }
wxBitmap GetBitmap() const wxOVERRIDE { return m_bitmap; }
virtual void SetWidth(int width) wxOVERRIDE { m_width = width; }
virtual int GetWidth() const wxOVERRIDE { return m_width; }
virtual void SetMinWidth(int minWidth) wxOVERRIDE { m_minWidth = minWidth; }
virtual int GetMinWidth() const wxOVERRIDE { return m_minWidth; }
virtual void SetAlignment(wxAlignment align) wxOVERRIDE { m_align = align; }
virtual wxAlignment GetAlignment() const wxOVERRIDE { return m_align; }
virtual void SetFlags(int flags) wxOVERRIDE { m_flags = flags; }
virtual int GetFlags() const wxOVERRIDE { return m_flags; }
virtual bool IsSortKey() const wxOVERRIDE { return m_sort; }
virtual void UnsetAsSortKey() wxOVERRIDE { m_sort = false; }
virtual void SetSortOrder(bool ascending) wxOVERRIDE
{
m_sort = true;
m_sortAscending = ascending;
}
virtual bool IsSortOrderAscending() const wxOVERRIDE { return m_sortAscending; }
private:
// common part of all ctors
void Init()
{
m_minWidth = 0;
m_sort = false;
m_sortAscending = true;
}
wxString m_title;
wxBitmap m_bitmap;
int m_width,
m_minWidth;
wxAlignment m_align;
int m_flags;
bool m_sort,
m_sortAscending;
};
#endif // wxUSE_HEADERCTRL
#endif // _WX_HEADERCOL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/prntbase.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/prntbase.h
// Purpose: Base classes for printing framework
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRNTBASEH__
#define _WX_PRNTBASEH__
#include "wx/defs.h"
#if wxUSE_PRINTING_ARCHITECTURE
#include "wx/event.h"
#include "wx/cmndata.h"
#include "wx/panel.h"
#include "wx/scrolwin.h"
#include "wx/dialog.h"
#include "wx/frame.h"
#include "wx/dc.h"
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxButton;
class WXDLLIMPEXP_FWD_CORE wxChoice;
class WXDLLIMPEXP_FWD_CORE wxPrintout;
class WXDLLIMPEXP_FWD_CORE wxPrinterBase;
class WXDLLIMPEXP_FWD_CORE wxPrintDialogBase;
class WXDLLIMPEXP_FWD_CORE wxPrintDialog;
class WXDLLIMPEXP_FWD_CORE wxPageSetupDialogBase;
class WXDLLIMPEXP_FWD_CORE wxPageSetupDialog;
class WXDLLIMPEXP_FWD_CORE wxPrintPreviewBase;
class WXDLLIMPEXP_FWD_CORE wxPreviewCanvas;
class WXDLLIMPEXP_FWD_CORE wxPreviewControlBar;
class WXDLLIMPEXP_FWD_CORE wxPreviewFrame;
class WXDLLIMPEXP_FWD_CORE wxPrintFactory;
class WXDLLIMPEXP_FWD_CORE wxPrintNativeDataBase;
class WXDLLIMPEXP_FWD_CORE wxPrintPreview;
class WXDLLIMPEXP_FWD_CORE wxPrintAbortDialog;
class WXDLLIMPEXP_FWD_CORE wxStaticText;
class wxPrintPageMaxCtrl;
class wxPrintPageTextCtrl;
//----------------------------------------------------------------------------
// error consts
//----------------------------------------------------------------------------
enum wxPrinterError
{
wxPRINTER_NO_ERROR = 0,
wxPRINTER_CANCELLED,
wxPRINTER_ERROR
};
// Preview frame modality kind used with wxPreviewFrame::Initialize()
enum wxPreviewFrameModalityKind
{
// Disable all the other top level windows while the preview is shown.
wxPreviewFrame_AppModal,
// Disable only the parent window while the preview is shown.
wxPreviewFrame_WindowModal,
// Don't disable any windows.
wxPreviewFrame_NonModal
};
//----------------------------------------------------------------------------
// wxPrintFactory
//----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPrintFactory
{
public:
wxPrintFactory() {}
virtual ~wxPrintFactory() {}
virtual wxPrinterBase *CreatePrinter( wxPrintDialogData* data ) = 0;
virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
wxPrintout *printout = NULL,
wxPrintDialogData *data = NULL ) = 0;
virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
wxPrintout *printout,
wxPrintData *data ) = 0;
virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
wxPrintDialogData *data = NULL ) = 0;
virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
wxPrintData *data ) = 0;
virtual wxPageSetupDialogBase *CreatePageSetupDialog( wxWindow *parent,
wxPageSetupDialogData * data = NULL ) = 0;
virtual wxDCImpl* CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data ) = 0;
// What to do and what to show in the wxPrintDialog
// a) Use the generic print setup dialog or a native one?
virtual bool HasPrintSetupDialog() = 0;
virtual wxDialog *CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data ) = 0;
// b) Provide the "print to file" option ourselves or via print setup?
virtual bool HasOwnPrintToFile() = 0;
// c) Show current printer
virtual bool HasPrinterLine() = 0;
virtual wxString CreatePrinterLine() = 0;
// d) Show Status line for current printer?
virtual bool HasStatusLine() = 0;
virtual wxString CreateStatusLine() = 0;
virtual wxPrintNativeDataBase *CreatePrintNativeData() = 0;
static void SetPrintFactory( wxPrintFactory *factory );
static wxPrintFactory *GetFactory();
private:
static wxPrintFactory *m_factory;
};
class WXDLLIMPEXP_CORE wxNativePrintFactory: public wxPrintFactory
{
public:
virtual wxPrinterBase *CreatePrinter( wxPrintDialogData *data ) wxOVERRIDE;
virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
wxPrintout *printout = NULL,
wxPrintDialogData *data = NULL ) wxOVERRIDE;
virtual wxPrintPreviewBase *CreatePrintPreview( wxPrintout *preview,
wxPrintout *printout,
wxPrintData *data ) wxOVERRIDE;
virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
wxPrintDialogData *data = NULL ) wxOVERRIDE;
virtual wxPrintDialogBase *CreatePrintDialog( wxWindow *parent,
wxPrintData *data ) wxOVERRIDE;
virtual wxPageSetupDialogBase *CreatePageSetupDialog( wxWindow *parent,
wxPageSetupDialogData * data = NULL ) wxOVERRIDE;
virtual wxDCImpl* CreatePrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data ) wxOVERRIDE;
virtual bool HasPrintSetupDialog() wxOVERRIDE;
virtual wxDialog *CreatePrintSetupDialog( wxWindow *parent, wxPrintData *data ) wxOVERRIDE;
virtual bool HasOwnPrintToFile() wxOVERRIDE;
virtual bool HasPrinterLine() wxOVERRIDE;
virtual wxString CreatePrinterLine() wxOVERRIDE;
virtual bool HasStatusLine() wxOVERRIDE;
virtual wxString CreateStatusLine() wxOVERRIDE;
virtual wxPrintNativeDataBase *CreatePrintNativeData() wxOVERRIDE;
};
//----------------------------------------------------------------------------
// wxPrintNativeDataBase
//----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPrintNativeDataBase: public wxObject
{
public:
wxPrintNativeDataBase();
virtual ~wxPrintNativeDataBase() {}
virtual bool TransferTo( wxPrintData &data ) = 0;
virtual bool TransferFrom( const wxPrintData &data ) = 0;
#ifdef __WXOSX__
// in order to expose functionality already to the result type of the ..PrintData->GetNativeData()
virtual void TransferFrom( const wxPageSetupDialogData * ) = 0;
virtual void TransferTo( wxPageSetupDialogData * ) = 0;
#endif
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const = 0;
int m_ref;
private:
wxDECLARE_CLASS(wxPrintNativeDataBase);
wxDECLARE_NO_COPY_CLASS(wxPrintNativeDataBase);
};
//----------------------------------------------------------------------------
// wxPrinterBase
//----------------------------------------------------------------------------
/*
* Represents the printer: manages printing a wxPrintout object
*/
class WXDLLIMPEXP_CORE wxPrinterBase: public wxObject
{
public:
wxPrinterBase(wxPrintDialogData *data = NULL);
virtual ~wxPrinterBase();
virtual wxPrintAbortDialog *CreateAbortWindow(wxWindow *parent, wxPrintout *printout);
virtual void ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message);
virtual wxPrintDialogData& GetPrintDialogData() const;
bool GetAbort() const { return sm_abortIt; }
static wxPrinterError GetLastError() { return sm_lastError; }
///////////////////////////////////////////////////////////////////////////
// OVERRIDES
virtual bool Setup(wxWindow *parent) = 0;
virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true) = 0;
virtual wxDC* PrintDialog(wxWindow *parent) = 0;
protected:
wxPrintDialogData m_printDialogData;
wxPrintout* m_currentPrintout;
static wxPrinterError sm_lastError;
public:
static wxWindow* sm_abortWindow;
static bool sm_abortIt;
private:
wxDECLARE_CLASS(wxPrinterBase);
wxDECLARE_NO_COPY_CLASS(wxPrinterBase);
};
//----------------------------------------------------------------------------
// wxPrinter
//----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPrinter: public wxPrinterBase
{
public:
wxPrinter(wxPrintDialogData *data = NULL);
virtual ~wxPrinter();
virtual wxPrintAbortDialog *CreateAbortWindow(wxWindow *parent, wxPrintout *printout) wxOVERRIDE;
virtual void ReportError(wxWindow *parent, wxPrintout *printout, const wxString& message) wxOVERRIDE;
virtual bool Setup(wxWindow *parent) wxOVERRIDE;
virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true) wxOVERRIDE;
virtual wxDC* PrintDialog(wxWindow *parent) wxOVERRIDE;
virtual wxPrintDialogData& GetPrintDialogData() const wxOVERRIDE;
protected:
wxPrinterBase *m_pimpl;
private:
wxDECLARE_CLASS(wxPrinter);
wxDECLARE_NO_COPY_CLASS(wxPrinter);
};
//----------------------------------------------------------------------------
// wxPrintout
//----------------------------------------------------------------------------
/*
* Represents an object via which a document may be printed.
* The programmer derives from this, overrides (at least) OnPrintPage,
* and passes it to a wxPrinter object for printing, or a wxPrintPreview
* object for previewing.
*/
class WXDLLIMPEXP_CORE wxPrintout: public wxObject
{
public:
wxPrintout(const wxString& title = wxGetTranslation("Printout"));
virtual ~wxPrintout();
virtual bool OnBeginDocument(int startPage, int endPage);
virtual void OnEndDocument();
virtual void OnBeginPrinting();
virtual void OnEndPrinting();
// Guaranteed to be before any other functions are called
virtual void OnPreparePrinting() { }
virtual bool HasPage(int page);
virtual bool OnPrintPage(int page) = 0;
virtual void GetPageInfo(int *minPage, int *maxPage, int *pageFrom, int *pageTo);
virtual wxString GetTitle() const { return m_printoutTitle; }
// Port-specific code should call this function to initialize this object
// with everything it needs, instead of using individual accessors below.
bool SetUp(wxDC& dc);
wxDC *GetDC() const { return m_printoutDC; }
void SetDC(wxDC *dc) { m_printoutDC = dc; }
void FitThisSizeToPaper(const wxSize& imageSize);
void FitThisSizeToPage(const wxSize& imageSize);
void FitThisSizeToPageMargins(const wxSize& imageSize, const wxPageSetupDialogData& pageSetupData);
void MapScreenSizeToPaper();
void MapScreenSizeToPage();
void MapScreenSizeToPageMargins(const wxPageSetupDialogData& pageSetupData);
void MapScreenSizeToDevice();
wxRect GetLogicalPaperRect() const;
wxRect GetLogicalPageRect() const;
wxRect GetLogicalPageMarginsRect(const wxPageSetupDialogData& pageSetupData) const;
void SetLogicalOrigin(wxCoord x, wxCoord y);
void OffsetLogicalOrigin(wxCoord xoff, wxCoord yoff);
void SetPageSizePixels(int w, int h) { m_pageWidthPixels = w; m_pageHeightPixels = h; }
void GetPageSizePixels(int *w, int *h) const { *w = m_pageWidthPixels; *h = m_pageHeightPixels; }
void SetPageSizeMM(int w, int h) { m_pageWidthMM = w; m_pageHeightMM = h; }
void GetPageSizeMM(int *w, int *h) const { *w = m_pageWidthMM; *h = m_pageHeightMM; }
void SetPPIScreen(int x, int y) { m_PPIScreenX = x; m_PPIScreenY = y; }
void SetPPIScreen(const wxSize& ppi) { SetPPIScreen(ppi.x, ppi.y); }
void GetPPIScreen(int *x, int *y) const { *x = m_PPIScreenX; *y = m_PPIScreenY; }
void SetPPIPrinter(int x, int y) { m_PPIPrinterX = x; m_PPIPrinterY = y; }
void SetPPIPrinter(const wxSize& ppi) { SetPPIPrinter(ppi.x, ppi.y); }
void GetPPIPrinter(int *x, int *y) const { *x = m_PPIPrinterX; *y = m_PPIPrinterY; }
void SetPaperRectPixels(const wxRect& paperRectPixels) { m_paperRectPixels = paperRectPixels; }
wxRect GetPaperRectPixels() const { return m_paperRectPixels; }
// This must be called by wxPrintPreview to associate itself with the
// printout it uses.
virtual void SetPreview(wxPrintPreview *preview) { m_preview = preview; }
wxPrintPreview *GetPreview() const { return m_preview; }
virtual bool IsPreview() const { return GetPreview() != NULL; }
private:
wxString m_printoutTitle;
wxDC* m_printoutDC;
wxPrintPreview *m_preview;
int m_pageWidthPixels;
int m_pageHeightPixels;
int m_pageWidthMM;
int m_pageHeightMM;
int m_PPIScreenX;
int m_PPIScreenY;
int m_PPIPrinterX;
int m_PPIPrinterY;
wxRect m_paperRectPixels;
private:
wxDECLARE_ABSTRACT_CLASS(wxPrintout);
wxDECLARE_NO_COPY_CLASS(wxPrintout);
};
//----------------------------------------------------------------------------
// wxPreviewCanvas
//----------------------------------------------------------------------------
/*
* Canvas upon which a preview is drawn.
*/
class WXDLLIMPEXP_CORE wxPreviewCanvas: public wxScrolledWindow
{
public:
wxPreviewCanvas(wxPrintPreviewBase *preview,
wxWindow *parent,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxT("canvas"));
virtual ~wxPreviewCanvas();
void SetPreview(wxPrintPreviewBase *preview) { m_printPreview = preview; }
void OnPaint(wxPaintEvent& event);
void OnChar(wxKeyEvent &event);
// Responds to colour changes
void OnSysColourChanged(wxSysColourChangedEvent& event);
private:
#if wxUSE_MOUSEWHEEL
void OnMouseWheel(wxMouseEvent& event);
#endif // wxUSE_MOUSEWHEEL
void OnIdle(wxIdleEvent& event);
wxPrintPreviewBase* m_printPreview;
wxDECLARE_CLASS(wxPreviewCanvas);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxPreviewCanvas);
};
//----------------------------------------------------------------------------
// wxPreviewFrame
//----------------------------------------------------------------------------
/*
* Default frame for showing preview.
*/
class WXDLLIMPEXP_CORE wxPreviewFrame: public wxFrame
{
public:
wxPreviewFrame(wxPrintPreviewBase *preview,
wxWindow *parent,
const wxString& title = wxGetTranslation("Print Preview"),
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxFRAME_FLOAT_ON_PARENT,
const wxString& name = wxFrameNameStr);
virtual ~wxPreviewFrame();
// Either Initialize() or InitializeWithModality() must be called before
// showing the preview frame, the former being just a particular case of
// the latter initializing the frame for being showing app-modally.
// Notice that we must keep Initialize() with its existing signature to
// avoid breaking the old code that overrides it and we can't reuse the
// same name for the other functions to avoid virtual function hiding
// problem and the associated warnings given by some compilers (e.g. from
// g++ with -Woverloaded-virtual).
virtual void Initialize()
{
InitializeWithModality(wxPreviewFrame_AppModal);
}
// Also note that this method is not virtual as it doesn't need to be
// overridden: it's never called by wxWidgets (of course, the same is true
// for Initialize() but, again, it must remain virtual for compatibility).
void InitializeWithModality(wxPreviewFrameModalityKind kind);
void OnCloseWindow(wxCloseEvent& event);
virtual void CreateCanvas();
virtual void CreateControlBar();
inline wxPreviewControlBar* GetControlBar() const { return m_controlBar; }
protected:
wxPreviewCanvas* m_previewCanvas;
wxPreviewControlBar* m_controlBar;
wxPrintPreviewBase* m_printPreview;
wxWindowDisabler* m_windowDisabler;
wxPreviewFrameModalityKind m_modalityKind;
private:
void OnChar(wxKeyEvent& event);
wxDECLARE_EVENT_TABLE();
wxDECLARE_CLASS(wxPreviewFrame);
wxDECLARE_NO_COPY_CLASS(wxPreviewFrame);
};
//----------------------------------------------------------------------------
// wxPreviewControlBar
//----------------------------------------------------------------------------
/*
* A panel with buttons for controlling a print preview.
* The programmer may wish to use other means for controlling
* the print preview.
*/
#define wxPREVIEW_PRINT 1
#define wxPREVIEW_PREVIOUS 2
#define wxPREVIEW_NEXT 4
#define wxPREVIEW_ZOOM 8
#define wxPREVIEW_FIRST 16
#define wxPREVIEW_LAST 32
#define wxPREVIEW_GOTO 64
#define wxPREVIEW_DEFAULT (wxPREVIEW_PREVIOUS|wxPREVIEW_NEXT|wxPREVIEW_ZOOM\
|wxPREVIEW_FIRST|wxPREVIEW_GOTO|wxPREVIEW_LAST)
// Ids for controls
#define wxID_PREVIEW_CLOSE 1
#define wxID_PREVIEW_NEXT 2
#define wxID_PREVIEW_PREVIOUS 3
#define wxID_PREVIEW_PRINT 4
#define wxID_PREVIEW_ZOOM 5
#define wxID_PREVIEW_FIRST 6
#define wxID_PREVIEW_LAST 7
#define wxID_PREVIEW_GOTO 8
#define wxID_PREVIEW_ZOOM_IN 9
#define wxID_PREVIEW_ZOOM_OUT 10
class WXDLLIMPEXP_CORE wxPreviewControlBar: public wxPanel
{
wxDECLARE_CLASS(wxPreviewControlBar);
public:
wxPreviewControlBar(wxPrintPreviewBase *preview,
long buttons,
wxWindow *parent,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL,
const wxString& name = wxT("panel"));
virtual ~wxPreviewControlBar();
virtual void CreateButtons();
virtual void SetPageInfo(int minPage, int maxPage);
virtual void SetZoomControl(int zoom);
virtual int GetZoomControl();
virtual wxPrintPreviewBase *GetPrintPreview() const
{ return m_printPreview; }
// Implementation only from now on.
void OnWindowClose(wxCommandEvent& event);
void OnNext();
void OnPrevious();
void OnFirst();
void OnLast();
void OnGotoPage();
void OnPrint();
void OnPrintButton(wxCommandEvent& WXUNUSED(event)) { OnPrint(); }
void OnNextButton(wxCommandEvent & WXUNUSED(event)) { OnNext(); }
void OnPreviousButton(wxCommandEvent & WXUNUSED(event)) { OnPrevious(); }
void OnFirstButton(wxCommandEvent & WXUNUSED(event)) { OnFirst(); }
void OnLastButton(wxCommandEvent & WXUNUSED(event)) { OnLast(); }
void OnPaint(wxPaintEvent& event);
void OnUpdateNextButton(wxUpdateUIEvent& event)
{ event.Enable(IsNextEnabled()); }
void OnUpdatePreviousButton(wxUpdateUIEvent& event)
{ event.Enable(IsPreviousEnabled()); }
void OnUpdateFirstButton(wxUpdateUIEvent& event)
{ event.Enable(IsFirstEnabled()); }
void OnUpdateLastButton(wxUpdateUIEvent& event)
{ event.Enable(IsLastEnabled()); }
void OnUpdateZoomInButton(wxUpdateUIEvent& event)
{ event.Enable(IsZoomInEnabled()); }
void OnUpdateZoomOutButton(wxUpdateUIEvent& event)
{ event.Enable(IsZoomOutEnabled()); }
// These methods are not private because they are called by wxPreviewCanvas.
void DoZoomIn();
void DoZoomOut();
protected:
wxPrintPreviewBase* m_printPreview;
wxButton* m_closeButton;
wxChoice* m_zoomControl;
wxPrintPageTextCtrl* m_currentPageText;
wxPrintPageMaxCtrl* m_maxPageText;
long m_buttonFlags;
private:
void DoGotoPage(int page);
void DoZoom();
bool IsNextEnabled() const;
bool IsPreviousEnabled() const;
bool IsFirstEnabled() const;
bool IsLastEnabled() const;
bool IsZoomInEnabled() const;
bool IsZoomOutEnabled() const;
void OnZoomInButton(wxCommandEvent & WXUNUSED(event)) { DoZoomIn(); }
void OnZoomOutButton(wxCommandEvent & WXUNUSED(event)) { DoZoomOut(); }
void OnZoomChoice(wxCommandEvent& WXUNUSED(event)) { DoZoom(); }
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxPreviewControlBar);
};
//----------------------------------------------------------------------------
// wxPrintPreviewBase
//----------------------------------------------------------------------------
/*
* Programmer creates an object of this class to preview a wxPrintout.
*/
class WXDLLIMPEXP_CORE wxPrintPreviewBase: public wxObject
{
public:
wxPrintPreviewBase(wxPrintout *printout,
wxPrintout *printoutForPrinting = NULL,
wxPrintDialogData *data = NULL);
wxPrintPreviewBase(wxPrintout *printout,
wxPrintout *printoutForPrinting,
wxPrintData *data);
virtual ~wxPrintPreviewBase();
virtual bool SetCurrentPage(int pageNum);
virtual int GetCurrentPage() const;
virtual void SetPrintout(wxPrintout *printout);
virtual wxPrintout *GetPrintout() const;
virtual wxPrintout *GetPrintoutForPrinting() const;
virtual void SetFrame(wxFrame *frame);
virtual void SetCanvas(wxPreviewCanvas *canvas);
virtual wxFrame *GetFrame() const;
virtual wxPreviewCanvas *GetCanvas() const;
// This is a helper routine, used by the next 4 routines.
virtual void CalcRects(wxPreviewCanvas *canvas, wxRect& printableAreaRect, wxRect& paperRect);
// The preview canvas should call this from OnPaint
virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc);
// Updates rendered page by calling RenderPage() if needed, returns true
// if there was some change. Preview canvas should call it at idle time
virtual bool UpdatePageRendering();
// This draws a blank page onto the preview canvas
virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc);
// Adjusts the scrollbars for the current scale
virtual void AdjustScrollbars(wxPreviewCanvas *canvas);
// This is called by wxPrintPreview to render a page into a wxMemoryDC.
virtual bool RenderPage(int pageNum);
virtual void SetZoom(int percent);
virtual int GetZoom() const;
virtual wxPrintDialogData& GetPrintDialogData();
virtual int GetMaxPage() const;
virtual int GetMinPage() const;
virtual bool Ok() const { return IsOk(); }
virtual bool IsOk() const;
virtual void SetOk(bool ok);
///////////////////////////////////////////////////////////////////////////
// OVERRIDES
// If we own a wxPrintout that can be used for printing, this
// will invoke the actual printing procedure. Called
// by the wxPreviewControlBar.
virtual bool Print(bool interactive) = 0;
// Calculate scaling that needs to be done to get roughly
// the right scaling for the screen pretending to be
// the currently selected printer.
virtual void DetermineScaling() = 0;
protected:
// helpers for RenderPage():
virtual bool RenderPageIntoDC(wxDC& dc, int pageNum);
// renders preview into m_previewBitmap
virtual bool RenderPageIntoBitmap(wxBitmap& bmp, int pageNum);
void InvalidatePreviewBitmap();
protected:
wxPrintDialogData m_printDialogData;
wxPreviewCanvas* m_previewCanvas;
wxFrame* m_previewFrame;
wxBitmap* m_previewBitmap;
bool m_previewFailed;
wxPrintout* m_previewPrintout;
wxPrintout* m_printPrintout;
int m_currentPage;
int m_currentZoom;
float m_previewScaleX;
float m_previewScaleY;
int m_topMargin;
int m_leftMargin;
int m_pageWidth;
int m_pageHeight;
int m_minPage;
int m_maxPage;
bool m_isOk;
bool m_printingPrepared; // Called OnPreparePrinting?
private:
void Init(wxPrintout *printout, wxPrintout *printoutForPrinting);
wxDECLARE_NO_COPY_CLASS(wxPrintPreviewBase);
wxDECLARE_CLASS(wxPrintPreviewBase);
};
//----------------------------------------------------------------------------
// wxPrintPreview
//----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPrintPreview: public wxPrintPreviewBase
{
public:
wxPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting = NULL,
wxPrintDialogData *data = NULL);
wxPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting,
wxPrintData *data);
virtual ~wxPrintPreview();
virtual bool SetCurrentPage(int pageNum) wxOVERRIDE;
virtual int GetCurrentPage() const wxOVERRIDE;
virtual void SetPrintout(wxPrintout *printout) wxOVERRIDE;
virtual wxPrintout *GetPrintout() const wxOVERRIDE;
virtual wxPrintout *GetPrintoutForPrinting() const wxOVERRIDE;
virtual void SetFrame(wxFrame *frame) wxOVERRIDE;
virtual void SetCanvas(wxPreviewCanvas *canvas) wxOVERRIDE;
virtual wxFrame *GetFrame() const wxOVERRIDE;
virtual wxPreviewCanvas *GetCanvas() const wxOVERRIDE;
virtual bool PaintPage(wxPreviewCanvas *canvas, wxDC& dc) wxOVERRIDE;
virtual bool UpdatePageRendering() wxOVERRIDE;
virtual bool DrawBlankPage(wxPreviewCanvas *canvas, wxDC& dc) wxOVERRIDE;
virtual void AdjustScrollbars(wxPreviewCanvas *canvas) wxOVERRIDE;
virtual bool RenderPage(int pageNum) wxOVERRIDE;
virtual void SetZoom(int percent) wxOVERRIDE;
virtual int GetZoom() const wxOVERRIDE;
virtual bool Print(bool interactive) wxOVERRIDE;
virtual void DetermineScaling() wxOVERRIDE;
virtual wxPrintDialogData& GetPrintDialogData() wxOVERRIDE;
virtual int GetMaxPage() const wxOVERRIDE;
virtual int GetMinPage() const wxOVERRIDE;
virtual bool Ok() const wxOVERRIDE { return IsOk(); }
virtual bool IsOk() const wxOVERRIDE;
virtual void SetOk(bool ok) wxOVERRIDE;
private:
wxPrintPreviewBase *m_pimpl;
private:
wxDECLARE_CLASS(wxPrintPreview);
wxDECLARE_NO_COPY_CLASS(wxPrintPreview);
};
//----------------------------------------------------------------------------
// wxPrintAbortDialog
//----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPrintAbortDialog: public wxDialog
{
public:
wxPrintAbortDialog(wxWindow *parent,
const wxString& documentTitle,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxT("dialog"));
void SetProgress(int currentPage, int totalPages,
int currentCopy, int totalCopies);
void OnCancel(wxCommandEvent& event);
private:
wxStaticText *m_progress;
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxPrintAbortDialog);
};
#endif // wxUSE_PRINTING_ARCHITECTURE
#endif
// _WX_PRNTBASEH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/validate.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/validate.h
// Purpose: wxValidator class
// Author: Julian Smart
// Modified by:
// Created: 29/01/98
// Copyright: (c) 1998 Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_VALIDATE_H_
#define _WX_VALIDATE_H_
#include "wx/defs.h"
#if wxUSE_VALIDATORS
#include "wx/event.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxWindowBase;
/*
A validator has up to three purposes:
1) To validate the data in the window that's associated
with the validator.
2) To transfer data to and from the window.
3) To filter input, using its role as a wxEvtHandler
to intercept e.g. OnChar.
Note that wxValidator and derived classes use reference counting.
*/
class WXDLLIMPEXP_CORE wxValidator : public wxEvtHandler
{
public:
wxValidator();
wxValidator(const wxValidator& other)
: wxEvtHandler()
, m_validatorWindow(other.m_validatorWindow)
{
}
virtual ~wxValidator();
// 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
{ return NULL; }
bool Copy(const wxValidator& val)
{ m_validatorWindow = val.m_validatorWindow; return true; }
// Called when the value in the window must be validated.
// This function can pop up an error message.
virtual bool Validate(wxWindow *WXUNUSED(parent)) { return false; }
// Called to transfer data to the window
virtual bool TransferToWindow() { return false; }
// Called to transfer data from the window
virtual bool TransferFromWindow() { return false; }
// Called when the validator is associated with a window, may be useful to
// override if it needs to somehow initialize the window.
virtual void SetWindow(wxWindow *win) { m_validatorWindow = win; }
// accessors
wxWindow *GetWindow() const { return m_validatorWindow; }
// validators beep by default if invalid key is pressed, this function
// allows to change this
static void SuppressBellOnError(bool suppress = true)
{ ms_isSilent = suppress; }
// test if beep is currently disabled
static bool IsSilent() { return ms_isSilent; }
// this function is deprecated because it handled its parameter
// unnaturally: it disabled the bell when it was true, not false as could
// be expected; use SuppressBellOnError() instead
#if WXWIN_COMPATIBILITY_2_8
static wxDEPRECATED_INLINE(
void SetBellOnError(bool doIt = true),
ms_isSilent = doIt;
)
#endif
protected:
wxWindow *m_validatorWindow;
private:
static bool ms_isSilent;
wxDECLARE_DYNAMIC_CLASS(wxValidator);
wxDECLARE_NO_ASSIGN_CLASS(wxValidator);
};
extern WXDLLIMPEXP_DATA_CORE(const wxValidator) wxDefaultValidator;
#define wxVALIDATOR_PARAM(val) val
#else // !wxUSE_VALIDATORS
// wxWidgets is compiled without support for wxValidator, but we still
// want to be able to pass wxDefaultValidator to the functions which take
// a wxValidator parameter to avoid using "#if wxUSE_VALIDATORS"
// everywhere
class WXDLLIMPEXP_FWD_CORE wxValidator;
static const wxValidator* const wxDefaultValidatorPtr = NULL;
#define wxDefaultValidator (*wxDefaultValidatorPtr)
// this macro allows to avoid warnings about unused parameters when
// wxUSE_VALIDATORS == 0
#define wxVALIDATOR_PARAM(val)
#endif // wxUSE_VALIDATORS/!wxUSE_VALIDATORS
#endif // _WX_VALIDATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/wupdlock.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/wupdlock.h
// Purpose: wxWindowUpdateLocker prevents window redrawing
// Author: Vadim Zeitlin
// Created: 2006-03-06
// Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WUPDLOCK_H_
#define _WX_WUPDLOCK_H_
#include "wx/window.h"
// ----------------------------------------------------------------------------
// wxWindowUpdateLocker prevents updates to the window during its lifetime
// ----------------------------------------------------------------------------
class wxWindowUpdateLocker
{
public:
// create an object preventing updates of the given window (which must have
// a lifetime at least as great as ours)
wxWindowUpdateLocker(wxWindow *win) : m_win(win) { win->Freeze(); }
// dtor thaws the window to permit updates again
~wxWindowUpdateLocker() { m_win->Thaw(); }
private:
wxWindow *m_win;
wxDECLARE_NO_COPY_CLASS(wxWindowUpdateLocker);
};
#endif // _WX_WUPDLOCK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/fswatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/fswatcher.h
// Purpose: wxFileSystemWatcherBase
// Author: Bartosz Bekier
// Created: 2009-05-23
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FSWATCHER_BASE_H_
#define _WX_FSWATCHER_BASE_H_
#include "wx/defs.h"
#if wxUSE_FSWATCHER
#include "wx/log.h"
#include "wx/event.h"
#include "wx/evtloop.h"
#include "wx/filename.h"
#include "wx/dir.h"
#include "wx/hashmap.h"
#define wxTRACE_FSWATCHER "fswatcher"
// ----------------------------------------------------------------------------
// wxFileSystemWatcherEventType & wxFileSystemWatcherEvent
// ----------------------------------------------------------------------------
/**
* Possible types of file system events.
* This is a subset that will work fine an all platforms (actually, we will
* see how it works on Mac).
*
* We got 2 types of error events:
* - warning: these are not fatal and further events can still be generated
* - error: indicates fatal error and causes that no more events will happen
*/
enum
{
wxFSW_EVENT_CREATE = 0x01,
wxFSW_EVENT_DELETE = 0x02,
wxFSW_EVENT_RENAME = 0x04,
wxFSW_EVENT_MODIFY = 0x08,
wxFSW_EVENT_ACCESS = 0x10,
wxFSW_EVENT_ATTRIB = 0x20, // Currently this is wxGTK-only
// error events
wxFSW_EVENT_WARNING = 0x40,
wxFSW_EVENT_ERROR = 0x80,
wxFSW_EVENT_ALL = wxFSW_EVENT_CREATE | wxFSW_EVENT_DELETE |
wxFSW_EVENT_RENAME | wxFSW_EVENT_MODIFY |
wxFSW_EVENT_ACCESS | wxFSW_EVENT_ATTRIB |
wxFSW_EVENT_WARNING | wxFSW_EVENT_ERROR
#if defined(wxHAS_INOTIFY) || defined(wxHAVE_FSEVENTS_FILE_NOTIFICATIONS)
,wxFSW_EVENT_UNMOUNT = 0x2000
#endif
};
// Type of the path watched, used only internally for now.
enum wxFSWPathType
{
wxFSWPath_None, // Invalid value for an initialized watch.
wxFSWPath_File, // Plain file.
wxFSWPath_Dir, // Watch a directory and the files in it.
wxFSWPath_Tree // Watch a directory and all its children recursively.
};
// Type of the warning for the events notifying about them.
enum wxFSWWarningType
{
wxFSW_WARNING_NONE,
wxFSW_WARNING_GENERAL,
wxFSW_WARNING_OVERFLOW
};
/**
* Event containing information about file system change.
*/
class WXDLLIMPEXP_FWD_BASE wxFileSystemWatcherEvent;
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_BASE, wxEVT_FSWATCHER,
wxFileSystemWatcherEvent);
class WXDLLIMPEXP_BASE wxFileSystemWatcherEvent: public wxEvent
{
public:
// Constructor for any kind of events, also used as default ctor.
wxFileSystemWatcherEvent(int changeType = 0, int watchid = wxID_ANY) :
wxEvent(watchid, wxEVT_FSWATCHER),
m_changeType(changeType),
m_warningType(wxFSW_WARNING_NONE)
{
}
// Constructor for the error or warning events.
wxFileSystemWatcherEvent(int changeType,
wxFSWWarningType warningType,
const wxString& errorMsg = wxString(),
int watchid = wxID_ANY) :
wxEvent(watchid, wxEVT_FSWATCHER),
m_changeType(changeType),
m_warningType(warningType),
m_errorMsg(errorMsg)
{
}
// Constructor for the normal events carrying information about the changes.
wxFileSystemWatcherEvent(int changeType,
const wxFileName& path, const wxFileName& newPath,
int watchid = wxID_ANY) :
wxEvent(watchid, wxEVT_FSWATCHER),
m_changeType(changeType),
m_warningType(wxFSW_WARNING_NONE),
m_path(path),
m_newPath(newPath)
{
}
/**
* Returns the path at which the event occurred.
*/
const wxFileName& GetPath() const
{
return m_path;
}
/**
* Sets the path at which the event occurred
*/
void SetPath(const wxFileName& path)
{
m_path = path;
}
/**
* In case of rename(move?) events, returns the new path related to the
* event. The "new" means newer in the sense of time. In case of other
* events it returns the same path as GetPath().
*/
const wxFileName& GetNewPath() const
{
return m_newPath;
}
/**
* Sets the new path related to the event. See above.
*/
void SetNewPath(const wxFileName& path)
{
m_newPath = path;
}
/**
* Returns the type of file system event that occurred.
*/
int GetChangeType() const
{
return m_changeType;
}
virtual wxEvent* Clone() const wxOVERRIDE
{
wxFileSystemWatcherEvent* evt = new wxFileSystemWatcherEvent(*this);
evt->m_errorMsg = m_errorMsg.Clone();
evt->m_path = wxFileName(m_path.GetFullPath().Clone());
evt->m_newPath = wxFileName(m_newPath.GetFullPath().Clone());
evt->m_warningType = m_warningType;
return evt;
}
virtual wxEventCategory GetEventCategory() const wxOVERRIDE
{
// TODO this has to be merged with "similar" categories and changed
return wxEVT_CATEGORY_UNKNOWN;
}
/**
* Returns if this error is an error event
*/
bool IsError() const
{
return (m_changeType & (wxFSW_EVENT_ERROR | wxFSW_EVENT_WARNING)) != 0;
}
wxString GetErrorDescription() const
{
return m_errorMsg;
}
wxFSWWarningType GetWarningType() const
{
return m_warningType;
}
/**
* Returns a wxString describing an event useful for debugging or testing
*/
wxString ToString() const;
protected:
int m_changeType;
wxFSWWarningType m_warningType;
wxFileName m_path;
wxFileName m_newPath;
wxString m_errorMsg;
private:
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxFileSystemWatcherEvent);
};
typedef void (wxEvtHandler::*wxFileSystemWatcherEventFunction)
(wxFileSystemWatcherEvent&);
#define wxFileSystemWatcherEventHandler(func) \
wxEVENT_HANDLER_CAST(wxFileSystemWatcherEventFunction, func)
#define EVT_FSWATCHER(winid, func) \
wx__DECLARE_EVT1(wxEVT_FSWATCHER, winid, wxFileSystemWatcherEventHandler(func))
// ----------------------------------------------------------------------------
// wxFileSystemWatcherBase: interface for wxFileSystemWatcher
// ----------------------------------------------------------------------------
// Simple container to store information about one watched path.
class wxFSWatchInfo
{
public:
wxFSWatchInfo() :
m_events(-1), m_type(wxFSWPath_None), m_refcount(-1)
{
}
wxFSWatchInfo(const wxString& path,
int events,
wxFSWPathType type,
const wxString& filespec = wxString()) :
m_path(path), m_filespec(filespec), m_events(events), m_type(type),
m_refcount(1)
{
}
const wxString& GetPath() const
{
return m_path;
}
const wxString& GetFilespec() const { return m_filespec; }
int GetFlags() const
{
return m_events;
}
wxFSWPathType GetType() const
{
return m_type;
}
// Reference counting of watch entries is used to avoid watching the same
// file system path multiple times (this can happen even accidentally, e.g.
// when you have a recursive watch and then decide to watch some file or
// directory under it separately).
int IncRef()
{
return ++m_refcount;
}
int DecRef()
{
wxASSERT_MSG( m_refcount > 0, wxS("Trying to decrement a zero count") );
return --m_refcount;
}
protected:
wxString m_path;
wxString m_filespec; // For tree watches, holds any filespec to apply
int m_events;
wxFSWPathType m_type;
int m_refcount;
};
WX_DECLARE_STRING_HASH_MAP(wxFSWatchInfo, wxFSWatchInfoMap);
/**
* Encapsulation of platform-specific file system event mechanism
*/
class wxFSWatcherImpl;
/**
* Main entry point for clients interested in file system events.
* Defines interface that can be used to receive that kind of events.
*/
class WXDLLIMPEXP_BASE wxFileSystemWatcherBase: public wxEvtHandler
{
public:
wxFileSystemWatcherBase();
virtual ~wxFileSystemWatcherBase();
/**
* Adds path to currently watched files. Any events concerning this
* particular path will be sent to handler. Optionally a filter can be
* specified to receive only events of particular type.
*
* Please note that when adding a dir, immediate children will be watched
* as well.
*/
virtual bool Add(const wxFileName& path, int events = wxFSW_EVENT_ALL);
/**
* Like above, but recursively adds every file/dir in the tree rooted in
* path. Additionally a file mask can be specified to include only files
* of particular type.
*/
virtual bool AddTree(const wxFileName& path, int events = wxFSW_EVENT_ALL,
const wxString& filespec = wxEmptyString);
/**
* Removes path from the list of watched paths.
*/
virtual bool Remove(const wxFileName& path);
/**
* Same as above, but also removes every file belonging to the tree rooted
* at path.
*/
virtual bool RemoveTree(const wxFileName& path);
/**
* Clears the list of currently watched paths.
*/
virtual bool RemoveAll();
/**
* Returns the number of watched paths
*/
int GetWatchedPathsCount() const;
/**
* Retrieves all watched paths and places them in wxArrayString. Returns
* the number of paths.
*
* TODO think about API here: we need to return more information (like is
* the path watched recursively)
*/
int GetWatchedPaths(wxArrayString* paths) const;
wxEvtHandler* GetOwner() const
{
return m_owner;
}
void SetOwner(wxEvtHandler* handler)
{
if (!handler)
m_owner = this;
else
m_owner = handler;
}
// This is a semi-private function used by wxWidgets itself only.
//
// Delegates the real work of adding the path to wxFSWatcherImpl::Add() and
// updates m_watches if the new path was successfully added.
bool AddAny(const wxFileName& path, int events, wxFSWPathType type,
const wxString& filespec = wxString());
protected:
static wxString GetCanonicalPath(const wxFileName& path)
{
wxFileName path_copy = wxFileName(path);
if ( !path_copy.Normalize() )
{
wxFAIL_MSG(wxString::Format("Unable to normalize path '%s'",
path.GetFullPath()));
return wxEmptyString;
}
return path_copy.GetFullPath();
}
wxFSWatchInfoMap m_watches; // path=>wxFSWatchInfo map
wxFSWatcherImpl* m_service; // file system events service
wxEvtHandler* m_owner; // handler for file system events
friend class wxFSWatcherImpl;
};
// include the platform specific file defining wxFileSystemWatcher
// inheriting from wxFileSystemWatcherBase
#ifdef wxHAS_INOTIFY
#include "wx/unix/fswatcher_inotify.h"
#define wxFileSystemWatcher wxInotifyFileSystemWatcher
#elif defined(wxHAS_KQUEUE) && defined(wxHAVE_FSEVENTS_FILE_NOTIFICATIONS)
#include "wx/unix/fswatcher_kqueue.h"
#include "wx/osx/fswatcher_fsevents.h"
#define wxFileSystemWatcher wxFsEventsFileSystemWatcher
#elif defined(wxHAS_KQUEUE)
#include "wx/unix/fswatcher_kqueue.h"
#define wxFileSystemWatcher wxKqueueFileSystemWatcher
#elif defined(__WINDOWS__)
#include "wx/msw/fswatcher.h"
#define wxFileSystemWatcher wxMSWFileSystemWatcher
#else
#include "wx/generic/fswatcher.h"
#define wxFileSystemWatcher wxPollingFileSystemWatcher
#endif
#endif // wxUSE_FSWATCHER
#endif /* _WX_FSWATCHER_BASE_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/anystr.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/anystr.h
// Purpose: wxAnyStrPtr class declaration
// Author: Vadim Zeitlin
// Created: 2009-03-23
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ANYSTR_H_
#define _WX_ANYSTR_H_
#include "wx/string.h"
// ----------------------------------------------------------------------------
// wxAnyStrPtr
//
// Notice that this is an internal and intentionally not documented class. It
// is only used by wxWidgets itself to ensure compatibility with previous
// versions and shouldn't be used by user code. When you see a function
// returning it you should just know that you can treat it as a string pointer.
// ----------------------------------------------------------------------------
// This is a helper class convertible to either narrow or wide string pointer.
// It is similar to wxCStrData but, unlike it, can be NULL which is required to
// represent the return value of wxDateTime::ParseXXX() methods for example.
//
// NB: this class is fully inline and so doesn't need to be DLL-exported
class wxAnyStrPtr
{
public:
// ctors: this class must be created from the associated string or using
// its default ctor for an invalid NULL-like object; notice that it is
// immutable after creation.
// ctor for invalid pointer
wxAnyStrPtr()
: m_str(NULL)
{
}
// ctor for valid pointer into the given string (whose lifetime must be
// greater than ours and which should remain constant while we're used)
wxAnyStrPtr(const wxString& str, const wxString::const_iterator& iter)
: m_str(&str),
m_iter(iter)
{
}
// default copy ctor is ok and so is default dtor, in particular we do not
// free the string
// various operators meant to make this class look like a superposition of
// char* and wchar_t*
// this one is needed to allow boolean expressions involving these objects,
// e.g. "if ( FuncReturningAnyStrPtr() && ... )" (unfortunately using
// unspecified_bool_type here wouldn't help with ambiguity between all the
// different conversions to pointers)
operator bool() const { return m_str != NULL; }
// at least VC7 also needs this one or it complains about ambiguity
// for !anystr expressions
bool operator!() const { return !((bool)*this); }
// and these are the conversions operator which allow to assign the result
// of FuncReturningAnyStrPtr() to either char* or wxChar* (i.e. wchar_t*)
operator const char *() const
{
if ( !m_str )
return NULL;
// check if the string is convertible to char at all
//
// notice that this pointer points into wxString internal buffer
// containing its char* representation and so it can be kept for as
// long as wxString is not modified -- which is long enough for our
// needs
const char *p = m_str->c_str().AsChar();
if ( *p )
{
// find the offset of the character corresponding to this iterator
// position in bytes: we don't have any direct way to do it so we
// need to redo the conversion again for the part of the string
// before the iterator to find its length in bytes in current
// locale
//
// NB: conversion won't fail as it succeeded for the entire string
p += strlen(wxString(m_str->begin(), m_iter).mb_str());
}
//else: conversion failed, return "" as we can't do anything else
return p;
}
operator const wchar_t *() const
{
if ( !m_str )
return NULL;
// no complications with wide strings (as long as we discount
// surrogates as we do for now)
//
// just remember that this works as long as wxString keeps an internal
// buffer with its wide wide char representation, just as with AsChar()
// above
return m_str->c_str().AsWChar() + (m_iter - m_str->begin());
}
// Because the objects of this class are only used as return type for
// functions which can return NULL we can skip providing dereferencing
// operators: the code using this class must test it for NULL first and if
// it does anything else with it it has to assign it to either char* or
// wchar_t* itself, before dereferencing.
//
// IOW this
//
// if ( *FuncReturningAnyStrPtr() )
//
// is invalid because it could crash. And this
//
// const char *p = FuncReturningAnyStrPtr();
// if ( p && *p )
//
// already works fine.
private:
// the original string and the position in it we correspond to, if the
// string is NULL this object is NULL pointer-like
const wxString * const m_str;
const wxString::const_iterator m_iter;
wxDECLARE_NO_ASSIGN_CLASS(wxAnyStrPtr);
};
#endif // _WX_ANYSTR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/dir.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/dir.h
// Purpose: wxDir is a class for enumerating the files in a directory
// Author: Vadim Zeitlin
// Modified by:
// Created: 08.12.99
// Copyright: (c) 1999 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIR_H_
#define _WX_DIR_H_
#include "wx/longlong.h"
#include "wx/string.h"
#include "wx/filefn.h" // for wxS_DIR_DEFAULT
class WXDLLIMPEXP_FWD_BASE wxArrayString;
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// These flags affect the behaviour of GetFirst/GetNext() and Traverse().
// They define what types are included in the list of items they produce.
// Note that wxDIR_NO_FOLLOW is relevant only on Unix and ignored under systems
// not supporting symbolic links.
enum wxDirFlags
{
wxDIR_FILES = 0x0001, // include files
wxDIR_DIRS = 0x0002, // include directories
wxDIR_HIDDEN = 0x0004, // include hidden files
wxDIR_DOTDOT = 0x0008, // include '.' and '..'
wxDIR_NO_FOLLOW = 0x0010, // don't dereference any symlink
// by default, enumerate everything except '.' and '..'
wxDIR_DEFAULT = wxDIR_FILES | wxDIR_DIRS | wxDIR_HIDDEN
};
// these constants are possible return value of wxDirTraverser::OnDir()
enum wxDirTraverseResult
{
wxDIR_IGNORE = -1, // ignore this directory but continue with others
wxDIR_STOP, // stop traversing
wxDIR_CONTINUE // continue into this directory
};
#if wxUSE_LONGLONG
// error code of wxDir::GetTotalSize()
extern WXDLLIMPEXP_DATA_BASE(const wxULongLong) wxInvalidSize;
#endif // wxUSE_LONGLONG
// ----------------------------------------------------------------------------
// wxDirTraverser: helper class for wxDir::Traverse()
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxDirTraverser
{
public:
/// a virtual dtor has been provided since this class has virtual members
virtual ~wxDirTraverser() { }
// called for each file found by wxDir::Traverse()
//
// return wxDIR_STOP or wxDIR_CONTINUE from here (wxDIR_IGNORE doesn't
// make sense)
virtual wxDirTraverseResult OnFile(const wxString& filename) = 0;
// called for each directory found by wxDir::Traverse()
//
// return one of the enum elements defined above
virtual wxDirTraverseResult OnDir(const wxString& dirname) = 0;
// called for each directory which we couldn't open during our traversal
// of the directory tree
//
// this method can also return either wxDIR_STOP, wxDIR_IGNORE or
// wxDIR_CONTINUE but the latter is treated specially: it means to retry
// opening the directory and so may lead to infinite loop if it is
// returned unconditionally, be careful with this!
//
// the base class version always returns wxDIR_IGNORE
virtual wxDirTraverseResult OnOpenError(const wxString& dirname);
};
// ----------------------------------------------------------------------------
// wxDir: portable equivalent of {open/read/close}dir functions
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_BASE wxDirData;
class WXDLLIMPEXP_BASE wxDir
{
public:
// ctors
// -----
// default, use Open()
wxDir() { m_data = NULL; }
// opens the directory for enumeration, use IsOpened() to test success
wxDir(const wxString& dir);
// dtor calls Close() automatically
~wxDir() { Close(); }
// open the directory for enumerating
bool Open(const wxString& dir);
// close the directory, Open() can be called again later
void Close();
// returns true if the directory was successfully opened
bool IsOpened() const;
// get the full name of the directory (without '/' at the end)
wxString GetName() const;
// Same as GetName() but does include the trailing separator, unless the
// string is empty (only for invalid directories).
wxString GetNameWithSep() const;
// file enumeration routines
// -------------------------
// start enumerating all files matching filespec (or all files if it is
// empty) and flags, return true on success
bool GetFirst(wxString *filename,
const wxString& filespec = wxEmptyString,
int flags = wxDIR_DEFAULT) const;
// get next file in the enumeration started with GetFirst()
bool GetNext(wxString *filename) const;
// return true if this directory has any files in it
bool HasFiles(const wxString& spec = wxEmptyString) const;
// return true if this directory has any subdirectories
bool HasSubDirs(const wxString& spec = wxEmptyString) const;
// enumerate all files in this directory and its subdirectories
//
// return the number of files found
size_t Traverse(wxDirTraverser& sink,
const wxString& filespec = wxEmptyString,
int flags = wxDIR_DEFAULT) const;
// simplest version of Traverse(): get the names of all files under this
// directory into filenames array, return the number of files
static size_t GetAllFiles(const wxString& dirname,
wxArrayString *files,
const wxString& filespec = wxEmptyString,
int flags = wxDIR_DEFAULT);
// check if there any files matching the given filespec under the given
// directory (i.e. searches recursively), return the file path if found or
// empty string otherwise
static wxString FindFirst(const wxString& dirname,
const wxString& filespec,
int flags = wxDIR_DEFAULT);
#if wxUSE_LONGLONG
// returns the size of all directories recursively found in given path
static wxULongLong GetTotalSize(const wxString &dir, wxArrayString *filesSkipped = NULL);
#endif // wxUSE_LONGLONG
// static utilities for directory management
// (alias to wxFileName's functions for dirs)
// -----------------------------------------
// test for existence of a directory with the given name
static bool Exists(const wxString& dir);
static bool Make(const wxString &dir, int perm = wxS_DIR_DEFAULT,
int flags = 0);
static bool Remove(const wxString &dir, int flags = 0);
private:
friend class wxDirData;
wxDirData *m_data;
wxDECLARE_NO_COPY_CLASS(wxDir);
};
#endif // _WX_DIR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/paper.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/paper.h
// Purpose: Paper database types and classes
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PAPERH__
#define _WX_PAPERH__
#include "wx/defs.h"
#include "wx/event.h"
#include "wx/cmndata.h"
#include "wx/intl.h"
#include "wx/hashmap.h"
/*
* Paper type: see defs.h for wxPaperSize enum.
* A wxPrintPaperType can have an id and a name, or just a name and wxPAPER_NONE,
* so you can add further paper types without needing new ids.
*/
#ifdef __WXMSW__
#define WXADDPAPER(paperId, platformId, name, w, h) AddPaperType(paperId, platformId, name, w, h)
#else
#define WXADDPAPER(paperId, platformId, name, w, h) AddPaperType(paperId, 0, name, w, h)
#endif
class WXDLLIMPEXP_CORE wxPrintPaperType: public wxObject
{
public:
wxPrintPaperType();
// platformId is a platform-specific id, such as in Windows, DMPAPER_...
wxPrintPaperType(wxPaperSize paperId, int platformId, const wxString& name, int w, int h);
inline wxString GetName() const { return wxGetTranslation(m_paperName); }
inline wxPaperSize GetId() const { return m_paperId; }
inline int GetPlatformId() const { return m_platformId; }
// Get width and height in tenths of a millimetre
inline int GetWidth() const { return m_width; }
inline int GetHeight() const { return m_height; }
// Get size in tenths of a millimetre
inline wxSize GetSize() const { return wxSize(m_width, m_height); }
// Get size in a millimetres
inline wxSize GetSizeMM() const { return wxSize(m_width/10, m_height/10); }
// Get width and height in device units (1/72th of an inch)
wxSize GetSizeDeviceUnits() const ;
public:
wxPaperSize m_paperId;
int m_platformId;
int m_width; // In tenths of a millimetre
int m_height; // In tenths of a millimetre
wxString m_paperName;
private:
wxDECLARE_DYNAMIC_CLASS(wxPrintPaperType);
};
WX_DECLARE_STRING_HASH_MAP(wxPrintPaperType*, wxStringToPrintPaperTypeHashMap);
class WXDLLIMPEXP_FWD_CORE wxPrintPaperTypeList;
class WXDLLIMPEXP_CORE wxPrintPaperDatabase
{
public:
wxPrintPaperDatabase();
~wxPrintPaperDatabase();
void CreateDatabase();
void ClearDatabase();
void AddPaperType(wxPaperSize paperId, const wxString& name, int w, int h);
void AddPaperType(wxPaperSize paperId, int platformId, const wxString& name, int w, int h);
// Find by name
wxPrintPaperType *FindPaperType(const wxString& name);
// Find by size id
wxPrintPaperType *FindPaperType(wxPaperSize id);
// Find by platform id
wxPrintPaperType *FindPaperTypeByPlatformId(int id);
// Find by size
wxPrintPaperType *FindPaperType(const wxSize& size);
// Convert name to size id
wxPaperSize ConvertNameToId(const wxString& name);
// Convert size id to name
wxString ConvertIdToName(wxPaperSize paperId);
// Get the paper size
wxSize GetSize(wxPaperSize paperId);
// Get the paper size
wxPaperSize GetSize(const wxSize& size);
//
wxPrintPaperType* Item(size_t index) const;
size_t GetCount() const;
private:
wxStringToPrintPaperTypeHashMap* m_map;
wxPrintPaperTypeList* m_list;
//wxDECLARE_DYNAMIC_CLASS(wxPrintPaperDatabase);
};
extern WXDLLIMPEXP_DATA_CORE(wxPrintPaperDatabase*) wxThePrintPaperDatabase;
#endif
// _WX_PAPERH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/zipstrm.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/zipstrm.h
// Purpose: Streams for Zip files
// Author: Mike Wetherell
// Copyright: (c) Mike Wetherell
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WXZIPSTREAM_H__
#define _WX_WXZIPSTREAM_H__
#include "wx/defs.h"
#if wxUSE_ZIPSTREAM
#include "wx/archive.h"
#include "wx/filename.h"
// some methods from wxZipInputStream and wxZipOutputStream stream do not get
// exported/imported when compiled with Mingw versions before 3.4.2. So they
// are imported/exported individually as a workaround
#if (defined(__GNUWIN32__) || defined(__MINGW32__)) \
&& (!defined __GNUC__ \
|| !defined __GNUC_MINOR__ \
|| !defined __GNUC_PATCHLEVEL__ \
|| __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 30402)
#define WXZIPFIX WXDLLIMPEXP_BASE
#else
#define WXZIPFIX
#endif
/////////////////////////////////////////////////////////////////////////////
// constants
// Compression Method, only 0 (store) and 8 (deflate) are supported here
//
enum wxZipMethod
{
wxZIP_METHOD_STORE,
wxZIP_METHOD_SHRINK,
wxZIP_METHOD_REDUCE1,
wxZIP_METHOD_REDUCE2,
wxZIP_METHOD_REDUCE3,
wxZIP_METHOD_REDUCE4,
wxZIP_METHOD_IMPLODE,
wxZIP_METHOD_TOKENIZE,
wxZIP_METHOD_DEFLATE,
wxZIP_METHOD_DEFLATE64,
wxZIP_METHOD_BZIP2 = 12,
wxZIP_METHOD_DEFAULT = 0xffff
};
// Originating File-System.
//
// These are Pkware's values. Note that Info-zip disagree on some of them,
// most notably NTFS.
//
enum wxZipSystem
{
wxZIP_SYSTEM_MSDOS,
wxZIP_SYSTEM_AMIGA,
wxZIP_SYSTEM_OPENVMS,
wxZIP_SYSTEM_UNIX,
wxZIP_SYSTEM_VM_CMS,
wxZIP_SYSTEM_ATARI_ST,
wxZIP_SYSTEM_OS2_HPFS,
wxZIP_SYSTEM_MACINTOSH,
wxZIP_SYSTEM_Z_SYSTEM,
wxZIP_SYSTEM_CPM,
wxZIP_SYSTEM_WINDOWS_NTFS,
wxZIP_SYSTEM_MVS,
wxZIP_SYSTEM_VSE,
wxZIP_SYSTEM_ACORN_RISC,
wxZIP_SYSTEM_VFAT,
wxZIP_SYSTEM_ALTERNATE_MVS,
wxZIP_SYSTEM_BEOS,
wxZIP_SYSTEM_TANDEM,
wxZIP_SYSTEM_OS_400
};
// Dos/Win file attributes
//
enum wxZipAttributes
{
wxZIP_A_RDONLY = 0x01,
wxZIP_A_HIDDEN = 0x02,
wxZIP_A_SYSTEM = 0x04,
wxZIP_A_SUBDIR = 0x10,
wxZIP_A_ARCH = 0x20,
wxZIP_A_MASK = 0x37
};
// Values for the flags field in the zip headers
//
enum wxZipFlags
{
wxZIP_ENCRYPTED = 0x0001,
wxZIP_DEFLATE_NORMAL = 0x0000, // normal compression
wxZIP_DEFLATE_EXTRA = 0x0002, // extra compression
wxZIP_DEFLATE_FAST = 0x0004, // fast compression
wxZIP_DEFLATE_SUPERFAST = 0x0006, // superfast compression
wxZIP_DEFLATE_MASK = 0x0006,
wxZIP_SUMS_FOLLOW = 0x0008, // crc and sizes come after the data
wxZIP_ENHANCED = 0x0010,
wxZIP_PATCH = 0x0020,
wxZIP_STRONG_ENC = 0x0040,
wxZIP_LANG_ENC_UTF8 = 0x0800, // filename and comment are UTF8
wxZIP_UNUSED = 0x0F80,
wxZIP_RESERVED = 0xF000
};
enum wxZipArchiveFormat
{
/// Default zip format
wxZIP_FORMAT_DEFAULT,
/// ZIP64 format
wxZIP_FORMAT_ZIP64
};
// Forward decls
//
class WXDLLIMPEXP_FWD_BASE wxZipEntry;
class WXDLLIMPEXP_FWD_BASE wxZipInputStream;
/////////////////////////////////////////////////////////////////////////////
// wxZipNotifier
class WXDLLIMPEXP_BASE wxZipNotifier
{
public:
virtual ~wxZipNotifier() { }
virtual void OnEntryUpdated(wxZipEntry& entry) = 0;
};
/////////////////////////////////////////////////////////////////////////////
// Zip Entry - holds the meta data for a file in the zip
class wxDataOutputStream;
class WXDLLIMPEXP_BASE wxZipEntry : public wxArchiveEntry
{
public:
wxZipEntry(const wxString& name = wxEmptyString,
const wxDateTime& dt = wxDateTime::Now(),
wxFileOffset size = wxInvalidOffset);
virtual ~wxZipEntry();
wxZipEntry(const wxZipEntry& entry);
wxZipEntry& operator=(const wxZipEntry& entry);
// Get accessors
wxDateTime GetDateTime() const wxOVERRIDE { return m_DateTime; }
wxFileOffset GetSize() const wxOVERRIDE { return m_Size; }
wxFileOffset GetOffset() const wxOVERRIDE { return m_Offset; }
wxString GetInternalName() const wxOVERRIDE { return m_Name; }
int GetMethod() const { return m_Method; }
int GetFlags() const { return m_Flags; }
wxUint32 GetCrc() const { return m_Crc; }
wxFileOffset GetCompressedSize() const { return m_CompressedSize; }
int GetSystemMadeBy() const { return m_SystemMadeBy; }
wxString GetComment() const { return m_Comment; }
wxUint32 GetExternalAttributes() const { return m_ExternalAttributes; }
wxPathFormat GetInternalFormat() const wxOVERRIDE { return wxPATH_UNIX; }
int GetMode() const;
const char *GetLocalExtra() const;
size_t GetLocalExtraLen() const;
const char *GetExtra() const;
size_t GetExtraLen() const;
wxString GetName(wxPathFormat format = wxPATH_NATIVE) const wxOVERRIDE;
// is accessors
inline bool IsDir() const wxOVERRIDE;
inline bool IsText() const;
inline bool IsReadOnly() const wxOVERRIDE;
inline bool IsMadeByUnix() const;
// set accessors
void SetDateTime(const wxDateTime& dt) wxOVERRIDE { m_DateTime = dt; }
void SetSize(wxFileOffset size) wxOVERRIDE { m_Size = size; }
void SetMethod(int method) { m_Method = (wxUint16)method; }
void SetComment(const wxString& comment) { m_Comment = comment; }
void SetExternalAttributes(wxUint32 attr ) { m_ExternalAttributes = attr; }
void SetSystemMadeBy(int system);
void SetMode(int mode);
void SetExtra(const char *extra, size_t len);
void SetLocalExtra(const char *extra, size_t len);
inline void SetName(const wxString& name,
wxPathFormat format = wxPATH_NATIVE) wxOVERRIDE;
static wxString GetInternalName(const wxString& name,
wxPathFormat format = wxPATH_NATIVE,
bool *pIsDir = NULL);
// set is accessors
void SetIsDir(bool isDir = true) wxOVERRIDE;
inline void SetIsReadOnly(bool isReadOnly = true) wxOVERRIDE;
inline void SetIsText(bool isText = true);
wxZipEntry *Clone() const { return ZipClone(); }
void SetNotifier(wxZipNotifier& notifier);
void UnsetNotifier() wxOVERRIDE;
protected:
// Internal attributes
enum { TEXT_ATTR = 1 };
// protected Get accessors
int GetVersionNeeded() const { return m_VersionNeeded; }
wxFileOffset GetKey() const { return m_Key; }
int GetVersionMadeBy() const { return m_VersionMadeBy; }
int GetDiskStart() const { return m_DiskStart; }
int GetInternalAttributes() const { return m_InternalAttributes; }
void SetVersionNeeded(int version) { m_VersionNeeded = (wxUint16)version; }
void SetOffset(wxFileOffset offset) wxOVERRIDE { m_Offset = offset; }
void SetFlags(int flags) { m_Flags = (wxUint16)flags; }
void SetVersionMadeBy(int version) { m_VersionMadeBy = (wxUint8)version; }
void SetCrc(wxUint32 crc) { m_Crc = crc; }
void SetCompressedSize(wxFileOffset size) { m_CompressedSize = size; }
void SetKey(wxFileOffset offset) { m_Key = offset; }
void SetDiskStart(int start) { m_DiskStart = (wxUint16)start; }
void SetInternalAttributes(int attr) { m_InternalAttributes = (wxUint16)attr; }
virtual wxZipEntry *ZipClone() const { return new wxZipEntry(*this); }
void Notify();
private:
wxArchiveEntry* DoClone() const wxOVERRIDE { return ZipClone(); }
size_t ReadLocal(wxInputStream& stream, wxMBConv& conv);
size_t WriteLocal(wxOutputStream& stream, wxMBConv& conv, wxZipArchiveFormat zipFormat);
size_t ReadCentral(wxInputStream& stream, wxMBConv& conv);
size_t WriteCentral(wxOutputStream& stream, wxMBConv& conv) const;
size_t ReadDescriptor(wxInputStream& stream);
size_t WriteDescriptor(wxOutputStream& stream, wxUint32 crc,
wxFileOffset compressedSize, wxFileOffset size);
void WriteLocalFileSizes(wxDataOutputStream& ds) const;
void WriteLocalZip64ExtraInfo(wxOutputStream& stream) const;
bool LoadExtraInfo(const char* extraData, wxUint16 extraLen, bool localInfo);
wxUint16 GetInternalFlags(bool checkForUTF8) const;
wxUint8 m_SystemMadeBy; // one of enum wxZipSystem
wxUint8 m_VersionMadeBy; // major * 10 + minor
wxUint16 m_VersionNeeded; // ver needed to extract (20 i.e. v2.0)
wxUint16 m_Flags;
wxUint16 m_Method; // compression method (one of wxZipMethod)
wxDateTime m_DateTime;
wxUint32 m_Crc;
wxFileOffset m_CompressedSize;
wxFileOffset m_Size;
wxString m_Name; // in internal format
wxFileOffset m_Key; // the original offset for copied entries
wxFileOffset m_Offset; // file offset of the entry
wxString m_Comment;
wxUint16 m_DiskStart; // for multidisk archives, not unsupported
wxUint16 m_InternalAttributes; // bit 0 set for text files
wxUint32 m_ExternalAttributes; // system specific depends on SystemMadeBy
wxUint16 m_z64infoOffset; // Offset of ZIP64 local extra data for file sizes
class wxZipMemory *m_Extra;
class wxZipMemory *m_LocalExtra;
wxZipNotifier *m_zipnotifier;
class wxZipWeakLinks *m_backlink;
friend class wxZipInputStream;
friend class wxZipOutputStream;
wxDECLARE_DYNAMIC_CLASS(wxZipEntry);
};
/////////////////////////////////////////////////////////////////////////////
// wxZipOutputStream
WX_DECLARE_LIST_WITH_DECL(wxZipEntry, wxZipEntryList_, class WXDLLIMPEXP_BASE);
class WXDLLIMPEXP_BASE wxZipOutputStream : public wxArchiveOutputStream
{
public:
wxZipOutputStream(wxOutputStream& stream,
int level = -1,
wxMBConv& conv = wxConvUTF8);
wxZipOutputStream(wxOutputStream *stream,
int level = -1,
wxMBConv& conv = wxConvUTF8);
virtual WXZIPFIX ~wxZipOutputStream();
bool PutNextEntry(wxZipEntry *entry) { return DoCreate(entry); }
bool WXZIPFIX PutNextEntry(const wxString& name,
const wxDateTime& dt = wxDateTime::Now(),
wxFileOffset size = wxInvalidOffset) wxOVERRIDE;
bool WXZIPFIX PutNextDirEntry(const wxString& name,
const wxDateTime& dt = wxDateTime::Now()) wxOVERRIDE;
bool WXZIPFIX CopyEntry(wxZipEntry *entry, wxZipInputStream& inputStream);
bool WXZIPFIX CopyArchiveMetaData(wxZipInputStream& inputStream);
void WXZIPFIX Sync() wxOVERRIDE;
bool WXZIPFIX CloseEntry() wxOVERRIDE;
bool WXZIPFIX Close() wxOVERRIDE;
void SetComment(const wxString& comment) { m_Comment = comment; }
int GetLevel() const { return m_level; }
void WXZIPFIX SetLevel(int level);
void SetFormat(wxZipArchiveFormat format) { m_format = format; }
wxZipArchiveFormat GetFormat() const { return m_format; }
protected:
virtual size_t WXZIPFIX OnSysWrite(const void *buffer, size_t size) wxOVERRIDE;
virtual wxFileOffset OnSysTell() const wxOVERRIDE { return m_entrySize; }
// this protected interface isn't yet finalised
struct Buffer { const char *m_data; size_t m_size; };
virtual wxOutputStream* WXZIPFIX OpenCompressor(wxOutputStream& stream,
wxZipEntry& entry,
const Buffer bufs[]);
virtual bool WXZIPFIX CloseCompressor(wxOutputStream *comp);
bool IsParentSeekable() const
{ return m_offsetAdjustment != wxInvalidOffset; }
private:
void Init(int level);
bool WXZIPFIX PutNextEntry(wxArchiveEntry *entry) wxOVERRIDE;
bool WXZIPFIX CopyEntry(wxArchiveEntry *entry, wxArchiveInputStream& stream) wxOVERRIDE;
bool WXZIPFIX CopyArchiveMetaData(wxArchiveInputStream& stream) wxOVERRIDE;
bool IsOpened() const { return m_comp || m_pending; }
bool DoCreate(wxZipEntry *entry, bool raw = false);
void CreatePendingEntry(const void *buffer, size_t size);
void CreatePendingEntry();
class wxStoredOutputStream *m_store;
class wxZlibOutputStream2 *m_deflate;
class wxZipStreamLink *m_backlink;
wxZipEntryList_ m_entries;
char *m_initialData;
size_t m_initialSize;
wxZipEntry *m_pending;
bool m_raw;
wxFileOffset m_headerOffset;
size_t m_headerSize;
wxFileOffset m_entrySize;
wxUint32 m_crcAccumulator;
wxOutputStream *m_comp;
int m_level;
wxFileOffset m_offsetAdjustment;
wxString m_Comment;
bool m_endrecWritten;
wxZipArchiveFormat m_format;
wxDECLARE_NO_COPY_CLASS(wxZipOutputStream);
};
/////////////////////////////////////////////////////////////////////////////
// wxZipInputStream
class WXDLLIMPEXP_BASE wxZipInputStream : public wxArchiveInputStream
{
public:
typedef wxZipEntry entry_type;
wxZipInputStream(wxInputStream& stream, wxMBConv& conv = wxConvLocal);
wxZipInputStream(wxInputStream *stream, wxMBConv& conv = wxConvLocal);
virtual WXZIPFIX ~wxZipInputStream();
bool OpenEntry(wxZipEntry& entry) { return DoOpen(&entry); }
bool WXZIPFIX CloseEntry() wxOVERRIDE;
wxZipEntry *GetNextEntry();
wxString WXZIPFIX GetComment();
int WXZIPFIX GetTotalEntries();
virtual wxFileOffset GetLength() const wxOVERRIDE { return m_entry.GetSize(); }
protected:
size_t WXZIPFIX OnSysRead(void *buffer, size_t size) wxOVERRIDE;
wxFileOffset OnSysTell() const wxOVERRIDE { return m_decomp ? m_decomp->TellI() : 0; }
// this protected interface isn't yet finalised
virtual wxInputStream* WXZIPFIX OpenDecompressor(wxInputStream& stream);
virtual bool WXZIPFIX CloseDecompressor(wxInputStream *decomp);
private:
void Init();
void Init(const wxString& file);
wxArchiveEntry *DoGetNextEntry() wxOVERRIDE { return GetNextEntry(); }
bool WXZIPFIX OpenEntry(wxArchiveEntry& entry) wxOVERRIDE;
wxStreamError ReadLocal(bool readEndRec = false);
wxStreamError ReadCentral();
wxUint32 ReadSignature();
bool FindEndRecord();
bool LoadEndRecord();
bool AtHeader() const { return m_headerSize == 0; }
bool AfterHeader() const { return m_headerSize > 0 && !m_decomp; }
bool IsOpened() const { return m_decomp != NULL; }
wxZipStreamLink *MakeLink(wxZipOutputStream *out);
bool DoOpen(wxZipEntry *entry = NULL, bool raw = false);
bool OpenDecompressor(bool raw = false);
class wxStoredInputStream *m_store;
class wxZlibInputStream2 *m_inflate;
class wxRawInputStream *m_rawin;
wxZipEntry m_entry;
bool m_raw;
size_t m_headerSize;
wxUint32 m_crcAccumulator;
wxInputStream *m_decomp;
bool m_parentSeekable;
class wxZipWeakLinks *m_weaklinks;
class wxZipStreamLink *m_streamlink;
wxFileOffset m_offsetAdjustment;
wxFileOffset m_position;
wxUint32 m_signature;
size_t m_TotalEntries;
wxString m_Comment;
friend bool wxZipOutputStream::CopyEntry(
wxZipEntry *entry, wxZipInputStream& inputStream);
friend bool wxZipOutputStream::CopyArchiveMetaData(
wxZipInputStream& inputStream);
wxDECLARE_NO_COPY_CLASS(wxZipInputStream);
};
/////////////////////////////////////////////////////////////////////////////
// Iterators
#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
typedef wxArchiveIterator<wxZipInputStream> wxZipIter;
typedef wxArchiveIterator<wxZipInputStream,
std::pair<wxString, wxZipEntry*> > wxZipPairIter;
#endif
/////////////////////////////////////////////////////////////////////////////
// wxZipClassFactory
class WXDLLIMPEXP_BASE wxZipClassFactory : public wxArchiveClassFactory
{
public:
typedef wxZipEntry entry_type;
typedef wxZipInputStream instream_type;
typedef wxZipOutputStream outstream_type;
typedef wxZipNotifier notifier_type;
#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
typedef wxZipIter iter_type;
typedef wxZipPairIter pairiter_type;
#endif
wxZipClassFactory();
wxZipEntry *NewEntry() const
{ return new wxZipEntry; }
wxZipInputStream *NewStream(wxInputStream& stream) const
{ return new wxZipInputStream(stream, GetConv()); }
wxZipOutputStream *NewStream(wxOutputStream& stream) const
{ return new wxZipOutputStream(stream, -1, GetConv()); }
wxZipInputStream *NewStream(wxInputStream *stream) const
{ return new wxZipInputStream(stream, GetConv()); }
wxZipOutputStream *NewStream(wxOutputStream *stream) const
{ return new wxZipOutputStream(stream, -1, GetConv()); }
wxString GetInternalName(const wxString& name,
wxPathFormat format = wxPATH_NATIVE) const wxOVERRIDE
{ return wxZipEntry::GetInternalName(name, format); }
const wxChar * const *GetProtocols(wxStreamProtocolType type
= wxSTREAM_PROTOCOL) const wxOVERRIDE;
protected:
wxArchiveEntry *DoNewEntry() const wxOVERRIDE
{ return NewEntry(); }
wxArchiveInputStream *DoNewStream(wxInputStream& stream) const wxOVERRIDE
{ return NewStream(stream); }
wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const wxOVERRIDE
{ return NewStream(stream); }
wxArchiveInputStream *DoNewStream(wxInputStream *stream) const wxOVERRIDE
{ return NewStream(stream); }
wxArchiveOutputStream *DoNewStream(wxOutputStream *stream) const wxOVERRIDE
{ return NewStream(stream); }
private:
wxDECLARE_DYNAMIC_CLASS(wxZipClassFactory);
};
/////////////////////////////////////////////////////////////////////////////
// wxZipEntry inlines
inline bool wxZipEntry::IsText() const
{
return (m_InternalAttributes & TEXT_ATTR) != 0;
}
inline bool wxZipEntry::IsDir() const
{
return (m_ExternalAttributes & wxZIP_A_SUBDIR) != 0;
}
inline bool wxZipEntry::IsReadOnly() const
{
return (m_ExternalAttributes & wxZIP_A_RDONLY) != 0;
}
inline bool wxZipEntry::IsMadeByUnix() const
{
switch ( m_SystemMadeBy )
{
case wxZIP_SYSTEM_MSDOS:
// note: some unix zippers put madeby = dos
return (m_ExternalAttributes & ~0xFFFF) != 0;
case wxZIP_SYSTEM_OPENVMS:
case wxZIP_SYSTEM_UNIX:
case wxZIP_SYSTEM_ATARI_ST:
case wxZIP_SYSTEM_ACORN_RISC:
case wxZIP_SYSTEM_BEOS:
case wxZIP_SYSTEM_TANDEM:
return true;
case wxZIP_SYSTEM_AMIGA:
case wxZIP_SYSTEM_VM_CMS:
case wxZIP_SYSTEM_OS2_HPFS:
case wxZIP_SYSTEM_MACINTOSH:
case wxZIP_SYSTEM_Z_SYSTEM:
case wxZIP_SYSTEM_CPM:
case wxZIP_SYSTEM_WINDOWS_NTFS:
case wxZIP_SYSTEM_MVS:
case wxZIP_SYSTEM_VSE:
case wxZIP_SYSTEM_VFAT:
case wxZIP_SYSTEM_ALTERNATE_MVS:
case wxZIP_SYSTEM_OS_400:
return false;
}
// Unknown system, assume not Unix.
return false;
}
inline void wxZipEntry::SetIsText(bool isText)
{
if (isText)
m_InternalAttributes |= TEXT_ATTR;
else
m_InternalAttributes &= ~TEXT_ATTR;
}
inline void wxZipEntry::SetIsReadOnly(bool isReadOnly)
{
if (isReadOnly)
SetMode(GetMode() & ~0222);
else
SetMode(GetMode() | 0200);
}
inline void wxZipEntry::SetName(const wxString& name,
wxPathFormat format /*=wxPATH_NATIVE*/)
{
bool isDir;
m_Name = GetInternalName(name, format, &isDir);
SetIsDir(isDir);
}
#endif // wxUSE_ZIPSTREAM
#endif // _WX_WXZIPSTREAM_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_grid.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_grid.h
// Purpose: XML resource handler for wxGrid
// Author: Agron Selimaj
// Created: 2005/08/11
// Copyright: (c) 2005 Agron Selimaj, Freepour Controls Inc.
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_GRD_H_
#define _WX_XH_GRD_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_GRID
class WXDLLIMPEXP_XRC wxGridXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxGridXmlHandler);
public:
wxGridXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_GRID
#endif // _WX_XH_GRD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_stlin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_stlin.h
// Purpose: XML resource handler for wxStaticLine
// Author: Vaclav Slavik
// Created: 2000/09/00
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_STLIN_H_
#define _WX_XH_STLIN_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_STATLINE
class WXDLLIMPEXP_XRC wxStaticLineXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxStaticLineXmlHandler);
public:
wxStaticLineXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_STATLINE
#endif // _WX_XH_STLIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_stbmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_stbmp.h
// Purpose: XML resource handler for wxStaticBitmap
// Author: Vaclav Slavik
// Created: 2000/04/22
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_STBMP_H_
#define _WX_XH_STBMP_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_STATBMP
class WXDLLIMPEXP_XRC wxStaticBitmapXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmapXmlHandler);
public:
wxStaticBitmapXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_STATBMP
#endif // _WX_XH_STBMP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_bmpbt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_bmpbt.h
// Purpose: XML resource handler for bitmap buttons
// Author: Brian Gavin
// Created: 2000/03/05
// Copyright: (c) 2000 Brian Gavin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_BMPBT_H_
#define _WX_XH_BMPBT_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_BMPBUTTON
class WXDLLIMPEXP_XRC wxBitmapButtonXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxBitmapButtonXmlHandler);
public:
wxBitmapButtonXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_BMPBUTTON
#endif // _WX_XH_BMPBT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_bannerwindow.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_bannerwindow.h
// Purpose: Declaration of wxBannerWindow XRC handler.
// Author: Vadim Zeitlin
// Created: 2011-08-16
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_BANNERWINDOW_H_
#define _WX_XH_BANNERWINDOW_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_BANNERWINDOW
class WXDLLIMPEXP_XRC wxBannerWindowXmlHandler : public wxXmlResourceHandler
{
public:
wxBannerWindowXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxBannerWindowXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_BANNERWINDOW
#endif // _WX_XH_BANNERWINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_notbk.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_notbk.h
// Purpose: XML resource handler for wxNotebook
// Author: Vaclav Slavik
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_NOTBK_H_
#define _WX_XH_NOTBK_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_NOTEBOOK
class WXDLLIMPEXP_FWD_CORE wxNotebook;
class WXDLLIMPEXP_XRC wxNotebookXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxNotebookXmlHandler);
public:
wxNotebookXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxNotebook *m_notebook;
};
#endif // wxUSE_XRC && wxUSE_NOTEBOOK
#endif // _WX_XH_NOTBK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_panel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_panel.h
// Purpose: XML resource handler for wxPanel
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_PANEL_H_
#define _WX_XH_PANEL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
class WXDLLIMPEXP_XRC wxPanelXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxPanelXmlHandler);
public:
wxPanelXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC
#endif // _WX_XH_PANEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_cald.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_cald.h
// Purpose: XML resource handler for wxCalendarCtrl
// Author: Brian Gavin
// Created: 2000/09/09
// Copyright: (c) 2000 Brian Gavin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_CALD_H_
#define _WX_XH_CALD_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_CALENDARCTRL
class WXDLLIMPEXP_XRC wxCalendarCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxCalendarCtrlXmlHandler);
public:
wxCalendarCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_CALENDARCTRL
#endif // _WX_XH_CALD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_text.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_text.h
// Purpose: XML resource handler for wxTextCtrl
// Author: Aleksandras Gluchovas
// Created: 2000/03/21
// Copyright: (c) 2000 Aleksandras Gluchovas
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TEXT_H_
#define _WX_XH_TEXT_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_TEXTCTRL
class WXDLLIMPEXP_XRC wxTextCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxTextCtrlXmlHandler);
public:
wxTextCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_TEXTCTRL
#endif // _WX_XH_TEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_datectrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_datectrl.h
// Purpose: XML resource handler for wxDatePickerCtrl
// Author: Vaclav Slavik
// Created: 2005-02-07
// Copyright: (c) 2005 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_DATECTRL_H_
#define _WX_XH_DATECTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_DATEPICKCTRL
class WXDLLIMPEXP_XRC wxDateCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxDateCtrlXmlHandler);
public:
wxDateCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_DATEPICKCTRL
#endif // _WX_XH_DATECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_dirpicker.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_dirpicker.h
// Purpose: XML resource handler for wxDirPickerCtrl
// Author: Francesco Montorsi
// Created: 2006-04-17
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_DIRPICKERCTRL_H_
#define _WX_XH_DIRPICKERCTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_DIRPICKERCTRL
class WXDLLIMPEXP_XRC wxDirPickerCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxDirPickerCtrlXmlHandler);
public:
wxDirPickerCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_DIRPICKERCTRL
#endif // _WX_XH_DIRPICKERCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_combo.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_combo.h
// Purpose: XML resource handler for wxComboBox
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_COMBO_H_
#define _WX_XH_COMBO_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_COMBOBOX
class WXDLLIMPEXP_XRC wxComboBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxComboBoxXmlHandler);
public:
wxComboBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
wxArrayString strList;
};
#endif // wxUSE_XRC && wxUSE_COMBOBOX
#endif // _WX_XH_COMBO_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_dlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_dlg.h
// Purpose: XML resource handler for dialogs
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_DLG_H_
#define _WX_XH_DLG_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
class WXDLLIMPEXP_XRC wxDialogXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxDialogXmlHandler);
public:
wxDialogXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC
#endif // _WX_XH_DLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_scwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_scwin.h
// Purpose: XML resource handler for wxScrolledWindow
// Author: Vaclav Slavik
// Created: 2002/10/18
// Copyright: (c) 2002 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SCWIN_H_
#define _WX_XH_SCWIN_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
class WXDLLIMPEXP_XRC wxScrolledWindowXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxScrolledWindowXmlHandler);
public:
wxScrolledWindowXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC
#endif // _WX_XH_SCWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_slidr.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_slidr.h
// Purpose: XML resource handler for wxSlider
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SLIDR_H_
#define _WX_XH_SLIDR_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_SLIDER
class WXDLLIMPEXP_XRC wxSliderXmlHandler : public wxXmlResourceHandler
{
public:
wxSliderXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxSliderXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_SLIDER
#endif // _WX_XH_SLIDR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_tree.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_tree.h
// Purpose: XML resource handler for wxTreeCtrl
// Author: Brian Gavin
// Created: 2000/09/09
// Copyright: (c) 2000 Brian Gavin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TREE_H_
#define _WX_XH_TREE_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_TREECTRL
class WXDLLIMPEXP_XRC wxTreeCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxTreeCtrlXmlHandler);
public:
wxTreeCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_TREECTRL
#endif // _WX_XH_TREE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xmlres.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xmlres.h
// Purpose: XML resources
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XMLRES_H_
#define _WX_XMLRES_H_
#include "wx/defs.h"
#if wxUSE_XRC
#include "wx/string.h"
#include "wx/dynarray.h"
#include "wx/arrstr.h"
#include "wx/datetime.h"
#include "wx/list.h"
#include "wx/gdicmn.h"
#include "wx/filesys.h"
#include "wx/bitmap.h"
#include "wx/icon.h"
#include "wx/artprov.h"
#include "wx/colour.h"
#include "wx/vector.h"
#include "wx/xrc/xmlreshandler.h"
class WXDLLIMPEXP_FWD_BASE wxFileName;
class WXDLLIMPEXP_FWD_CORE wxIconBundle;
class WXDLLIMPEXP_FWD_CORE wxImageList;
class WXDLLIMPEXP_FWD_CORE wxMenu;
class WXDLLIMPEXP_FWD_CORE wxMenuBar;
class WXDLLIMPEXP_FWD_CORE wxDialog;
class WXDLLIMPEXP_FWD_CORE wxPanel;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxFrame;
class WXDLLIMPEXP_FWD_CORE wxToolBar;
class WXDLLIMPEXP_FWD_XML wxXmlDocument;
class WXDLLIMPEXP_FWD_XML wxXmlNode;
class WXDLLIMPEXP_FWD_XRC wxXmlSubclassFactory;
class wxXmlSubclassFactories;
class wxXmlResourceModule;
class wxXmlResourceDataRecords;
// These macros indicate current version of XML resources (this information is
// encoded in root node of XRC file as "version" property).
//
// Rules for increasing version number:
// - change it only if you made incompatible change to the format. Addition
// of new attribute to control handler is _not_ incompatible change, because
// older versions of the library may ignore it.
// - if you change version number, follow these steps:
// - set major, minor and release numbers to respective version numbers of
// the wxWidgets library (see wx/version.h)
// - reset revision to 0 unless the first three are same as before,
// in which case you should increase revision by one
#define WX_XMLRES_CURRENT_VERSION_MAJOR 2
#define WX_XMLRES_CURRENT_VERSION_MINOR 5
#define WX_XMLRES_CURRENT_VERSION_RELEASE 3
#define WX_XMLRES_CURRENT_VERSION_REVISION 0
#define WX_XMLRES_CURRENT_VERSION_STRING wxT("2.5.3.0")
#define WX_XMLRES_CURRENT_VERSION \
(WX_XMLRES_CURRENT_VERSION_MAJOR * 256*256*256 + \
WX_XMLRES_CURRENT_VERSION_MINOR * 256*256 + \
WX_XMLRES_CURRENT_VERSION_RELEASE * 256 + \
WX_XMLRES_CURRENT_VERSION_REVISION)
enum wxXmlResourceFlags
{
wxXRC_USE_LOCALE = 1,
wxXRC_NO_SUBCLASSING = 2,
wxXRC_NO_RELOADING = 4
};
// This class holds XML resources from one or more .xml files
// (or derived forms, either binary or zipped -- see manual for
// details).
class WXDLLIMPEXP_XRC wxXmlResource : public wxObject
{
public:
// Constructor.
// Flags: wxXRC_USE_LOCALE
// translatable strings will be translated via _()
// using the given domain if specified
// wxXRC_NO_SUBCLASSING
// subclass property of object nodes will be ignored
// (useful for previews in XRC editors)
// wxXRC_NO_RELOADING
// don't check the modification time of the XRC files and
// reload them if they have changed on disk
wxXmlResource(int flags = wxXRC_USE_LOCALE,
const wxString& domain = wxEmptyString);
// Constructor.
// Flags: wxXRC_USE_LOCALE
// translatable strings will be translated via _()
// using the given domain if specified
// wxXRC_NO_SUBCLASSING
// subclass property of object nodes will be ignored
// (useful for previews in XRC editors)
wxXmlResource(const wxString& filemask, int flags = wxXRC_USE_LOCALE,
const wxString& domain = wxEmptyString);
// Destructor.
virtual ~wxXmlResource();
// Loads resources from XML files that match given filemask.
// This method understands wxFileSystem URLs if wxUSE_FILESYS.
bool Load(const wxString& filemask);
// Loads resources from single XRC file.
bool LoadFile(const wxFileName& file);
// Loads all XRC files from a directory.
bool LoadAllFiles(const wxString& dirname);
// Unload resource from the given XML file (wildcards not allowed)
bool Unload(const wxString& filename);
// Initialize handlers for all supported controls/windows. This will
// make the executable quite big because it forces linking against
// most of the wxWidgets library.
void InitAllHandlers();
// Initialize only a specific handler (or custom handler). Convention says
// that handler name is equal to the control's name plus 'XmlHandler', for
// example wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. The XML resource
// compiler (xmlres) can create include file that contains initialization
// code for all controls used within the resource.
void AddHandler(wxXmlResourceHandler *handler);
// Add a new handler at the beginning of the handler list
void InsertHandler(wxXmlResourceHandler *handler);
// Removes all handlers
void ClearHandlers();
// Registers subclasses factory for use in XRC. This function is not meant
// for public use, please see the comment above wxXmlSubclassFactory
// definition.
static void AddSubclassFactory(wxXmlSubclassFactory *factory);
// Loads menu from resource. Returns NULL on failure.
wxMenu *LoadMenu(const wxString& name);
// Loads menubar from resource. Returns NULL on failure.
wxMenuBar *LoadMenuBar(wxWindow *parent, const wxString& name);
// Loads menubar from resource. Returns NULL on failure.
wxMenuBar *LoadMenuBar(const wxString& name) { return LoadMenuBar(NULL, name); }
#if wxUSE_TOOLBAR
// Loads a toolbar.
wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);
#endif
// Loads a dialog. dlg points to parent window (if any).
wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
// Loads a dialog. dlg points to parent window (if any). This form
// is used to finish creation of already existing instance (main reason
// for this is that you may want to use derived class with new event table)
// Example (typical usage):
// MyDialog dlg;
// wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
// dlg->ShowModal();
bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
// Loads a panel. panel points to parent window (if any).
wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
// Loads a panel. panel points to parent window (if any). This form
// is used to finish creation of already existing instance.
bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
// Loads a frame.
wxFrame *LoadFrame(wxWindow* parent, const wxString& name);
bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);
// Load an object from the resource specifying both the resource name and
// the classname. This lets you load nonstandard container windows.
wxObject *LoadObject(wxWindow *parent, const wxString& name,
const wxString& classname)
{
return DoLoadObject(parent, name, classname, false /* !recursive */);
}
// Load an object from the resource specifying both the resource name and
// the classname. This form lets you finish the creation of an existing
// instance.
bool LoadObject(wxObject *instance,
wxWindow *parent,
const wxString& name,
const wxString& classname)
{
return DoLoadObject(instance, parent, name, classname, false);
}
// These versions of LoadObject() look for the object with the given name
// recursively (breadth first) and can be used to instantiate an individual
// control defined anywhere in an XRC file. No check is done that the name
// is unique, it's up to the caller to ensure this.
wxObject *LoadObjectRecursively(wxWindow *parent,
const wxString& name,
const wxString& classname)
{
return DoLoadObject(parent, name, classname, true /* recursive */);
}
bool LoadObjectRecursively(wxObject *instance,
wxWindow *parent,
const wxString& name,
const wxString& classname)
{
return DoLoadObject(instance, parent, name, classname, true);
}
// Loads a bitmap resource from a file.
wxBitmap LoadBitmap(const wxString& name);
// Loads an icon resource from a file.
wxIcon LoadIcon(const wxString& name);
// Attaches an unknown control to the given panel/window/dialog.
// Unknown controls are used in conjunction with <object class="unknown">.
bool AttachUnknownControl(const wxString& name, wxWindow *control,
wxWindow *parent = NULL);
// Returns a numeric ID that is equivalent to the string ID used in an XML
// resource. If an unknown str_id is requested (i.e. other than wxID_XXX
// or integer), a new record is created which associates the given string
// with a number. If value_if_not_found == wxID_NONE, the number is obtained via
// wxWindow::NewControlId(). Otherwise value_if_not_found is used.
// Macro XRCID(name) is provided for convenient use in event tables.
static int GetXRCID(const wxString& str_id, int value_if_not_found = wxID_NONE)
{ return DoGetXRCID(str_id.mb_str(), value_if_not_found); }
// version for internal use only
static int DoGetXRCID(const char *str_id, int value_if_not_found = wxID_NONE);
// Find the string ID with the given numeric value, returns an empty string
// if no such ID is found.
//
// Notice that unlike GetXRCID(), which is fast, this operation is slow as
// it checks all the IDs used in XRC.
static wxString FindXRCIDById(int numId);
// Returns version information (a.b.c.d = d+ 256*c + 256^2*b + 256^3*a).
long GetVersion() const { return m_version; }
// Compares resources version to argument. Returns -1 if resources version
// is less than the argument, +1 if greater and 0 if they equal.
int CompareVersion(int major, int minor, int release, int revision) const
{
long diff = GetVersion() -
(major*256*256*256 + minor*256*256 + release*256 + revision);
if ( diff < 0 )
return -1;
else if ( diff > 0 )
return +1;
else
return 0;
}
//// Singleton accessors.
// Gets the global resources object or creates one if none exists.
static wxXmlResource *Get();
// Sets the global resources object and returns a pointer to the previous one (may be NULL).
static wxXmlResource *Set(wxXmlResource *res);
// Returns flags, which may be a bitlist of wxXRC_USE_LOCALE and wxXRC_NO_SUBCLASSING.
int GetFlags() const { return m_flags; }
// Set flags after construction.
void SetFlags(int flags) { m_flags = flags; }
// Get/Set the domain to be passed to the translation functions, defaults
// to empty string (no domain).
const wxString& GetDomain() const { return m_domain; }
void SetDomain(const wxString& domain);
// This function returns the wxXmlNode containing the definition of the
// object with the given name or NULL.
//
// It can be used to access additional information defined in the XRC file
// and not used by wxXmlResource itself.
const wxXmlNode *GetResourceNode(const wxString& name) const
{ return GetResourceNodeAndLocation(name, wxString(), true); }
protected:
// reports input error at position 'context'
void ReportError(const wxXmlNode *context, const wxString& message);
// override this in derived class to customize errors reporting
virtual void DoReportError(const wxString& xrcFile, const wxXmlNode *position,
const wxString& message);
// Load the contents of a single file and returns its contents as a new
// wxXmlDocument (which will be owned by caller) on success or NULL.
wxXmlDocument *DoLoadFile(const wxString& file);
// Scans the resources list for unloaded files and loads them. Also reloads
// files that have been modified since last loading.
bool UpdateResources();
// Common implementation of GetResourceNode() and FindResource(): searches
// all top-level or all (if recursive == true) nodes if all loaded XRC
// files and returns the node, if found, as well as the path of the file it
// was found in if path is non-NULL
wxXmlNode *GetResourceNodeAndLocation(const wxString& name,
const wxString& classname,
bool recursive = false,
wxString *path = NULL) const;
// Note that these functions are used outside of wxWidgets itself, e.g.
// there are several known cases of inheriting from wxXmlResource just to
// be able to call FindResource() so we keep them for compatibility even if
// their names are not really consistent with GetResourceNode() public
// function and FindResource() is also non-const because it changes the
// current path of m_curFileSystem to ensure that relative paths work
// correctly when CreateResFromNode() is called immediately afterwards
// (something const public function intentionally does not do)
// Returns the node containing the resource with the given name and class
// name unless it's empty (then any class matches) or NULL if not found.
wxXmlNode *FindResource(const wxString& name, const wxString& classname,
bool recursive = false);
// Helper function used by FindResource() to look under the given node.
wxXmlNode *DoFindResource(wxXmlNode *parent, const wxString& name,
const wxString& classname, bool recursive) const;
// Creates a resource from information in the given node
// (Uses only 'handlerToUse' if != NULL)
wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent,
wxObject *instance = NULL,
wxXmlResourceHandler *handlerToUse = NULL)
{
return node ? DoCreateResFromNode(*node, parent, instance, handlerToUse)
: NULL;
}
// Helper of Load() and Unload(): returns the URL corresponding to the
// given file if it's indeed a file, otherwise returns the original string
// unmodified
static wxString ConvertFileNameToURL(const wxString& filename);
// loading resources from archives is impossible without wxFileSystem
#if wxUSE_FILESYSTEM
// Another helper: detect if the filename is a ZIP or XRS file
static bool IsArchive(const wxString& filename);
#endif // wxUSE_FILESYSTEM
private:
wxXmlResourceDataRecords& Data() { return *m_data; }
const wxXmlResourceDataRecords& Data() const { return *m_data; }
// the real implementation of CreateResFromNode(): this should be only
// called if node is non-NULL
wxObject *DoCreateResFromNode(wxXmlNode& node,
wxObject *parent,
wxObject *instance,
wxXmlResourceHandler *handlerToUse = NULL);
// common part of LoadObject() and LoadObjectRecursively()
wxObject *DoLoadObject(wxWindow *parent,
const wxString& name,
const wxString& classname,
bool recursive);
bool DoLoadObject(wxObject *instance,
wxWindow *parent,
const wxString& name,
const wxString& classname,
bool recursive);
private:
long m_version;
int m_flags;
wxVector<wxXmlResourceHandler*> m_handlers;
wxXmlResourceDataRecords *m_data;
#if wxUSE_FILESYSTEM
wxFileSystem m_curFileSystem;
wxFileSystem& GetCurFileSystem() { return m_curFileSystem; }
#endif
// domain to pass to translation functions, if any.
wxString m_domain;
friend class wxXmlResourceHandlerImpl;
friend class wxXmlResourceModule;
friend class wxIdRangeManager;
friend class wxIdRange;
static wxXmlSubclassFactories *ms_subclassFactories;
// singleton instance:
static wxXmlResource *ms_instance;
};
// This macro translates string identifier (as used in XML resource,
// e.g. <menuitem id="my_menu">...</menuitem>) to integer id that is needed by
// wxWidgets event tables.
// Example:
// wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
// EVT_MENU(XRCID("quit"), MyFrame::OnQuit)
// EVT_MENU(XRCID("about"), MyFrame::OnAbout)
// EVT_MENU(XRCID("new"), MyFrame::OnNew)
// EVT_MENU(XRCID("open"), MyFrame::OnOpen)
// wxEND_EVENT_TABLE()
#define XRCID(str_id) \
wxXmlResource::DoGetXRCID(str_id)
// This macro returns pointer to particular control in dialog
// created using XML resources. You can use it to set/get values from
// controls.
// Example:
// wxDialog dlg;
// wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
// XRCCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(wxT("default value"));
#define XRCCTRL(window, id, type) \
(wxStaticCast((window).FindWindow(XRCID(id)), type))
// This macro returns pointer to sizer item
// Example:
//
// <object class="spacer" name="area">
// <size>400, 300</size>
// </object>
//
// wxSizerItem* item = XRCSIZERITEM(*this, "area")
#define XRCSIZERITEM(window, id) \
((window).GetSizer() ? (window).GetSizer()->GetItemById(XRCID(id)) : NULL)
// wxXmlResourceHandlerImpl is the back-end of the wxXmlResourceHander class to
// really implementing all its functionality. It is defined in the "xrc"
// library unlike wxXmlResourceHandler itself which is defined in "core" to
// allow inheriting from it in the code from the other libraries too.
class WXDLLIMPEXP_XRC wxXmlResourceHandlerImpl : public wxXmlResourceHandlerImplBase
{
public:
// Constructor.
wxXmlResourceHandlerImpl(wxXmlResourceHandler *handler);
// Destructor.
virtual ~wxXmlResourceHandlerImpl() {}
// Creates an object (menu, dialog, control, ...) from an XML node.
// Should check for validity.
// parent is a higher-level object (usually window, dialog or panel)
// that is often necessary to create the resource.
// If instance is non-NULL it should not create a new instance via 'new' but
// should rather use this one, and call its Create method.
wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
wxObject *instance) wxOVERRIDE;
// --- Handy methods:
// Returns true if the node has a property class equal to classname,
// e.g. <object class="wxDialog">.
bool IsOfClass(wxXmlNode *node, const wxString& classname) const wxOVERRIDE;
bool IsObjectNode(const wxXmlNode *node) const wxOVERRIDE;
// Gets node content from wxXML_ENTITY_NODE
// The problem is, <tag>content<tag> is represented as
// wxXML_ENTITY_NODE name="tag", content=""
// |-- wxXML_TEXT_NODE or
// wxXML_CDATA_SECTION_NODE name="" content="content"
wxString GetNodeContent(const wxXmlNode *node) wxOVERRIDE;
wxXmlNode *GetNodeParent(const wxXmlNode *node) const wxOVERRIDE;
wxXmlNode *GetNodeNext(const wxXmlNode *node) const wxOVERRIDE;
wxXmlNode *GetNodeChildren(const wxXmlNode *node) const wxOVERRIDE;
// Check to see if a parameter exists.
bool HasParam(const wxString& param) wxOVERRIDE;
// Finds the node or returns NULL.
wxXmlNode *GetParamNode(const wxString& param) wxOVERRIDE;
// Finds the parameter value or returns the empty string.
wxString GetParamValue(const wxString& param) wxOVERRIDE;
// Returns the parameter value from given node.
wxString GetParamValue(const wxXmlNode* node) wxOVERRIDE;
// Gets style flags from text in form "flag | flag2| flag3 |..."
// Only understands flags added with AddStyle
int GetStyle(const wxString& param = wxT("style"), int defaults = 0) wxOVERRIDE;
// Gets text from param and does some conversions:
// - replaces \n, \r, \t by respective chars (according to C syntax)
// - replaces _ by & and __ by _ (needed for _File => &File because of XML)
// - calls wxGetTranslations (unless disabled in wxXmlResource)
//
// The first two conversions can be disabled by using wxXRC_TEXT_NO_ESCAPE
// in flags and the last one -- by using wxXRC_TEXT_NO_TRANSLATE.
wxString GetNodeText(const wxXmlNode *node, int flags = 0) wxOVERRIDE;
// Returns the XRCID.
int GetID() wxOVERRIDE;
// Returns the resource name.
wxString GetName() wxOVERRIDE;
// Gets a bool flag (1, t, yes, on, true are true, everything else is false).
bool GetBool(const wxString& param, bool defaultv = false) wxOVERRIDE;
// Gets an integer value from the parameter.
long GetLong(const wxString& param, long defaultv = 0) wxOVERRIDE;
// Gets a float value from the parameter.
float GetFloat(const wxString& param, float defaultv = 0) wxOVERRIDE;
// Gets colour in HTML syntax (#RRGGBB).
wxColour GetColour(const wxString& param, const wxColour& defaultv = wxNullColour) wxOVERRIDE;
// Gets the size (may be in dialog units).
wxSize GetSize(const wxString& param = wxT("size"),
wxWindow *windowToUse = NULL) wxOVERRIDE;
// Gets the position (may be in dialog units).
wxPoint GetPosition(const wxString& param = wxT("pos")) wxOVERRIDE;
// Gets a dimension (may be in dialog units).
wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
wxWindow *windowToUse = NULL) wxOVERRIDE;
// Gets a size which is not expressed in pixels, so not in dialog units.
wxSize GetPairInts(const wxString& param) wxOVERRIDE;
// Gets a direction, complains if the value is invalid.
wxDirection GetDirection(const wxString& param, wxDirection dirDefault = wxLEFT) wxOVERRIDE;
// Gets a bitmap.
wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) wxOVERRIDE;
// Gets a bitmap from an XmlNode.
wxBitmap GetBitmap(const wxXmlNode* node,
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) wxOVERRIDE;
// Gets an icon.
wxIcon GetIcon(const wxString& param = wxT("icon"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) wxOVERRIDE;
// Gets an icon from an XmlNode.
wxIcon GetIcon(const wxXmlNode* node,
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) wxOVERRIDE;
// Gets an icon bundle.
wxIconBundle GetIconBundle(const wxString& param,
const wxArtClient& defaultArtClient = wxART_OTHER) wxOVERRIDE;
// Gets an image list.
wxImageList *GetImageList(const wxString& param = wxT("imagelist")) wxOVERRIDE;
#if wxUSE_ANIMATIONCTRL
// Gets an animation.
wxAnimation* GetAnimation(const wxString& param = wxT("animation")) wxOVERRIDE;
#endif
// Gets a font.
wxFont GetFont(const wxString& param = wxT("font"), wxWindow* parent = NULL) wxOVERRIDE;
// Gets the value of a boolean attribute (only "0" and "1" are valid values)
bool GetBoolAttr(const wxString& attr, bool defaultv) wxOVERRIDE;
// Returns the window associated with the handler (may be NULL).
wxWindow* GetParentAsWindow() const { return m_handler->GetParentAsWindow(); }
// Sets common window options.
void SetupWindow(wxWindow *wnd) wxOVERRIDE;
// Creates children.
void CreateChildren(wxObject *parent, bool this_hnd_only = false) wxOVERRIDE;
// Helper function.
void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL) wxOVERRIDE;
// Creates a resource from a node.
wxObject *CreateResFromNode(wxXmlNode *node,
wxObject *parent, wxObject *instance = NULL) wxOVERRIDE;
// helper
#if wxUSE_FILESYSTEM
wxFileSystem& GetCurFileSystem() wxOVERRIDE;
#endif
// reports input error at position 'context'
void ReportError(wxXmlNode *context, const wxString& message) wxOVERRIDE;
// reports input error at m_node
void ReportError(const wxString& message) wxOVERRIDE;
// reports input error when parsing parameter with given name
void ReportParamError(const wxString& param, const wxString& message) wxOVERRIDE;
};
// Programmer-friendly macros for writing XRC handlers:
#define XRC_MAKE_INSTANCE(variable, classname) \
classname *variable = NULL; \
if (m_instance) \
variable = wxStaticCast(m_instance, classname); \
if (!variable) \
variable = new classname; \
if (GetBool(wxT("hidden"), 0) == 1) \
variable->Hide();
// FIXME -- remove this $%^#$%#$@# as soon as Ron checks his changes in!!
WXDLLIMPEXP_XRC void wxXmlInitResourceModule();
// This class is used to create instances of XRC "object" nodes with "subclass"
// property. It is _not_ supposed to be used by XRC users, you should instead
// register your subclasses via wxWidgets' RTTI mechanism. This class is useful
// only for language bindings developer who need a way to implement subclassing
// in wxWidgets ports that don't support wxRTTI (e.g. wxPython).
class WXDLLIMPEXP_XRC wxXmlSubclassFactory
{
public:
// Try to create instance of given class and return it, return NULL on
// failure:
virtual wxObject *Create(const wxString& className) = 0;
virtual ~wxXmlSubclassFactory() {}
};
/* -------------------------------------------------------------------------
Backward compatibility macros. Do *NOT* use, they may disappear in future
versions of the XRC library!
------------------------------------------------------------------------- */
#endif // wxUSE_XRC
#endif // _WX_XMLRES_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_treebk.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_treebk.h
// Purpose: XML resource handler for wxTreebook
// Author: Evgeniy Tarassov
// Created: 2005/09/28
// Copyright: (c) 2005 TT-Solutions <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TREEBK_H_
#define _WX_XH_TREEBK_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_TREEBOOK
class WXDLLIMPEXP_FWD_CORE wxTreebook;
#include "wx/dynarray.h"
WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(size_t, wxArrayTbkPageIndexes,
class WXDLLIMPEXP_XRC);
// ---------------------------------------------------------------------
// wxTreebookXmlHandler class
// ---------------------------------------------------------------------
// Resource xml structure have to be almost the "same" as for wxNotebook
// except the additional (size_t)depth parameter for treebookpage nodes
// which indicates the depth of the page in the tree.
// There is only one logical constraint on this parameter :
// it cannot be greater than the previous page depth plus one
class WXDLLIMPEXP_XRC wxTreebookXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxTreebookXmlHandler);
public:
wxTreebookXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxTreebook *m_tbk;
wxArrayTbkPageIndexes m_treeContext;
bool m_isInside;
};
// Example:
// -------
// Label
// \--First
// | \--Second
// \--Third
//
//<resource>
// ...
// <object class="wxTreebook">
// <object class="treebookpage">
// <object class="wxWindow" />
// <label>My first page</label>
// <depth>0</depth>
// </object>
// <object class="treebookpage">
// <object class="wxWindow" />
// <label>First</label>
// <depth>1</depth>
// </object>
// <object class="treebookpage">
// <object class="wxWindow" />
// <label>Second</label>
// <depth>2</depth>
// </object>
// <object class="treebookpage">
// <object class="wxWindow" />
// <label>Third</label>
// <depth>1</depth>
// </object>
// </object>
// ...
//</resource>
#endif // wxUSE_XRC && wxUSE_TREEBOOK
#endif // _WX_XH_TREEBK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_toolb.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_toolb.h
// Purpose: XML resource handler for wxToolBar
// Author: Vaclav Slavik
// Created: 2000/08/11
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TOOLB_H_
#define _WX_XH_TOOLB_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_TOOLBAR
class WXDLLIMPEXP_FWD_CORE wxToolBar;
class WXDLLIMPEXP_XRC wxToolBarXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxToolBarXmlHandler);
public:
wxToolBarXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxToolBar *m_toolbar;
wxSize m_toolSize;
};
#endif // wxUSE_XRC && wxUSE_TOOLBAR
#endif // _WX_XH_TOOLB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_frame.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_frame.h
// Purpose: XML resource handler for wxFrame
// Author: Vaclav Slavik & Aleks.
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_FRAME_H_
#define _WX_XH_FRAME_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
class WXDLLIMPEXP_XRC wxFrameXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxFrameXmlHandler);
public:
wxFrameXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC
#endif // _WX_XH_FRAME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_collpane.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_collpane.h
// Purpose: XML resource handler for wxCollapsiblePane
// Author: Francesco Montorsi
// Created: 2006-10-27
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_COLLPANE_H_
#define _WX_XH_COLLPANE_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_COLLPANE
class WXDLLIMPEXP_FWD_CORE wxCollapsiblePane;
class WXDLLIMPEXP_XRC wxCollapsiblePaneXmlHandler : public wxXmlResourceHandler
{
public:
wxCollapsiblePaneXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxCollapsiblePane *m_collpane;
wxDECLARE_DYNAMIC_CLASS(wxCollapsiblePaneXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_COLLPANE
#endif // _WX_XH_COLLPANE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_comboctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_comboctrl.h
// Purpose: XML resource handler for wxComboBox
// Author: Jaakko Salli
// Created: 2009/01/25
// Copyright: (c) 2009 Jaakko Salli
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_COMBOCTRL_H_
#define _WX_XH_COMBOCTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_COMBOCTRL
class WXDLLIMPEXP_XRC wxComboCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxComboCtrlXmlHandler);
public:
wxComboCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
};
#endif // wxUSE_XRC && wxUSE_COMBOCTRL
#endif // _WX_XH_COMBOCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_activityindicator.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_activityindicator.h
// Purpose: Declaration of wxActivityIndicator XRC handler.
// Author: Vadim Zeitlin
// Created: 2015-03-18
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_ACTIVITYINDICATOR_H_
#define _WX_XH_ACTIVITYINDICATOR_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_ACTIVITYINDICATOR
class WXDLLIMPEXP_XRC wxActivityIndicatorXmlHandler : public wxXmlResourceHandler
{
public:
wxActivityIndicatorXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxActivityIndicatorXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_ACTIVITYINDICATOR
#endif // _WX_XH_ACTIVITYINDICATOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_editlbox.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_editlbox.h
// Purpose: declaration of wxEditableListBox XRC handler
// Author: Vadim Zeitlin
// Created: 2009-06-04
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XRC_XH_EDITLBOX_H_
#define _WX_XRC_XH_EDITLBOX_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_EDITABLELISTBOX
// ----------------------------------------------------------------------------
// wxEditableListBoxXmlHandler: XRC handler for wxEditableListBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_XRC wxEditableListBoxXmlHandler : public wxXmlResourceHandler
{
public:
wxEditableListBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
wxArrayString m_items;
wxDECLARE_DYNAMIC_CLASS(wxEditableListBoxXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_EDITABLELISTBOX
#endif // _WX_XRC_XH_EDITLBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_filectrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_filectrl.h
// Purpose: XML resource handler for wxFileCtrl
// Author: Kinaou Hervé
// Created: 2009-05-11
// Copyright: (c) 2009 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_FILECTRL_H_
#define _WX_XH_FILECTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_FILECTRL
class WXDLLIMPEXP_XRC wxFileCtrlXmlHandler : public wxXmlResourceHandler
{
public:
wxFileCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxFileCtrlXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_FILECTRL
#endif // _WX_XH_FILEPICKERCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_split.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_split.h
// Purpose: XRC resource for wxSplitterWindow
// Author: [email protected], Vaclav Slavik
// Created: 2003/01/26
// Copyright: (c) 2003 [email protected], Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SPLIT_H_
#define _WX_XH_SPLIT_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_SPLITTER
class WXDLLIMPEXP_XRC wxSplitterWindowXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxSplitterWindowXmlHandler);
public:
wxSplitterWindowXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_SPLITTER
#endif // _WX_XH_SPLIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_sizer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_sizer.h
// Purpose: XML resource handler for wxBoxSizer
// Author: Vaclav Slavik
// Created: 2000/04/24
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SIZER_H_
#define _WX_XH_SIZER_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
#include "wx/sizer.h"
#include "wx/gbsizer.h"
class WXDLLIMPEXP_XRC wxSizerXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxSizerXmlHandler);
public:
wxSizerXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
protected:
virtual wxSizer* DoCreateSizer(const wxString& name);
virtual bool IsSizerNode(wxXmlNode *node) const;
private:
bool m_isInside;
bool m_isGBS;
wxSizer *m_parentSizer;
wxObject* Handle_sizeritem();
wxObject* Handle_spacer();
wxObject* Handle_sizer();
wxSizer* Handle_wxBoxSizer();
#if wxUSE_STATBOX
wxSizer* Handle_wxStaticBoxSizer();
#endif
wxSizer* Handle_wxGridSizer();
wxFlexGridSizer* Handle_wxFlexGridSizer();
wxGridBagSizer* Handle_wxGridBagSizer();
wxSizer* Handle_wxWrapSizer();
bool ValidateGridSizerChildren();
void SetFlexibleMode(wxFlexGridSizer* fsizer);
void SetGrowables(wxFlexGridSizer* fsizer, const wxChar* param, bool rows);
wxGBPosition GetGBPos();
wxGBSpan GetGBSpan();
wxSizerItem* MakeSizerItem();
void SetSizerItemAttributes(wxSizerItem* sitem);
void AddSizerItem(wxSizerItem* sitem);
int GetSizerFlags();
};
#if wxUSE_BUTTON
class WXDLLIMPEXP_XRC wxStdDialogButtonSizerXmlHandler
: public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler);
public:
wxStdDialogButtonSizerXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxStdDialogButtonSizer *m_parentSizer;
};
#endif // wxUSE_BUTTON
#endif // wxUSE_XRC
#endif // _WX_XH_SIZER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_all.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_all.h
// Purpose: includes all xh_*.h files
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_ALL_H_
#define _WX_XH_ALL_H_
// Existing handlers:
#include "wx/xrc/xh_activityindicator.h"
#include "wx/xrc/xh_animatctrl.h"
#include "wx/xrc/xh_bannerwindow.h"
#include "wx/xrc/xh_bmp.h"
#include "wx/xrc/xh_bmpbt.h"
#include "wx/xrc/xh_bmpcbox.h"
#include "wx/xrc/xh_bttn.h"
#include "wx/xrc/xh_cald.h"
#include "wx/xrc/xh_chckb.h"
#include "wx/xrc/xh_chckl.h"
#include "wx/xrc/xh_choic.h"
#include "wx/xrc/xh_choicbk.h"
#include "wx/xrc/xh_clrpicker.h"
#include "wx/xrc/xh_cmdlinkbn.h"
#include "wx/xrc/xh_collpane.h"
#include "wx/xrc/xh_combo.h"
#include "wx/xrc/xh_comboctrl.h"
#include "wx/xrc/xh_datectrl.h"
#include "wx/xrc/xh_dirpicker.h"
#include "wx/xrc/xh_dlg.h"
#include "wx/xrc/xh_editlbox.h"
#include "wx/xrc/xh_filectrl.h"
#include "wx/xrc/xh_filepicker.h"
#include "wx/xrc/xh_fontpicker.h"
#include "wx/xrc/xh_frame.h"
#include "wx/xrc/xh_gauge.h"
#include "wx/xrc/xh_gdctl.h"
#include "wx/xrc/xh_grid.h"
#include "wx/xrc/xh_html.h"
#include "wx/xrc/xh_htmllbox.h"
#include "wx/xrc/xh_hyperlink.h"
#include "wx/xrc/xh_listb.h"
#include "wx/xrc/xh_listc.h"
#include "wx/xrc/xh_listbk.h"
#include "wx/xrc/xh_mdi.h"
#include "wx/xrc/xh_menu.h"
#include "wx/xrc/xh_notbk.h"
#include "wx/xrc/xh_odcombo.h"
#include "wx/xrc/xh_panel.h"
#include "wx/xrc/xh_propdlg.h"
#include "wx/xrc/xh_radbt.h"
#include "wx/xrc/xh_radbx.h"
#include "wx/xrc/xh_scrol.h"
#include "wx/xrc/xh_scwin.h"
#include "wx/xrc/xh_simplebook.h"
#include "wx/xrc/xh_sizer.h"
#include "wx/xrc/xh_slidr.h"
#include "wx/xrc/xh_spin.h"
#include "wx/xrc/xh_split.h"
#include "wx/xrc/xh_srchctrl.h"
#include "wx/xrc/xh_statbar.h"
#include "wx/xrc/xh_stbox.h"
#include "wx/xrc/xh_stbmp.h"
#include "wx/xrc/xh_sttxt.h"
#include "wx/xrc/xh_stlin.h"
#include "wx/xrc/xh_text.h"
#include "wx/xrc/xh_tglbtn.h"
#include "wx/xrc/xh_timectrl.h"
#include "wx/xrc/xh_toolb.h"
#include "wx/xrc/xh_toolbk.h"
#include "wx/xrc/xh_tree.h"
#include "wx/xrc/xh_treebk.h"
#include "wx/xrc/xh_unkwn.h"
#include "wx/xrc/xh_wizrd.h"
#endif // _WX_XH_ALL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_aui.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_aui.h
// Purpose: XRC resource handler for wxAUI
// Author: Andrea Zanellato, Steve Lamerton (wxAuiNotebook)
// Created: 2011-09-18
// Copyright: (c) 2011 wxWidgets Team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_AUI_H_
#define _WX_XH_AUI_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_AUI
#include "wx/vector.h"
class WXDLLIMPEXP_FWD_AUI wxAuiManager;
class WXDLLIMPEXP_FWD_AUI wxAuiNotebook;
class WXDLLIMPEXP_AUI wxAuiXmlHandler : public wxXmlResourceHandler
{
public:
wxAuiXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
// Returns the wxAuiManager for the specified window
wxAuiManager *GetAuiManager(wxWindow *managed) const;
private:
// Used to UnInit() the wxAuiManager before destroying its managed window
void OnManagedWindowClose(wxWindowDestroyEvent &event);
typedef wxVector<wxAuiManager*> Managers;
Managers m_managers; // all wxAuiManagers created in this handler
wxAuiManager *m_manager; // Current wxAuiManager
wxWindow *m_window; // Current managed wxWindow
wxAuiNotebook *m_notebook;
bool m_mgrInside; // Are we handling a wxAuiManager or panes inside it?
bool m_anbInside; // Are we handling a wxAuiNotebook or pages inside it?
wxDECLARE_DYNAMIC_CLASS(wxAuiXmlHandler);
};
#endif //wxUSE_XRC && wxUSE_AUI
#endif //_WX_XH_AUI_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_chckb.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_chckb.h
// Purpose: XML resource handler for wxCheckBox
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_CHCKB_H_
#define _WX_XH_CHCKB_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_CHECKBOX
class WXDLLIMPEXP_XRC wxCheckBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxCheckBoxXmlHandler);
public:
wxCheckBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_CHECKBOX
#endif // _WX_XH_CHECKBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_gdctl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_gdctl.h
// Purpose: XML resource handler for wxGenericDirCtrl
// Author: Markus Greither
// Created: 2002/01/20
// Copyright: (c) 2002 Markus Greither
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_GDCTL_H_
#define _WX_XH_GDCTL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_DIRDLG
class WXDLLIMPEXP_XRC wxGenericDirCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxGenericDirCtrlXmlHandler);
public:
wxGenericDirCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_DIRDLG
#endif // _WX_XH_GDCTL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_odcombo.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_odcombo.h
// Purpose: XML resource handler for wxOwnerDrawnComboBox
// Author: Alex Bligh - based on wx/xrc/xh_combo.h
// Created: 2006/06/19
// Copyright: (c) 2006 Alex Bligh
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_ODCOMBO_H_
#define _WX_XH_ODCOMBO_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_ODCOMBOBOX
class WXDLLIMPEXP_XRC wxOwnerDrawnComboBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxOwnerDrawnComboBoxXmlHandler);
public:
wxOwnerDrawnComboBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
wxArrayString strList;
};
#endif // wxUSE_XRC && wxUSE_ODCOMBOBOX
#endif // _WX_XH_ODCOMBO_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_tglbtn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_tglbtn.h
// Purpose: XML resource handler for wxToggleButton
// Author: Julian Smart
// Created: 2004-08-30
// Copyright: (c) 2004 Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TGLBTN_H_
#define _WX_XH_TGLBTN_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_TOGGLEBTN
class WXDLLIMPEXP_XRC wxToggleButtonXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxToggleButtonXmlHandler);
public:
wxToggleButtonXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
protected:
virtual void DoCreateToggleButton(wxObject *control);
#if !defined(__WXUNIVERSAL__) && !defined(__WXMOTIF__) && !(defined(__WXGTK__) && !defined(__WXGTK20__))
virtual void DoCreateBitmapToggleButton(wxObject *control);
#endif
};
#endif // wxUSE_XRC && wxUSE_TOGGLEBTN
#endif // _WX_XH_TGLBTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_scrol.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_scrol.h
// Purpose: XML resource handler for wxScrollBar
// Author: Brian Gavin
// Created: 2000/09/09
// Copyright: (c) 2000 Brian Gavin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SCROL_H_
#define _WX_XH_SCROL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_SCROLLBAR
class WXDLLIMPEXP_XRC wxScrollBarXmlHandler : public wxXmlResourceHandler
{
public:
wxScrollBarXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxScrollBarXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_SCROLLBAR
#endif // _WX_XH_SCROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_timectrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_timectrl.h
// Purpose: XML resource handler for wxTimePickerCtrl
// Author: Vadim Zeitlin
// Created: 2011-09-22
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TIMECTRL_H_
#define _WX_XH_TIMECTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_TIMEPICKCTRL
class WXDLLIMPEXP_XRC wxTimeCtrlXmlHandler : public wxXmlResourceHandler
{
public:
wxTimeCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxTimeCtrlXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_TIMEPICKCTRL
#endif // _WX_XH_TIMECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_cmdlinkbn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_cmdlinkbn.h
// Purpose: XML resource handler for command link buttons
// Author: Kinaou Herve
// Created: 2010-10-20
// Copyright: (c) 2010 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_CMDLINKBN_H_
#define _WX_XH_CMDLINKBN_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_COMMANDLINKBUTTON
class WXDLLIMPEXP_XRC wxCommandLinkButtonXmlHandler : public wxXmlResourceHandler
{
public:
wxCommandLinkButtonXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxCommandLinkButtonXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_COMMANDLINKBUTTON
#endif // _WX_XH_CMDLINKBN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_filepicker.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_filepicker.h
// Purpose: XML resource handler for wxFilePickerCtrl
// Author: Francesco Montorsi
// Created: 2006-04-17
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_FILEPICKERCTRL_H_
#define _WX_XH_FILEPICKERCTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_FILEPICKERCTRL
class WXDLLIMPEXP_XRC wxFilePickerCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxFilePickerCtrlXmlHandler);
public:
wxFilePickerCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_FILEPICKERCTRL
#endif // _WX_XH_FILEPICKERCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_ribbon.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_ribbon.h
// Purpose: XML resource handler for wxRibbon related classes
// Author: Armel Asselin
// Created: 2010-04-23
// Copyright: (c) 2010 Armel Asselin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XRC_XH_RIBBON_H_
#define _WX_XRC_XH_RIBBON_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_RIBBON
class WXDLLIMPEXP_FWD_RIBBON wxRibbonControl;
class WXDLLIMPEXP_RIBBON wxRibbonXmlHandler : public wxXmlResourceHandler
{
public:
wxRibbonXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
const wxClassInfo *m_isInside;
bool IsRibbonControl (wxXmlNode *node);
wxObject* Handle_buttonbar();
wxObject* Handle_button();
wxObject* Handle_control();
wxObject* Handle_page();
wxObject* Handle_gallery();
wxObject* Handle_galleryitem();
wxObject* Handle_panel();
wxObject* Handle_bar();
void Handle_RibbonArtProvider(wxRibbonControl *control);
wxDECLARE_DYNAMIC_CLASS(wxRibbonXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_RIBBON
#endif // _WX_XRC_XH_RIBBON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_chckl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_chckl.h
// Purpose: XML resource handler for wxCheckListBox
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_CHCKL_H_
#define _WX_XH_CHCKL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_CHECKLISTBOX
class WXDLLIMPEXP_XRC wxCheckListBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxCheckListBoxXmlHandler);
public:
wxCheckListBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
wxArrayString strList;
};
#endif // wxUSE_XRC && wxUSE_CHECKLISTBOX
#endif // _WX_XH_CHECKLIST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_listc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_listc.h
// Purpose: XML resource handler for wxListCtrl
// Author: Brian Gavin
// Created: 2000/09/09
// Copyright: (c) 2000 Brian Gavin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_LISTC_H_
#define _WX_XH_LISTC_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_LISTCTRL
class WXDLLIMPEXP_FWD_CORE wxListCtrl;
class WXDLLIMPEXP_FWD_CORE wxListItem;
class WXDLLIMPEXP_XRC wxListCtrlXmlHandler : public wxXmlResourceHandler
{
public:
wxListCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
// handlers for wxListCtrl itself and its listcol and listitem children
wxListCtrl *HandleListCtrl();
void HandleListCol();
void HandleListItem();
// common part to HandleList{Col,Item}()
void HandleCommonItemAttrs(wxListItem& item);
// gets the items image index in the corresponding image list (normal if
// which is wxIMAGE_LIST_NORMAL or small if it is wxIMAGE_LIST_SMALL)
long GetImageIndex(wxListCtrl *listctrl, int which);
wxDECLARE_DYNAMIC_CLASS(wxListCtrlXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_LISTCTRL
#endif // _WX_XH_LISTC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_unkwn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_unkwn.h
// Purpose: XML resource handler for unknown widget
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_UNKWN_H_
#define _WX_XH_UNKWN_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
class WXDLLIMPEXP_XRC wxUnknownWidgetXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxUnknownWidgetXmlHandler);
public:
wxUnknownWidgetXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC
#endif // _WX_XH_UNKWN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_listb.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_listb.h
// Purpose: XML resource handler for wxListbox
// Author: Bob Mitchell & Vaclav Slavik
// Created: 2000/07/29
// Copyright: (c) 2000 Bob Mitchell & Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_LISTB_H_
#define _WX_XH_LISTB_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_LISTBOX
class WXDLLIMPEXP_XRC wxListBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxListBoxXmlHandler);
public:
wxListBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
wxArrayString strList;
};
#endif // wxUSE_XRC && wxUSE_LISTBOX
#endif // _WX_XH_LISTB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_mdi.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_mdi.h
// Purpose: XML resource handler for wxMDI
// Author: David M. Falkinder & Vaclav Slavik
// Created: 14/02/2005
// Copyright: (c) 2005 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_MDI_H_
#define _WX_XH_MDI_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_MDI
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_XRC wxMdiXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxMdiXmlHandler);
public:
wxMdiXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxWindow *CreateFrame();
};
#endif // wxUSE_XRC && wxUSE_MDI
#endif // _WX_XH_MDI_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_simplebook.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_simplebook.h
// Purpose: XML resource handler for wxSimplebook
// Author: Vadim Zeitlin
// Created: 2014-08-05
// Copyright: (c) 2014 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SIMPLEBOOK_H_
#define _WX_XH_SIMPLEBOOK_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_BOOKCTRL
class wxSimplebook;
class WXDLLIMPEXP_XRC wxSimplebookXmlHandler : public wxXmlResourceHandler
{
public:
wxSimplebookXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxSimplebook *m_simplebook;
wxDECLARE_DYNAMIC_CLASS(wxSimplebookXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_BOOKCTRL
#endif // _WX_XH_SIMPLEBOOK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_animatctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_animatctrl.h
// Purpose: XML resource handler for wxAnimationCtrl
// Author: Francesco Montorsi
// Created: 2006-10-15
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_ANIMATIONCTRL_H_
#define _WX_XH_ANIMATIONCTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_ANIMATIONCTRL
class WXDLLIMPEXP_XRC wxAnimationCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxAnimationCtrlXmlHandler);
public:
wxAnimationCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_ANIMATIONCTRL
#endif // _WX_XH_ANIMATIONCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_sttxt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_sttxt.h
// Purpose: XML resource handler for wxStaticText
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_STTXT_H_
#define _WX_XH_STTXT_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_STATTEXT
class WXDLLIMPEXP_XRC wxStaticTextXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxStaticTextXmlHandler);
public:
wxStaticTextXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_STATTEXT
#endif // _WX_XH_STTXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_statbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_statbar.h
// Purpose: XML resource handler for wxStatusBar
// Author: Brian Ravnsgaard Riis
// Created: 2004/01/21
// Copyright: (c) 2004 Brian Ravnsgaard Riis
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_STATBAR_H_
#define _WX_XH_STATBAR_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_STATUSBAR
class WXDLLIMPEXP_XRC wxStatusBarXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxStatusBarXmlHandler);
public:
wxStatusBarXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_STATUSBAR
#endif // _WX_XH_STATBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_radbt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_radbt.h
// Purpose: XML resource handler for wxRadioButton
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_RADBT_H_
#define _WX_XH_RADBT_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_RADIOBTN
class WXDLLIMPEXP_XRC wxRadioButtonXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxRadioButtonXmlHandler);
public:
wxRadioButtonXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_RADIOBOX
#endif // _WX_XH_RADBT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_spin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_spin.h
// Purpose: XML resource handler for wxSpinButton, wxSpinCtrl, wxSpinCtrlDouble
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SPIN_H_
#define _WX_XH_SPIN_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
#if wxUSE_SPINBTN
class WXDLLIMPEXP_XRC wxSpinButtonXmlHandler : public wxXmlResourceHandler
{
public:
wxSpinButtonXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxSpinButtonXmlHandler);
};
#endif // wxUSE_SPINBTN
#if wxUSE_SPINCTRL
class WXDLLIMPEXP_XRC wxSpinCtrlXmlHandler : public wxXmlResourceHandler
{
public:
wxSpinCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxSpinCtrlXmlHandler);
};
class WXDLLIMPEXP_XRC wxSpinCtrlDoubleXmlHandler : public wxXmlResourceHandler
{
public:
wxSpinCtrlDoubleXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxSpinCtrlDoubleXmlHandler);
};
#endif // wxUSE_SPINCTRL
#endif // wxUSE_XRC
#endif // _WX_XH_SPIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_clrpicker.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_clrpicker.h
// Purpose: XML resource handler for wxColourPickerCtrl
// Author: Francesco Montorsi
// Created: 2006-04-17
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_CLRPICKERCTRL_H_
#define _WX_XH_CLRPICKERCTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_COLOURPICKERCTRL
class WXDLLIMPEXP_XRC wxColourPickerCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxColourPickerCtrlXmlHandler);
public:
wxColourPickerCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_COLOURPICKERCTRL
#endif // _WX_XH_CLRPICKERCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_gauge.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_gauge.h
// Purpose: XML resource handler for wxGauge
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_GAUGE_H_
#define _WX_XH_GAUGE_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_GAUGE
class WXDLLIMPEXP_XRC wxGaugeXmlHandler : public wxXmlResourceHandler
{
public:
wxGaugeXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxGaugeXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_GAUGE
#endif // _WX_XH_GAUGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xmlreshandler.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xmlreshandler.cpp
// Purpose: XML resource handler
// Author: Steven Lamerton
// Created: 2011/01/26
// Copyright: (c) 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XRC_XMLRESHANDLER_H_
#define _WX_XRC_XMLRESHANDLER_H_
#include "wx/defs.h"
#if wxUSE_XRC
#include "wx/string.h"
#include "wx/artprov.h"
#include "wx/colour.h"
#include "wx/filesys.h"
#include "wx/imaglist.h"
#include "wx/window.h"
class WXDLLIMPEXP_FWD_CORE wxAnimation;
class WXDLLIMPEXP_FWD_XML wxXmlNode;
class WXDLLIMPEXP_FWD_XML wxXmlResource;
class WXDLLIMPEXP_FWD_CORE wxXmlResourceHandler;
// Helper macro used by the classes derived from wxXmlResourceHandler but also
// by wxXmlResourceHandler implementation itself.
#define XRC_ADD_STYLE(style) AddStyle(wxT(#style), style)
// Flags for GetNodeText().
enum
{
wxXRC_TEXT_NO_TRANSLATE = 1,
wxXRC_TEXT_NO_ESCAPE = 2
};
// Abstract base class for the implementation object used by
// wxXmlResourceHandlerImpl. The real implementation is in
// wxXmlResourceHandlerImpl class in the "xrc" library while this class is in
// the "core" itself -- but it is so small that it doesn't matter.
class WXDLLIMPEXP_CORE wxXmlResourceHandlerImplBase : public wxObject
{
public:
// Constructor.
wxXmlResourceHandlerImplBase(wxXmlResourceHandler *handler)
: m_handler(handler)
{}
// Destructor.
virtual ~wxXmlResourceHandlerImplBase() {}
virtual wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
wxObject *instance) = 0;
virtual bool IsOfClass(wxXmlNode *node, const wxString& classname) const = 0;
virtual bool IsObjectNode(const wxXmlNode *node) const = 0;
virtual wxString GetNodeContent(const wxXmlNode *node) = 0;
virtual wxXmlNode *GetNodeParent(const wxXmlNode *node) const = 0;
virtual wxXmlNode *GetNodeNext(const wxXmlNode *node) const = 0;
virtual wxXmlNode *GetNodeChildren(const wxXmlNode *node) const = 0;
virtual bool HasParam(const wxString& param) = 0;
virtual wxXmlNode *GetParamNode(const wxString& param) = 0;
virtual wxString GetParamValue(const wxString& param) = 0;
virtual wxString GetParamValue(const wxXmlNode* node) = 0;
virtual int GetStyle(const wxString& param = wxT("style"), int defaults = 0) = 0;
virtual wxString GetNodeText(const wxXmlNode *node, int flags = 0) = 0;
virtual int GetID() = 0;
virtual wxString GetName() = 0;
virtual bool GetBool(const wxString& param, bool defaultv = false) = 0;
virtual long GetLong(const wxString& param, long defaultv = 0) = 0;
virtual float GetFloat(const wxString& param, float defaultv = 0) = 0;
virtual wxColour GetColour(const wxString& param,
const wxColour& defaultv = wxNullColour) = 0;
virtual wxSize GetSize(const wxString& param = wxT("size"),
wxWindow *windowToUse = NULL) = 0;
virtual wxPoint GetPosition(const wxString& param = wxT("pos")) = 0;
virtual wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
wxWindow *windowToUse = NULL) = 0;
virtual wxSize GetPairInts(const wxString& param) = 0;
virtual wxDirection GetDirection(const wxString& param, wxDirection dir = wxLEFT) = 0;
virtual wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) = 0;
virtual wxBitmap GetBitmap(const wxXmlNode* node,
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) = 0;
virtual wxIcon GetIcon(const wxString& param = wxT("icon"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) = 0;
virtual wxIcon GetIcon(const wxXmlNode* node,
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize) = 0;
virtual wxIconBundle GetIconBundle(const wxString& param,
const wxArtClient& defaultArtClient = wxART_OTHER) = 0;
virtual wxImageList *GetImageList(const wxString& param = wxT("imagelist")) = 0;
#if wxUSE_ANIMATIONCTRL
virtual wxAnimation* GetAnimation(const wxString& param = wxT("animation")) = 0;
#endif
virtual wxFont GetFont(const wxString& param = wxT("font"), wxWindow* parent = NULL) = 0;
virtual bool GetBoolAttr(const wxString& attr, bool defaultv) = 0;
virtual void SetupWindow(wxWindow *wnd) = 0;
virtual void CreateChildren(wxObject *parent, bool this_hnd_only = false) = 0;
virtual void CreateChildrenPrivately(wxObject *parent,
wxXmlNode *rootnode = NULL) = 0;
virtual wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent,
wxObject *instance = NULL) = 0;
#if wxUSE_FILESYSTEM
virtual wxFileSystem& GetCurFileSystem() = 0;
#endif
virtual void ReportError(wxXmlNode *context, const wxString& message) = 0;
virtual void ReportError(const wxString& message) = 0;
virtual void ReportParamError(const wxString& param, const wxString& message) = 0;
wxXmlResourceHandler* GetHandler() { return m_handler; }
protected:
wxXmlResourceHandler *m_handler;
};
// Base class for all XRC handlers.
//
// Notice that this class is defined in the core library itself and so can be
// used as the base class by classes in any GUI library. However to actually be
// usable, it needs to be registered with wxXmlResource which implies linking
// the application with the xrc library.
//
// Also note that all the methods forwarding to GetImpl() are documented only
// in wxXmlResourceHandlerImpl in wx/xrc/xmlres.h to avoid duplication.
class WXDLLIMPEXP_CORE wxXmlResourceHandler : public wxObject
{
public:
// Constructor creates an unusable object, before anything can be done with
// it, SetImpl() needs to be called as done by wxXmlResource::AddHandler().
wxXmlResourceHandler()
{
m_node = NULL;
m_parent =
m_instance = NULL;
m_parentAsWindow = NULL;
m_resource = NULL;
m_impl = NULL;
}
// This should be called exactly once.
void SetImpl(wxXmlResourceHandlerImplBase* impl)
{
wxASSERT_MSG( !m_impl, wxS("Should be called exactly once") );
m_impl = impl;
}
// Destructor.
virtual ~wxXmlResourceHandler()
{
delete m_impl;
}
wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
wxObject *instance)
{
return GetImpl()->CreateResource(node, parent, instance);
}
// This one is called from CreateResource after variables
// were filled.
virtual wxObject *DoCreateResource() = 0;
// Returns true if it understands this node and can create
// a resource from it, false otherwise.
virtual bool CanHandle(wxXmlNode *node) = 0;
void SetParentResource(wxXmlResource *res)
{
m_resource = res;
}
// These methods are not forwarded to wxXmlResourceHandlerImpl because they
// are called from the derived classes ctors and so before SetImpl() can be
// called.
// Add a style flag (e.g. wxMB_DOCKABLE) to the list of flags
// understood by this handler.
void AddStyle(const wxString& name, int value);
// Add styles common to all wxWindow-derived classes.
void AddWindowStyles();
protected:
// Everything else is simply forwarded to wxXmlResourceHandlerImpl.
void ReportError(wxXmlNode *context, const wxString& message)
{
GetImpl()->ReportError(context, message);
}
void ReportError(const wxString& message)
{
GetImpl()->ReportError(message);
}
void ReportParamError(const wxString& param, const wxString& message)
{
GetImpl()->ReportParamError(param, message);
}
bool IsOfClass(wxXmlNode *node, const wxString& classname) const
{
return GetImpl()->IsOfClass(node, classname);
}
bool IsObjectNode(const wxXmlNode *node) const
{
return GetImpl()->IsObjectNode(node);
}
wxString GetNodeContent(const wxXmlNode *node)
{
return GetImpl()->GetNodeContent(node);
}
wxXmlNode *GetNodeParent(const wxXmlNode *node) const
{
return GetImpl()->GetNodeParent(node);
}
wxXmlNode *GetNodeNext(const wxXmlNode *node) const
{
return GetImpl()->GetNodeNext(node);
}
wxXmlNode *GetNodeChildren(const wxXmlNode *node) const
{
return GetImpl()->GetNodeChildren(node);
}
bool HasParam(const wxString& param)
{
return GetImpl()->HasParam(param);
}
wxXmlNode *GetParamNode(const wxString& param)
{
return GetImpl()->GetParamNode(param);
}
wxString GetParamValue(const wxString& param)
{
return GetImpl()->GetParamValue(param);
}
wxString GetParamValue(const wxXmlNode* node)
{
return GetImpl()->GetParamValue(node);
}
int GetStyle(const wxString& param = wxT("style"), int defaults = 0)
{
return GetImpl()->GetStyle(param, defaults);
}
wxString GetNodeText(const wxXmlNode *node, int flags = 0)
{
return GetImpl()->GetNodeText(node, flags);
}
wxString GetText(const wxString& param, bool translate = true)
{
return GetImpl()->GetNodeText(GetImpl()->GetParamNode(param),
translate ? 0 : wxXRC_TEXT_NO_TRANSLATE);
}
int GetID() const
{
return GetImpl()->GetID();
}
wxString GetName()
{
return GetImpl()->GetName();
}
bool GetBool(const wxString& param, bool defaultv = false)
{
return GetImpl()->GetBool(param, defaultv);
}
long GetLong(const wxString& param, long defaultv = 0)
{
return GetImpl()->GetLong(param, defaultv);
}
float GetFloat(const wxString& param, float defaultv = 0)
{
return GetImpl()->GetFloat(param, defaultv);
}
wxColour GetColour(const wxString& param,
const wxColour& defaultv = wxNullColour)
{
return GetImpl()->GetColour(param, defaultv);
}
wxSize GetSize(const wxString& param = wxT("size"),
wxWindow *windowToUse = NULL)
{
return GetImpl()->GetSize(param, windowToUse);
}
wxPoint GetPosition(const wxString& param = wxT("pos"))
{
return GetImpl()->GetPosition(param);
}
wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
wxWindow *windowToUse = NULL)
{
return GetImpl()->GetDimension(param, defaultv, windowToUse);
}
wxSize GetPairInts(const wxString& param)
{
return GetImpl()->GetPairInts(param);
}
wxDirection GetDirection(const wxString& param, wxDirection dir = wxLEFT)
{
return GetImpl()->GetDirection(param, dir);
}
wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize)
{
return GetImpl()->GetBitmap(param, defaultArtClient, size);
}
wxBitmap GetBitmap(const wxXmlNode* node,
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize)
{
return GetImpl()->GetBitmap(node, defaultArtClient, size);
}
wxIcon GetIcon(const wxString& param = wxT("icon"),
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize)
{
return GetImpl()->GetIcon(param, defaultArtClient, size);
}
wxIcon GetIcon(const wxXmlNode* node,
const wxArtClient& defaultArtClient = wxART_OTHER,
wxSize size = wxDefaultSize)
{
return GetImpl()->GetIcon(node, defaultArtClient, size);
}
wxIconBundle GetIconBundle(const wxString& param,
const wxArtClient& defaultArtClient = wxART_OTHER)
{
return GetImpl()->GetIconBundle(param, defaultArtClient);
}
wxImageList *GetImageList(const wxString& param = wxT("imagelist"))
{
return GetImpl()->GetImageList(param);
}
#if wxUSE_ANIMATIONCTRL
wxAnimation* GetAnimation(const wxString& param = wxT("animation"))
{
return GetImpl()->GetAnimation(param);
}
#endif
wxFont GetFont(const wxString& param = wxT("font"),
wxWindow* parent = NULL)
{
return GetImpl()->GetFont(param, parent);
}
bool GetBoolAttr(const wxString& attr, bool defaultv)
{
return GetImpl()->GetBoolAttr(attr, defaultv);
}
void SetupWindow(wxWindow *wnd)
{
GetImpl()->SetupWindow(wnd);
}
void CreateChildren(wxObject *parent, bool this_hnd_only = false)
{
GetImpl()->CreateChildren(parent, this_hnd_only);
}
void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL)
{
GetImpl()->CreateChildrenPrivately(parent, rootnode);
}
wxObject *CreateResFromNode(wxXmlNode *node,
wxObject *parent, wxObject *instance = NULL)
{
return GetImpl()->CreateResFromNode(node, parent, instance);
}
#if wxUSE_FILESYSTEM
wxFileSystem& GetCurFileSystem()
{
return GetImpl()->GetCurFileSystem();
}
#endif
// Variables (filled by CreateResource)
wxXmlNode *m_node;
wxString m_class;
wxObject *m_parent, *m_instance;
wxWindow *m_parentAsWindow;
wxXmlResource *m_resource;
// provide method access to those member variables
wxXmlResource* GetResource() const { return m_resource; }
wxXmlNode* GetNode() const { return m_node; }
wxString GetClass() const { return m_class; }
wxObject* GetParent() const { return m_parent; }
wxObject* GetInstance() const { return m_instance; }
wxWindow* GetParentAsWindow() const { return m_parentAsWindow; }
wxArrayString m_styleNames;
wxArrayInt m_styleValues;
friend class wxXmlResourceHandlerImpl;
private:
// This is supposed to never return NULL because SetImpl() should have been
// called.
wxXmlResourceHandlerImplBase* GetImpl() const;
wxXmlResourceHandlerImplBase *m_impl;
wxDECLARE_ABSTRACT_CLASS(wxXmlResourceHandler);
};
#endif // wxUSE_XRC
#endif // _WX_XRC_XMLRESHANDLER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_bmpcbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_bmpcbox.h
// Purpose: XML resource handler for wxBitmapComboBox
// Author: Jaakko Salli
// Created: Sep-10-2006
// Copyright: (c) 2006 Jaakko Salli
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_BMPCBOX_H_
#define _WX_XH_BMPCBOX_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_BITMAPCOMBOBOX
class WXDLLIMPEXP_FWD_CORE wxBitmapComboBox;
class WXDLLIMPEXP_XRC wxBitmapComboBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxBitmapComboBoxXmlHandler);
public:
wxBitmapComboBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxBitmapComboBox* m_combobox;
bool m_isInside;
};
#endif // wxUSE_XRC && wxUSE_BITMAPCOMBOBOX
#endif // _WX_XH_BMPCBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_htmllbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_htmllbox.h
// Purpose: XML resource handler for wxSimpleHtmlListBox
// Author: Francesco Montorsi
// Created: 2006/10/21
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SIMPLEHTMLLISTBOX_H_
#define _WX_XH_SIMPLEHTMLLISTBOX_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_HTML
class WXDLLIMPEXP_XRC wxSimpleHtmlListBoxXmlHandler : public wxXmlResourceHandler
{
public:
wxSimpleHtmlListBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
wxArrayString strList;
wxDECLARE_DYNAMIC_CLASS(wxSimpleHtmlListBoxXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_HTML
#endif // _WX_XH_SIMPLEHTMLLISTBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_toolbk.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_toolbk.h
// Purpose: XML resource handler for wxToolbook
// Author: Andrea Zanellato
// Created: 2009/12/12
// Copyright: (c) 2010 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_TOOLBK_H_
#define _WX_XH_TOOLBK_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_TOOLBOOK
class WXDLLIMPEXP_FWD_CORE wxToolbook;
class WXDLLIMPEXP_XRC wxToolbookXmlHandler : public wxXmlResourceHandler
{
public:
wxToolbookXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxToolbook *m_toolbook;
wxDECLARE_DYNAMIC_CLASS(wxToolbookXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_TOOLBOOK
#endif // _WX_XH_TOOLBK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_hyperlink.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_hyperlink.h
// Purpose: Hyperlink control (wxAdv)
// Author: David Norris <[email protected]>
// Modified by: Ryan Norton, Francesco Montorsi
// Created: 04/02/2005
// Copyright: (c) 2005 David Norris
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_HYPERLINKH__
#define _WX_XH_HYPERLINKH__
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_HYPERLINKCTRL
class WXDLLIMPEXP_XRC wxHyperlinkCtrlXmlHandler : public wxXmlResourceHandler
{
// Register with wxWindows' dynamic class subsystem.
wxDECLARE_DYNAMIC_CLASS(wxHyperlinkCtrlXmlHandler);
public:
// Constructor.
wxHyperlinkCtrlXmlHandler();
// Creates the control and returns a pointer to it.
virtual wxObject *DoCreateResource() wxOVERRIDE;
// Returns true if we know how to create a control for the given node.
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_HYPERLINKCTRL
#endif // _WX_XH_HYPERLINKH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_listbk.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_listbk.h
// Purpose: XML resource handler for wxListbook
// Author: Vaclav Slavik
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_LISTBK_H_
#define _WX_XH_LISTBK_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_LISTBOOK
class WXDLLIMPEXP_FWD_CORE wxListbook;
class WXDLLIMPEXP_XRC wxListbookXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxListbookXmlHandler);
public:
wxListbookXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxListbook *m_listbook;
};
#endif // wxUSE_XRC && wxUSE_LISTBOOK
#endif // _WX_XH_LISTBK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_radbx.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_radbx.h
// Purpose: XML resource handler for wxRadioBox
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_RADBX_H_
#define _WX_XH_RADBX_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_RADIOBOX
class WXDLLIMPEXP_XRC wxRadioBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxRadioBoxXmlHandler);
public:
wxRadioBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
// the items labels
wxArrayString m_labels;
#if wxUSE_TOOLTIPS
// the items tooltips
wxArrayString m_tooltips;
#endif // wxUSE_TOOLTIPS
// the item help text
wxArrayString m_helptexts;
wxArrayInt m_helptextSpecified;
// if the corresponding array element is 1, the radiobox item is
// disabled/hidden
wxArrayInt m_isEnabled,
m_isShown;
};
#endif // wxUSE_XRC && wxUSE_RADIOBOX
#endif // _WX_XH_RADBX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_richtext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_richtext.h
// Purpose: XML resource handler for wxRichTextCtrl
// Author: Julian Smart
// Created: 2006-11-08
// Copyright: (c) 2006 Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_RICHTEXT_H_
#define _WX_XH_RICHTEXT_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_RICHTEXT
class WXDLLIMPEXP_RICHTEXT wxRichTextCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxRichTextCtrlXmlHandler);
public:
wxRichTextCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_RICHTEXT
#endif // _WX_XH_RICHTEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_fontpicker.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_fontpicker.h
// Purpose: XML resource handler for wxFontPickerCtrl
// Author: Francesco Montorsi
// Created: 2006-04-17
// Copyright: (c) 2006 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_FONTPICKERCTRL_H_
#define _WX_XH_FONTPICKERCTRL_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_FONTPICKERCTRL
class WXDLLIMPEXP_XRC wxFontPickerCtrlXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxFontPickerCtrlXmlHandler);
public:
wxFontPickerCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_FONTPICKERCTRL
#endif // _WX_XH_FONTPICKERCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_stbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_stbox.h
// Purpose: XML resource handler for wxStaticBox
// Author: Brian Gavin
// Created: 2000/09/00
// Copyright: (c) 2000 Brian Gavin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_STBOX_H_
#define _WX_XH_STBOX_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_STATBOX
class WXDLLIMPEXP_XRC wxStaticBoxXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxStaticBoxXmlHandler);
public:
wxStaticBoxXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_STATBOX
#endif // _WX_XH_STBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_wizrd.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_wizrd.h
// Purpose: XML resource handler for wxWizard
// Author: Vaclav Slavik
// Created: 2003/03/02
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_WIZRD_H_
#define _WX_XH_WIZRD_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_WIZARDDLG
class WXDLLIMPEXP_FWD_CORE wxWizard;
class WXDLLIMPEXP_FWD_CORE wxWizardPageSimple;
class WXDLLIMPEXP_XRC wxWizardXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxWizardXmlHandler);
public:
wxWizardXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
wxWizard *m_wizard;
wxWizardPageSimple *m_lastSimplePage;
};
#endif // wxUSE_XRC && wxUSE_WIZARDDLG
#endif // _WX_XH_WIZRD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_choic.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_choic.h
// Purpose: XML resource handler for wxChoice
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_CHOIC_H_
#define _WX_XH_CHOIC_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_CHOICE
class WXDLLIMPEXP_XRC wxChoiceXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxChoiceXmlHandler);
public:
wxChoiceXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideBox;
wxArrayString strList;
};
#endif // wxUSE_XRC && wxUSE_CHOICE
#endif // _WX_XH_CHOIC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_html.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_html.h
// Purpose: XML resource handler for wxHtmlWindow
// Author: Bob Mitchell
// Created: 2000/03/21
// Copyright: (c) 2000 Bob Mitchell and Verant Interactive
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_HTML_H_
#define _WX_XH_HTML_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_HTML
class WXDLLIMPEXP_XRC wxHtmlWindowXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxHtmlWindowXmlHandler);
public:
wxHtmlWindowXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_HTML
#endif // _WX_XH_HTML_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_choicbk.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_choicbk.h
// Purpose: XML resource handler for wxChoicebook
// Author: Vaclav Slavik
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_CHOICEBK_H_
#define _WX_XH_CHOICEBK_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_CHOICEBOOK
class WXDLLIMPEXP_FWD_CORE wxChoicebook;
class WXDLLIMPEXP_XRC wxChoicebookXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxChoicebookXmlHandler);
public:
wxChoicebookXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxChoicebook *m_choicebook;
};
#endif // wxUSE_XRC && wxUSE_CHOICEBOOK
#endif // _WX_XH_CHOICEBK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_bttn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_bttn.h
// Purpose: XML resource handler for buttons
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_BTTN_H_
#define _WX_XH_BTTN_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_BUTTON
class WXDLLIMPEXP_XRC wxButtonXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxButtonXmlHandler);
public:
wxButtonXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_BUTTON
#endif // _WX_XH_BTTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_auitoolb.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_toolb.h
// Purpose: XML resource handler for wxAuiToolBar
// Author: Rodolphe Suescun
// Created: 2013-11-23
// Copyright: (c) 2013 Rodolphe Suescun
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_AUITOOLB_H_
#define _WX_XH_AUITOOLB_H_
#include "wx/aui/auibar.h"
#include "wx/menu.h"
#include "wx/vector.h"
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_AUI
class WXDLLIMPEXP_FWD_AUI wxAuiToolBar;
class WXDLLIMPEXP_AUI wxAuiToolBarXmlHandler : public wxXmlResourceHandler
{
public:
wxAuiToolBarXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxAuiToolBar *m_toolbar;
wxSize m_toolSize;
class MenuHandler : public wxEvtHandler
{
public:
void OnDropDown(wxAuiToolBarEvent& event);
unsigned RegisterMenu(wxAuiToolBar *toobar, int id, wxMenu *menu);
private:
wxVector<wxMenu*> m_menus;
};
MenuHandler m_menuHandler;
wxDECLARE_DYNAMIC_CLASS(wxAuiToolBarXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_AUI
#endif // _WX_XH_AUITOOLB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_menu.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_menu.h
// Purpose: XML resource handler for menus/menubars
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_MENU_H_
#define _WX_XH_MENU_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_MENUS
class WXDLLIMPEXP_XRC wxMenuXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxMenuXmlHandler);
public:
wxMenuXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_insideMenu;
};
class WXDLLIMPEXP_XRC wxMenuBarXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxMenuBarXmlHandler);
public:
wxMenuBarXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC && wxUSE_MENUS
#endif // _WX_XH_MENU_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_propdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_propdlg.h
// Purpose: XML resource handler for wxPropertySheetDialog
// Author: Sander Berents
// Created: 2007/07/12
// Copyright: (c) 2007 Sander Berents
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_PROPDLG_H_
#define _WX_XH_PROPDLG_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
class WXDLLIMPEXP_FWD_CORE wxPropertySheetDialog;
class WXDLLIMPEXP_XRC wxPropertySheetDialogXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxPropertySheetDialogXmlHandler);
public:
wxPropertySheetDialogXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
private:
bool m_isInside;
wxPropertySheetDialog *m_dialog;
};
#endif // wxUSE_XRC
#endif // _WX_XH_PROPDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_srchctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_srchctl.h
// Purpose: XRC resource handler for wxSearchCtrl
// Author: Sander Berents
// Created: 2007/07/12
// Copyright: (c) 2007 Sander Berents
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_SRCH_H_
#define _WX_XH_SRCH_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC && wxUSE_SEARCHCTRL
class WXDLLIMPEXP_XRC wxSearchCtrlXmlHandler : public wxXmlResourceHandler
{
public:
wxSearchCtrlXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxSearchCtrlXmlHandler);
};
#endif // wxUSE_XRC && wxUSE_SEARCHCTRL
#endif // _WX_XH_SRCH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/xrc/xh_bmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xrc/xh_bmp.h
// Purpose: XML resource handler for wxBitmap and wxIcon
// Author: Vaclav Slavik
// Created: 2000/09/00
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XH_BMP_H_
#define _WX_XH_BMP_H_
#include "wx/xrc/xmlres.h"
#if wxUSE_XRC
class WXDLLIMPEXP_XRC wxBitmapXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxBitmapXmlHandler);
public:
wxBitmapXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
class WXDLLIMPEXP_XRC wxIconXmlHandler : public wxXmlResourceHandler
{
wxDECLARE_DYNAMIC_CLASS(wxIconXmlHandler);
public:
wxIconXmlHandler();
virtual wxObject *DoCreateResource() wxOVERRIDE;
virtual bool CanHandle(wxXmlNode *node) wxOVERRIDE;
};
#endif // wxUSE_XRC
#endif // _WX_XH_BMP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/persist/toplevel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/persist/toplevel.h
// Purpose: persistence support for wxTLW
// Author: Vadim Zeitlin
// Created: 2009-01-19
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PERSIST_TOPLEVEL_H_
#define _WX_PERSIST_TOPLEVEL_H_
#include "wx/persist/window.h"
#include "wx/toplevel.h"
// ----------------------------------------------------------------------------
// string constants used by wxPersistentTLW
// ----------------------------------------------------------------------------
// we use just "Window" to keep configuration files and such short, there
// should be no confusion with wxWindow itself as we don't have persistent
// windows, just persistent controls which have their own specific kind strings
#define wxPERSIST_TLW_KIND "Window"
// ----------------------------------------------------------------------------
// wxPersistentTLW: supports saving/restoring window position and size as well
// as maximized/iconized/restore state
// ----------------------------------------------------------------------------
class wxPersistentTLW : public wxPersistentWindow<wxTopLevelWindow>,
private wxTopLevelWindow::GeometrySerializer
{
public:
wxPersistentTLW(wxTopLevelWindow *tlw)
: wxPersistentWindow<wxTopLevelWindow>(tlw)
{
}
virtual void Save() const wxOVERRIDE
{
const wxTopLevelWindow * const tlw = Get();
tlw->SaveGeometry(*this);
}
virtual bool Restore() wxOVERRIDE
{
wxTopLevelWindow * const tlw = Get();
return tlw->RestoreToGeometry(*this);
}
virtual wxString GetKind() const wxOVERRIDE { return wxPERSIST_TLW_KIND; }
private:
virtual bool SaveField(const wxString& name, int value) const wxOVERRIDE
{
return SaveValue(name, value);
}
virtual bool RestoreField(const wxString& name, int* value) wxOVERRIDE
{
return RestoreValue(name, value);
}
};
inline wxPersistentObject *wxCreatePersistentObject(wxTopLevelWindow *tlw)
{
return new wxPersistentTLW(tlw);
}
#endif // _WX_PERSIST_TOPLEVEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/persist/treebook.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/persist/treebook.h
// Purpose: persistence support for wxBookCtrl
// Author: Vadim Zeitlin
// Created: 2009-01-19
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PERSIST_TREEBOOK_H_
#define _WX_PERSIST_TREEBOOK_H_
#include "wx/persist/bookctrl.h"
#include "wx/arrstr.h"
#include "wx/treebook.h"
// ----------------------------------------------------------------------------
// string constants used by wxPersistentTreeBookCtrl
// ----------------------------------------------------------------------------
#define wxPERSIST_TREEBOOK_KIND "TreeBook"
// this key contains the indices of all expanded nodes in the tree book
// separated by wxPERSIST_TREEBOOK_EXPANDED_SEP
#define wxPERSIST_TREEBOOK_EXPANDED_BRANCHES "Expanded"
#define wxPERSIST_TREEBOOK_EXPANDED_SEP ','
// ----------------------------------------------------------------------------
// wxPersistentTreeBookCtrl: supports saving/restoring open tree branches
// ----------------------------------------------------------------------------
class wxPersistentTreeBookCtrl : public wxPersistentBookCtrl
{
public:
wxPersistentTreeBookCtrl(wxTreebook *book)
: wxPersistentBookCtrl(book)
{
}
virtual void Save() const wxOVERRIDE
{
const wxTreebook * const book = GetTreeBook();
wxString expanded;
const size_t count = book->GetPageCount();
for ( size_t n = 0; n < count; n++ )
{
if ( book->IsNodeExpanded(n) )
{
if ( !expanded.empty() )
expanded += wxPERSIST_TREEBOOK_EXPANDED_SEP;
expanded += wxString::Format("%u", static_cast<unsigned>(n));
}
}
SaveValue(wxPERSIST_TREEBOOK_EXPANDED_BRANCHES, expanded);
wxPersistentBookCtrl::Save();
}
virtual bool Restore() wxOVERRIDE
{
wxTreebook * const book = GetTreeBook();
wxString expanded;
if ( RestoreValue(wxPERSIST_TREEBOOK_EXPANDED_BRANCHES, &expanded) )
{
const wxArrayString
indices(wxSplit(expanded, wxPERSIST_TREEBOOK_EXPANDED_SEP));
const size_t pageCount = book->GetPageCount();
const size_t count = indices.size();
for ( size_t n = 0; n < count; n++ )
{
unsigned long idx;
if ( indices[n].ToULong(&idx) && idx < pageCount )
book->ExpandNode(idx);
}
}
return wxPersistentBookCtrl::Restore();
}
virtual wxString GetKind() const wxOVERRIDE { return wxPERSIST_TREEBOOK_KIND; }
wxTreebook *GetTreeBook() const { return static_cast<wxTreebook *>(Get()); }
};
inline wxPersistentObject *wxCreatePersistentObject(wxTreebook *book)
{
return new wxPersistentTreeBookCtrl(book);
}
#endif // _WX_PERSIST_TREEBOOK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/persist/bookctrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/persist/bookctrl.h
// Purpose: persistence support for wxBookCtrl
// Author: Vadim Zeitlin
// Created: 2009-01-19
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PERSIST_BOOKCTRL_H_
#define _WX_PERSIST_BOOKCTRL_H_
#include "wx/persist/window.h"
#include "wx/bookctrl.h"
// ----------------------------------------------------------------------------
// string constants used by wxPersistentBookCtrl
// ----------------------------------------------------------------------------
#define wxPERSIST_BOOK_KIND "Book"
#define wxPERSIST_BOOK_SELECTION "Selection"
// ----------------------------------------------------------------------------
// wxPersistentBookCtrl: supports saving/restoring book control selection
// ----------------------------------------------------------------------------
class wxPersistentBookCtrl : public wxPersistentWindow<wxBookCtrlBase>
{
public:
wxPersistentBookCtrl(wxBookCtrlBase *book)
: wxPersistentWindow<wxBookCtrlBase>(book)
{
}
virtual void Save() const wxOVERRIDE
{
SaveValue(wxPERSIST_BOOK_SELECTION, Get()->GetSelection());
}
virtual bool Restore() wxOVERRIDE
{
long sel;
if ( RestoreValue(wxPERSIST_BOOK_SELECTION, &sel) )
{
wxBookCtrlBase * const book = Get();
if ( sel >= 0 && (unsigned)sel < book->GetPageCount() )
{
book->SetSelection(sel);
return true;
}
}
return false;
}
virtual wxString GetKind() const wxOVERRIDE { return wxPERSIST_BOOK_KIND; }
};
inline wxPersistentObject *wxCreatePersistentObject(wxBookCtrlBase *book)
{
return new wxPersistentBookCtrl(book);
}
#endif // _WX_PERSIST_BOOKCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/persist/dataview.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/persist/dataview.h
// Purpose: Persistence support for wxDataViewCtrl and its derivatives
// Author: wxWidgets Team
// Created: 2017-08-21
// Copyright: (c) 2017 wxWidgets.org
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PERSIST_DATAVIEW_H_
#define _WX_PERSIST_DATAVIEW_H_
#include "wx/persist/window.h"
#include "wx/dataview.h"
// ----------------------------------------------------------------------------
// String constants used by wxPersistentDataViewCtrl.
// ----------------------------------------------------------------------------
#define wxPERSIST_DVC_KIND "DataView"
#define wxPERSIST_DVC_HIDDEN "Hidden"
#define wxPERSIST_DVC_POS "Position"
#define wxPERSIST_DVC_TITLE "Title"
#define wxPERSIST_DVC_WIDTH "Width"
#define wxPERSIST_DVC_SORT_KEY "Sorting/Column"
#define wxPERSIST_DVC_SORT_ASC "Sorting/Asc"
// ----------------------------------------------------------------------------
// wxPersistentDataViewCtrl: Saves and restores user modified column widths
// and single column sort order.
//
// Future improvements could be to save and restore column order if the user
// has changed it and multicolumn sorts.
// ----------------------------------------------------------------------------
class wxPersistentDataViewCtrl : public wxPersistentWindow<wxDataViewCtrl>
{
public:
wxPersistentDataViewCtrl(wxDataViewCtrl* control)
: wxPersistentWindow<wxDataViewCtrl>(control)
{
}
virtual void Save() const wxOVERRIDE
{
wxDataViewCtrl* const control = Get();
const wxDataViewColumn* sortColumn = NULL;
for ( unsigned int col = 0; col < control->GetColumnCount(); col++ )
{
const wxDataViewColumn* const column = control->GetColumn(col);
// Create a prefix string to identify each column.
const wxString columnPrefix = MakeColumnPrefix(column);
// Save the column attributes.
SaveValue(columnPrefix + wxPERSIST_DVC_HIDDEN, column->IsHidden());
SaveValue(columnPrefix + wxPERSIST_DVC_POS,
control->GetColumnPosition(column));
SaveValue(columnPrefix + wxPERSIST_DVC_WIDTH, column->GetWidth());
// Check if this column is the current sort key.
if ( column->IsSortKey() )
sortColumn = column;
}
// Note: The current implementation does not save and restore multi-
// column sort keys.
if ( control->IsMultiColumnSortAllowed() )
return;
// Save the sort key and direction if there is a valid sort.
if ( sortColumn )
{
SaveValue(wxPERSIST_DVC_SORT_KEY, sortColumn->GetTitle());
SaveValue(wxPERSIST_DVC_SORT_ASC,
sortColumn->IsSortOrderAscending());
}
}
virtual bool Restore() wxOVERRIDE
{
wxDataViewCtrl* const control = Get();
for ( unsigned int col = 0; col < control->GetColumnCount(); col++ )
{
wxDataViewColumn* const column = control->GetColumn(col);
// Create a prefix string to identify each column within the
// persistence store (columns are stored by title). The persistence
// store benignly handles cases where the title is not found.
const wxString columnPrefix = MakeColumnPrefix(column);
// Restore column hidden status.
bool hidden;
if ( RestoreValue(columnPrefix + wxPERSIST_DVC_HIDDEN, &hidden) )
column->SetHidden(hidden);
// Restore the column width.
int width;
if ( RestoreValue(columnPrefix + wxPERSIST_DVC_WIDTH, &width) )
column->SetWidth(width);
// TODO: Set the column's view position.
}
// Restore the sort key and order if there is a valid model and sort
// criteria.
wxString sortColumn;
if ( control->GetModel() &&
RestoreValue(wxPERSIST_DVC_SORT_KEY, &sortColumn) &&
!sortColumn.empty() )
{
bool sortAsc = true;
if ( wxDataViewColumn* column = GetColumnByTitle(control, sortColumn) )
{
RestoreValue(wxPERSIST_DVC_SORT_ASC, &sortAsc);
column->SetSortOrder(sortAsc);
// Resort the control based on the new sort criteria.
control->GetModel()->Resort();
}
}
return true;
}
virtual wxString GetKind() const wxOVERRIDE
{
return wxPERSIST_DVC_KIND;
}
private:
// Return a (slash-terminated) prefix for the column-specific entries.
static wxString MakeColumnPrefix(const wxDataViewColumn* column)
{
return wxString::Format("/Columns/%s/", column->GetTitle());
}
// Return the column with the given title or NULL.
static wxDataViewColumn*
GetColumnByTitle(wxDataViewCtrl* control, const wxString& title)
{
for ( unsigned int col = 0; col < control->GetColumnCount(); col++ )
{
if ( control->GetColumn(col)->GetTitle() == title )
return control->GetColumn(col);
}
return NULL;
}
};
inline wxPersistentObject *wxCreatePersistentObject(wxDataViewCtrl* control)
{
return new wxPersistentDataViewCtrl(control);
}
#endif // _WX_PERSIST_DATAVIEW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/persist/splitter.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/persist/splitter.h
// Purpose: Persistence support for wxSplitterWindow.
// Author: Vadim Zeitlin
// Created: 2011-08-31
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PERSIST_SPLITTER_H_
#define _WX_PERSIST_SPLITTER_H_
#include "wx/persist/window.h"
#include "wx/splitter.h"
// ----------------------------------------------------------------------------
// string constants used by wxPersistentSplitter
// ----------------------------------------------------------------------------
#define wxPERSIST_SPLITTER_KIND "Splitter"
// Special position value of -1 means the splitter is not split at all.
#define wxPERSIST_SPLITTER_POSITION "Position"
// ----------------------------------------------------------------------------
// wxPersistentSplitter: supports saving/restoring splitter position
// ----------------------------------------------------------------------------
class wxPersistentSplitter : public wxPersistentWindow<wxSplitterWindow>
{
public:
wxPersistentSplitter(wxSplitterWindow* splitter)
: wxPersistentWindow<wxSplitterWindow>(splitter)
{
}
virtual void Save() const wxOVERRIDE
{
wxSplitterWindow* const splitter = Get();
int pos = splitter->IsSplit() ? splitter->GetSashPosition() : -1;
SaveValue(wxPERSIST_SPLITTER_POSITION, pos);
}
virtual bool Restore() wxOVERRIDE
{
int pos;
if ( !RestoreValue(wxPERSIST_SPLITTER_POSITION, &pos) )
return false;
if ( pos == -1 )
Get()->Unsplit();
else
Get()->SetSashPosition(pos);
return true;
}
virtual wxString GetKind() const wxOVERRIDE { return wxPERSIST_SPLITTER_KIND; }
};
inline wxPersistentObject *wxCreatePersistentObject(wxSplitterWindow* splitter)
{
return new wxPersistentSplitter(splitter);
}
#endif // _WX_PERSIST_SPLITTER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/persist/window.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/persist/window.h
// Purpose: wxPersistentWindow declaration
// Author: Vadim Zeitlin
// Created: 2009-01-23
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PERSIST_WINDOW_H_
#define _WX_PERSIST_WINDOW_H_
#include "wx/persist.h"
#include "wx/window.h"
// ----------------------------------------------------------------------------
// wxPersistentWindow: base class for persistent windows, uses the window name
// as persistent name by default and automatically reacts
// to the window destruction
// ----------------------------------------------------------------------------
// type-independent part of wxPersistentWindow
class wxPersistentWindowBase : public wxPersistentObject
{
public:
wxPersistentWindowBase(wxWindow *win)
: wxPersistentObject(win)
{
win->Bind(wxEVT_DESTROY, &wxPersistentWindowBase::HandleDestroy, this);
}
virtual wxString GetName() const wxOVERRIDE
{
const wxString name = GetWindow()->GetName();
wxASSERT_MSG( !name.empty(), "persistent windows should be named!" );
return name;
}
protected:
wxWindow *GetWindow() const { return static_cast<wxWindow *>(GetObject()); }
private:
void HandleDestroy(wxWindowDestroyEvent& event)
{
event.Skip();
// only react to the destruction of this object itself, not of any of
// its children
if ( event.GetEventObject() == GetObject() )
{
// this will delete this object itself
wxPersistenceManager::Get().SaveAndUnregister(GetWindow());
}
}
wxDECLARE_NO_COPY_CLASS(wxPersistentWindowBase);
};
template <class T>
class wxPersistentWindow : public wxPersistentWindowBase
{
public:
typedef T WindowType;
wxPersistentWindow(WindowType *win)
: wxPersistentWindowBase(win)
{
}
WindowType *Get() const { return static_cast<WindowType *>(GetWindow()); }
};
#endif // _WX_PERSIST_WINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/srchctlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/srchctlg.h
// Purpose: generic wxSearchCtrl class
// Author: Vince Harron
// Created: 2006-02-19
// Copyright: Vince Harron
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_SEARCHCTRL_H_
#define _WX_GENERIC_SEARCHCTRL_H_
#if wxUSE_SEARCHCTRL
#include "wx/bitmap.h"
class WXDLLIMPEXP_FWD_CORE wxSearchButton;
class WXDLLIMPEXP_FWD_CORE wxSearchTextCtrl;
// ----------------------------------------------------------------------------
// wxSearchCtrl is a combination of wxTextCtrl and wxSearchButton
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSearchCtrl : public wxSearchCtrlBase
{
public:
// creation
// --------
wxSearchCtrl();
wxSearchCtrl(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSearchCtrlNameStr);
virtual ~wxSearchCtrl();
bool Create(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSearchCtrlNameStr);
#if wxUSE_MENUS
// get/set search button menu
// --------------------------
virtual void SetMenu( wxMenu* menu ) wxOVERRIDE;
virtual wxMenu* GetMenu() wxOVERRIDE;
#endif // wxUSE_MENUS
// get/set search options
// ----------------------
virtual void ShowSearchButton( bool show ) wxOVERRIDE;
virtual bool IsSearchButtonVisible() const wxOVERRIDE;
virtual void ShowCancelButton( bool show ) wxOVERRIDE;
virtual bool IsCancelButtonVisible() const wxOVERRIDE;
virtual void SetDescriptiveText(const wxString& text) wxOVERRIDE;
virtual wxString GetDescriptiveText() const wxOVERRIDE;
// accessors
// ---------
virtual wxString GetRange(long from, long to) const wxOVERRIDE;
virtual int GetLineLength(long lineNo) const wxOVERRIDE;
virtual wxString GetLineText(long lineNo) const wxOVERRIDE;
virtual int GetNumberOfLines() const wxOVERRIDE;
virtual bool IsModified() const wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
// more readable flag testing methods
virtual bool IsSingleLine() const;
virtual bool IsMultiLine() const;
// If the return values from and to are the same, there is no selection.
virtual void GetSelection(long* from, long* to) const wxOVERRIDE;
virtual wxString GetStringSelection() const wxOVERRIDE;
// operations
// ----------
virtual void ChangeValue(const wxString& value) wxOVERRIDE;
// editing
virtual void Clear() wxOVERRIDE;
virtual void Replace(long from, long to, const wxString& value) wxOVERRIDE;
virtual void Remove(long from, long to) wxOVERRIDE;
// load/save the controls contents from/to the file
virtual bool LoadFile(const wxString& file);
virtual bool SaveFile(const wxString& file = wxEmptyString);
// sets/clears the dirty flag
virtual void MarkDirty() wxOVERRIDE;
virtual void DiscardEdits() wxOVERRIDE;
// set the max number of characters which may be entered in a single line
// text control
virtual void SetMaxLength(unsigned long WXUNUSED(len)) wxOVERRIDE;
// writing text inserts it at the current position, appending always
// inserts it at the end
virtual void WriteText(const wxString& text) wxOVERRIDE;
virtual void AppendText(const wxString& text) wxOVERRIDE;
// insert the character which would have resulted from this key event,
// return true if anything has been inserted
virtual bool EmulateKeyPress(const wxKeyEvent& event);
// text control under some platforms supports the text styles: these
// methods allow to apply the given text style to the given selection or to
// set/get the style which will be used for all appended text
virtual bool SetStyle(long start, long end, const wxTextAttr& style) wxOVERRIDE;
virtual bool GetStyle(long position, wxTextAttr& style) wxOVERRIDE;
virtual bool SetDefaultStyle(const wxTextAttr& style) wxOVERRIDE;
virtual const wxTextAttr& GetDefaultStyle() const wxOVERRIDE;
// translate between the position (which is just an index in the text ctrl
// considering all its contents as a single strings) and (x, y) coordinates
// which represent column and line.
virtual long XYToPosition(long x, long y) const wxOVERRIDE;
virtual bool PositionToXY(long pos, long *x, long *y) const wxOVERRIDE;
virtual void ShowPosition(long pos) wxOVERRIDE;
// find the character at position given in pixels
//
// NB: pt is in device coords (not adjusted for the client area origin nor
// scrolling)
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const wxOVERRIDE;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
wxTextCoord *col,
wxTextCoord *row) const wxOVERRIDE;
// Clipboard operations
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
virtual bool CanCopy() const wxOVERRIDE;
virtual bool CanCut() const wxOVERRIDE;
virtual bool CanPaste() const wxOVERRIDE;
// Undo/redo
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
// Insertion point
virtual void SetInsertionPoint(long pos) wxOVERRIDE;
virtual void SetInsertionPointEnd() wxOVERRIDE;
virtual long GetInsertionPoint() const wxOVERRIDE;
virtual wxTextPos GetLastPosition() const wxOVERRIDE;
virtual void SetSelection(long from, long to) wxOVERRIDE;
virtual void SelectAll() wxOVERRIDE;
virtual void SetEditable(bool editable) wxOVERRIDE;
// Autocomplete
virtual bool DoAutoCompleteStrings(const wxArrayString &choices) wxOVERRIDE;
virtual bool DoAutoCompleteFileNames(int flags) wxOVERRIDE;
virtual bool DoAutoCompleteCustom(wxTextCompleter *completer) wxOVERRIDE;
virtual bool ShouldInheritColours() const wxOVERRIDE;
// wxWindow overrides
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
// search control generic only
void SetSearchBitmap( const wxBitmap& bitmap );
void SetCancelBitmap( const wxBitmap& bitmap );
#if wxUSE_MENUS
void SetSearchMenuBitmap( const wxBitmap& bitmap );
#endif // wxUSE_MENUS
protected:
virtual void DoSetValue(const wxString& value, int flags) wxOVERRIDE;
virtual wxString DoGetValue() const wxOVERRIDE;
virtual bool DoLoadFile(const wxString& file, int fileType) wxOVERRIDE;
virtual bool DoSaveFile(const wxString& file, int fileType) wxOVERRIDE;
// override the base class virtuals involved into geometry calculations
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void RecalcBitmaps();
void Init();
virtual wxBitmap RenderSearchBitmap( int x, int y, bool renderDrop );
virtual wxBitmap RenderCancelBitmap( int x, int y );
void OnCancelButton( wxCommandEvent& event );
void OnSize( wxSizeEvent& event );
bool HasMenu() const
{
#if wxUSE_MENUS
return m_menu != NULL;
#else // !wxUSE_MENUS
return false;
#endif // wxUSE_MENUS/!wxUSE_MENUS
}
private:
friend class wxSearchButton;
// Implement pure virtual function inherited from wxCompositeWindow.
virtual wxWindowList GetCompositeWindowParts() const wxOVERRIDE;
// Position the child controls using the current window size.
void LayoutControls();
#if wxUSE_MENUS
void PopupSearchMenu();
#endif // wxUSE_MENUS
// the subcontrols
wxSearchTextCtrl *m_text;
wxSearchButton *m_searchButton;
wxSearchButton *m_cancelButton;
#if wxUSE_MENUS
wxMenu *m_menu;
#endif // wxUSE_MENUS
bool m_searchBitmapUser;
bool m_cancelBitmapUser;
#if wxUSE_MENUS
bool m_searchMenuBitmapUser;
#endif // wxUSE_MENUS
wxBitmap m_searchBitmap;
wxBitmap m_cancelBitmap;
#if wxUSE_MENUS
wxBitmap m_searchMenuBitmap;
#endif // wxUSE_MENUS
private:
wxDECLARE_DYNAMIC_CLASS(wxSearchCtrl);
wxDECLARE_EVENT_TABLE();
};
#endif // wxUSE_SEARCHCTRL
#endif // _WX_GENERIC_SEARCHCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/collheaderctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/collheaderctrl.h
// Purpose: wxGenericCollapsibleHeaderCtrl
// Author: Tobias Taschner
// Created: 2015-09-19
// Copyright: (c) 2015 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_COLLAPSIBLEHEADER_CTRL_H_
#define _WX_GENERIC_COLLAPSIBLEHEADER_CTRL_H_
class WXDLLIMPEXP_CORE wxGenericCollapsibleHeaderCtrl
: public wxCollapsibleHeaderCtrlBase
{
public:
wxGenericCollapsibleHeaderCtrl() { Init(); }
wxGenericCollapsibleHeaderCtrl(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)
{
Init();
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);
virtual void SetCollapsed(bool collapsed = true) wxOVERRIDE;
virtual bool IsCollapsed() const wxOVERRIDE
{ return m_collapsed; }
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
private:
bool m_collapsed;
bool m_inWindow;
bool m_mouseDown;
void Init();
void OnPaint(wxPaintEvent& event);
// Handle set/kill focus events (invalidate for painting focus rect)
void OnFocus(wxFocusEvent& event);
// Handle click
void OnLeftUp(wxMouseEvent& event);
// Handle pressed state
void OnLeftDown(wxMouseEvent& event);
// Handle current state
void OnEnterWindow(wxMouseEvent& event);
void OnLeaveWindow(wxMouseEvent& event);
// Toggle on space
void OnChar(wxKeyEvent& event);
void DoSetCollapsed(bool collapsed);
wxDECLARE_NO_COPY_CLASS(wxGenericCollapsibleHeaderCtrl);
};
#endif // _WX_GENERIC_COLLAPSIBLEHEADER_CTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/listctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/listctrl.h
// Purpose: Generic list control
// Author: Robert Roebling
// Created: 01/02/97
// Copyright: (c) 1998 Robert Roebling and Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_LISTCTRL_H_
#define _WX_GENERIC_LISTCTRL_H_
#include "wx/containr.h"
#include "wx/scrolwin.h"
#include "wx/textctrl.h"
#if wxUSE_DRAG_AND_DROP
class WXDLLIMPEXP_FWD_CORE wxDropTarget;
#endif
//-----------------------------------------------------------------------------
// internal classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxListHeaderWindow;
class WXDLLIMPEXP_FWD_CORE wxListMainWindow;
//-----------------------------------------------------------------------------
// wxListCtrl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGenericListCtrl: public wxNavigationEnabled<wxListCtrlBase>,
public wxScrollHelper
{
public:
wxGenericListCtrl() : wxScrollHelper(this)
{
Init();
}
wxGenericListCtrl( wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString &name = wxListCtrlNameStr)
: wxScrollHelper(this)
{
Create(parent, winid, pos, size, style, validator, name);
}
virtual ~wxGenericListCtrl();
void Init();
bool Create( wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString &name = wxListCtrlNameStr);
bool GetColumn( int col, wxListItem& item ) const wxOVERRIDE;
bool SetColumn( int col, const wxListItem& item ) wxOVERRIDE;
int GetColumnWidth( int col ) const wxOVERRIDE;
bool SetColumnWidth( int col, int width) wxOVERRIDE;
int GetCountPerPage() const; // not the same in wxGLC as in Windows, I think
wxRect GetViewRect() const;
bool GetItem( wxListItem& info ) const;
bool SetItem( wxListItem& info ) ;
bool SetItem( long index, int col, const wxString& label, int imageId = -1 );
int GetItemState( long item, long stateMask ) const;
bool SetItemState( long item, long state, long stateMask);
bool SetItemImage( long item, int image, int selImage = -1 );
bool SetItemColumnImage( long item, long column, int image );
wxString GetItemText( long item, int col = 0 ) const;
void SetItemText( long item, const wxString& str );
wxUIntPtr GetItemData( long item ) const;
bool SetItemPtrData(long item, wxUIntPtr data);
bool SetItemData(long item, long data) { return SetItemPtrData(item, data); }
bool GetItemRect( long item, wxRect& rect, int code = wxLIST_RECT_BOUNDS ) const;
bool GetSubItemRect( long item, long subItem, wxRect& rect, int code = wxLIST_RECT_BOUNDS ) const;
bool GetItemPosition( long item, wxPoint& pos ) const;
bool SetItemPosition( long item, const wxPoint& pos ); // not supported in wxGLC
int GetItemCount() const;
int GetColumnCount() const wxOVERRIDE;
void SetItemSpacing( int spacing, bool isSmall = false );
wxSize GetItemSpacing() const;
void SetItemTextColour( long item, const wxColour& col);
wxColour GetItemTextColour( long item ) const;
void SetItemBackgroundColour( long item, const wxColour &col);
wxColour GetItemBackgroundColour( long item ) const;
void SetItemFont( long item, const wxFont &f);
wxFont GetItemFont( long item ) const;
int GetSelectedItemCount() const;
wxColour GetTextColour() const;
void SetTextColour(const wxColour& col);
long GetTopItem() const;
virtual bool HasCheckBoxes() const wxOVERRIDE;
virtual bool EnableCheckBoxes(bool enable = true) wxOVERRIDE;
virtual bool IsItemChecked(long item) const wxOVERRIDE;
virtual void CheckItem(long item, bool check) wxOVERRIDE;
void SetSingleStyle( long style, bool add = true ) ;
void SetWindowStyleFlag( long style ) wxOVERRIDE;
void RecreateWindow() {}
long GetNextItem( long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE ) const;
wxImageList *GetImageList( int which ) const wxOVERRIDE;
void SetImageList( wxImageList *imageList, int which ) wxOVERRIDE;
void AssignImageList( wxImageList *imageList, int which ) wxOVERRIDE;
bool Arrange( int flag = wxLIST_ALIGN_DEFAULT ); // always wxLIST_ALIGN_LEFT in wxGLC
void ClearAll();
bool DeleteItem( long item );
bool DeleteAllItems();
bool DeleteAllColumns() wxOVERRIDE;
bool DeleteColumn( int col ) wxOVERRIDE;
void SetItemCount(long count);
wxTextCtrl *EditLabel(long item,
wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
wxTextCtrl* GetEditControl() const;
void Edit( long item ) { EditLabel(item); }
bool EnsureVisible( long item );
long FindItem( long start, const wxString& str, bool partial = false );
long FindItem( long start, wxUIntPtr data );
long FindItem( long start, const wxPoint& pt, int direction ); // not supported in wxGLC
long HitTest( const wxPoint& point, int& flags, long *pSubItem = NULL ) const;
long InsertItem(wxListItem& info);
long InsertItem( long index, const wxString& label );
long InsertItem( long index, int imageIndex );
long InsertItem( long index, const wxString& label, int imageIndex );
bool ScrollList( int dx, int dy );
bool SortItems( wxListCtrlCompare fn, wxIntPtr data );
// do we have a header window?
bool HasHeader() const
{ return InReportView() && !HasFlag(wxLC_NO_HEADER); }
// refresh items selectively (only useful for virtual list controls)
void RefreshItem(long item);
void RefreshItems(long itemFrom, long itemTo);
virtual void EnableBellOnNoMatch(bool on = true) wxOVERRIDE;
// overridden base class virtuals
// ------------------------------
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
virtual void Update() wxOVERRIDE;
// implementation only from now on
// -------------------------------
// generic version extension, don't use in portable code
bool Update( long item );
void OnInternalIdle( ) wxOVERRIDE;
// We have to hand down a few functions
virtual void Refresh(bool eraseBackground = true,
const wxRect *rect = NULL) wxOVERRIDE;
virtual bool SetBackgroundColour( const wxColour &colour ) wxOVERRIDE;
virtual bool SetForegroundColour( const wxColour &colour ) wxOVERRIDE;
virtual wxColour GetBackgroundColour() const;
virtual wxColour GetForegroundColour() const;
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
virtual bool SetCursor( const wxCursor &cursor ) wxOVERRIDE;
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget ) wxOVERRIDE;
virtual wxDropTarget *GetDropTarget() const wxOVERRIDE;
#endif
virtual bool ShouldInheritColours() const wxOVERRIDE { return false; }
// implementation
// --------------
wxImageList *m_imageListNormal;
wxImageList *m_imageListSmall;
wxImageList *m_imageListState; // what's that ?
bool m_ownsImageListNormal,
m_ownsImageListSmall,
m_ownsImageListState;
wxListHeaderWindow *m_headerWin;
wxListMainWindow *m_mainWin;
protected:
// Implement base class pure virtual methods.
long DoInsertColumn(long col, const wxListItem& info) wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// return the text for the given column of the given item
virtual wxString OnGetItemText(long item, long column) const;
// return the icon for the given item. In report view, OnGetItemImage will
// only be called for the first column. See OnGetItemColumnImage for
// details.
virtual int OnGetItemImage(long item) const;
// return the icon for the given item and column.
virtual int OnGetItemColumnImage(long item, long column) const;
// it calls our OnGetXXX() functions
friend class WXDLLIMPEXP_FWD_CORE wxListMainWindow;
virtual wxBorder GetDefaultBorder() const wxOVERRIDE;
virtual wxSize GetSizeAvailableForScrollTarget(const wxSize& size) wxOVERRIDE;
private:
void CreateOrDestroyHeaderWindowAsNeeded();
void OnScroll( wxScrollWinEvent& event );
void OnSize( wxSizeEvent &event );
// we need to return a special WM_GETDLGCODE value to process just the
// arrows but let the other navigation characters through
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
virtual WXLRESULT
MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
#endif // __WXMSW__
WX_FORWARD_TO_SCROLL_HELPER()
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxGenericListCtrl);
};
#if (!defined(__WXMSW__) || defined(__WXUNIVERSAL__)) && (!(defined(__WXMAC__) && wxOSX_USE_CARBON) || defined(__WXUNIVERSAL__ ))
/*
* wxListCtrl has to be a real class or we have problems with
* the run-time information.
*/
class WXDLLIMPEXP_CORE wxListCtrl: public wxGenericListCtrl
{
wxDECLARE_DYNAMIC_CLASS(wxListCtrl);
public:
wxListCtrl() {}
wxListCtrl(wxWindow *parent, wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator &validator = wxDefaultValidator,
const wxString &name = wxListCtrlNameStr)
: wxGenericListCtrl(parent, winid, pos, size, style, validator, name)
{
}
};
#endif // !__WXMSW__ || __WXUNIVERSAL__
#endif // _WX_GENERIC_LISTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/activityindicator.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/activityindicator.h
// Purpose: Declaration of wxActivityIndicatorGeneric.
// Author: Vadim Zeitlin
// Created: 2015-03-06
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_ACTIVITYINDICATOR_H_
#define _WX_GENERIC_ACTIVITYINDICATOR_H_
#ifndef wxHAS_NATIVE_ACTIVITYINDICATOR
// This is the only implementation we have, so call it accordingly.
#define wxActivityIndicatorGeneric wxActivityIndicator
#endif
// ----------------------------------------------------------------------------
// wxActivityIndicatorGeneric: built-in generic implementation.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxActivityIndicatorGeneric : public wxActivityIndicatorBase
{
public:
wxActivityIndicatorGeneric()
{
m_impl = NULL;
}
explicit
wxActivityIndicatorGeneric(wxWindow* parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxActivityIndicatorNameStr)
{
m_impl = NULL;
Create(parent, winid, pos, size, style, name);
}
bool Create(wxWindow* parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxActivityIndicatorNameStr);
virtual ~wxActivityIndicatorGeneric();
virtual void Start() wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual bool IsRunning() const wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
private:
class wxActivityIndicatorImpl *m_impl;
#ifndef wxHAS_NATIVE_ACTIVITYINDICATOR
wxDECLARE_DYNAMIC_CLASS(wxActivityIndicator);
#endif
};
#endif // _WX_GENERIC_ACTIVITYINDICATOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/msgdlgg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/msgdlgg.h
// Purpose: Generic wxMessageDialog
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_MSGDLGG_H_
#define _WX_GENERIC_MSGDLGG_H_
class WXDLLIMPEXP_FWD_CORE wxSizer;
class WXDLLIMPEXP_CORE wxGenericMessageDialog : public wxMessageDialogBase
{
public:
wxGenericMessageDialog(wxWindow *parent,
const wxString& message,
const wxString& caption = wxMessageBoxCaptionStr,
long style = wxOK|wxCENTRE,
const wxPoint& pos = wxDefaultPosition);
virtual int ShowModal() wxOVERRIDE;
protected:
// Creates a message dialog taking any options that have been set after
// object creation into account such as custom labels.
void DoCreateMsgdialog();
void OnYes(wxCommandEvent& event);
void OnNo(wxCommandEvent& event);
void OnHelp(wxCommandEvent& event);
void OnCancel(wxCommandEvent& event);
// can be overridden to provide more contents to the dialog
virtual void AddMessageDialogCheckBox(wxSizer *WXUNUSED(sizer)) { }
virtual void AddMessageDialogDetails(wxSizer *WXUNUSED(sizer)) { }
private:
// Creates and returns a standard button sizer using the style of this
// dialog and the custom labels, if any.
//
// May return NULL on smart phone platforms not using buttons at all.
wxSizer *CreateMsgDlgButtonSizer();
wxPoint m_pos;
bool m_created;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxGenericMessageDialog);
};
#endif // _WX_GENERIC_MSGDLGG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/combo.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/combo.h
// Purpose: Generic wxComboCtrl
// Author: Jaakko Salli
// Modified by:
// Created: Apr-30-2006
// Copyright: (c) Jaakko Salli
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_COMBOCTRL_H_
#define _WX_GENERIC_COMBOCTRL_H_
#if wxUSE_COMBOCTRL
// Only define generic if native doesn't have all the features
#if !defined(wxCOMBOCONTROL_FULLY_FEATURED)
#include "wx/containr.h"
// ----------------------------------------------------------------------------
// Generic wxComboCtrl
// ----------------------------------------------------------------------------
#if defined(__WXUNIVERSAL__)
// all actions of single line text controls are supported
// popup/dismiss the choice window
#define wxACTION_COMBOBOX_POPUP wxT("popup")
#define wxACTION_COMBOBOX_DISMISS wxT("dismiss")
#endif
extern WXDLLIMPEXP_DATA_CORE(const char) wxComboBoxNameStr[];
class WXDLLIMPEXP_CORE wxGenericComboCtrl
: public wxNavigationEnabled<wxComboCtrlBase>
{
public:
// ctors and such
wxGenericComboCtrl() { Init(); }
wxGenericComboCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
Init();
(void)Create(parent, id, value, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
virtual ~wxGenericComboCtrl();
void SetCustomPaintWidth( int width );
virtual bool IsKeyPopupToggle(const wxKeyEvent& event) const wxOVERRIDE;
static int GetFeatures() { return wxComboCtrlFeatures::All; }
#if defined(__WXUNIVERSAL__)
// we have our own input handler and our own actions
virtual bool PerformAction(const wxControlAction& action,
long numArg = 0l,
const wxString& strArg = wxEmptyString);
#endif
protected:
// Dummies for platform-specific wxTextEntry implementations
#if defined(__WXUNIVERSAL__)
// Looks like there's nothing we need to override here
#elif defined(__WXMOTIF__)
virtual WXWidget GetTextWidget() const { return NULL; }
#elif defined(__WXGTK__)
#if defined(__WXGTK20__)
virtual GtkEditable *GetEditable() const wxOVERRIDE { return NULL; }
virtual GtkEntry *GetEntry() const wxOVERRIDE { return NULL; }
#endif
#elif defined(__WXMAC__)
// Looks like there's nothing we need to override here
#endif
// For better transparent background rendering
virtual bool HasTransparentBackground() wxOVERRIDE;
// Mandatory virtuals
virtual void OnResize() wxOVERRIDE;
// Event handlers
void OnPaintEvent( wxPaintEvent& event );
void OnMouseEvent( wxMouseEvent& event );
private:
void Init();
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxGenericComboCtrl);
};
#ifndef _WX_COMBOCONTROL_H_
// If native wxComboCtrl was not defined, then prepare a simple
// front-end so that wxRTTI works as expected.
class WXDLLIMPEXP_CORE wxComboCtrl : public wxGenericComboCtrl
{
public:
wxComboCtrl() : wxGenericComboCtrl() {}
wxComboCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
: wxGenericComboCtrl()
{
(void)Create(parent, id, value, pos, size, style, validator, name);
}
virtual ~wxComboCtrl() {}
protected:
private:
wxDECLARE_DYNAMIC_CLASS(wxComboCtrl);
};
#endif // _WX_COMBOCONTROL_H_
#else
#define wxGenericComboCtrl wxComboCtrl
#endif // !defined(wxCOMBOCONTROL_FULLY_FEATURED)
#endif // wxUSE_COMBOCTRL
#endif
// _WX_GENERIC_COMBOCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/animate.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/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_GENERIC_ANIMATEH__
#define _WX_GENERIC_ANIMATEH__
#include "wx/bitmap.h"
// ----------------------------------------------------------------------------
// wxAnimation
// ----------------------------------------------------------------------------
WX_DECLARE_LIST_WITH_DECL(wxAnimationDecoder, wxAnimationDecoderList, class WXDLLIMPEXP_ADV);
class WXDLLIMPEXP_ADV wxAnimation : public wxAnimationBase
{
public:
wxAnimation() {}
wxAnimation(const wxString &name, wxAnimationType type = wxANIMATION_TYPE_ANY)
{ LoadFile(name, type); }
virtual bool IsOk() const wxOVERRIDE
{ return m_refData != NULL; }
virtual unsigned int GetFrameCount() const wxOVERRIDE;
virtual int GetDelay(unsigned int i) const wxOVERRIDE;
virtual wxImage GetFrame(unsigned int i) const wxOVERRIDE;
virtual wxSize GetSize() const wxOVERRIDE;
virtual bool LoadFile(const wxString& filename,
wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
virtual bool Load(wxInputStream& stream,
wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
// extended interface used by the generic implementation of wxAnimationCtrl
wxPoint GetFramePosition(unsigned int frame) const;
wxSize GetFrameSize(unsigned int frame) const;
wxAnimationDisposal GetDisposalMethod(unsigned int frame) const;
wxColour GetTransparentColour(unsigned int frame) const;
wxColour GetBackgroundColour() const;
protected:
static wxAnimationDecoderList sm_handlers;
public:
static inline wxAnimationDecoderList& GetHandlers() { return sm_handlers; }
static void AddHandler(wxAnimationDecoder *handler);
static void InsertHandler(wxAnimationDecoder *handler);
static const wxAnimationDecoder *FindHandler( wxAnimationType animType );
static void CleanUpHandlers();
static void InitStandardHandlers();
wxDECLARE_DYNAMIC_CLASS(wxAnimation);
};
// ----------------------------------------------------------------------------
// wxAnimationCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxAnimationCtrl: public wxAnimationCtrlBase
{
public:
wxAnimationCtrl() { Init(); }
wxAnimationCtrl(wxWindow *parent,
wxWindowID id,
const wxAnimation& anim = wxNullAnimation,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxAC_DEFAULT_STYLE,
const wxString& name = wxAnimationCtrlNameStr)
{
Init();
Create(parent, id, anim, pos, size, style, name);
}
void Init();
bool Create(wxWindow *parent, wxWindowID id,
const wxAnimation& anim = wxNullAnimation,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxAC_DEFAULT_STYLE,
const wxString& name = wxAnimationCtrlNameStr);
~wxAnimationCtrl();
public:
virtual bool LoadFile(const wxString& filename, wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
virtual bool Load(wxInputStream& stream, wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual bool Play() wxOVERRIDE
{ return Play(true /* looped */); }
virtual bool IsPlaying() const wxOVERRIDE
{ return m_isPlaying; }
void SetAnimation(const wxAnimation &animation) wxOVERRIDE;
wxAnimation GetAnimation() const wxOVERRIDE
{ return m_animation; }
virtual void SetInactiveBitmap(const wxBitmap &bmp) wxOVERRIDE;
// override base class method
virtual bool SetBackgroundColour(const wxColour& col) wxOVERRIDE;
public: // event handlers
void OnPaint(wxPaintEvent& event);
void OnTimer(wxTimerEvent& event);
void OnSize(wxSizeEvent& event);
public: // extended API specific to this implementation of wxAnimateCtrl
// Specify whether the animation's background colour is to be shown (the default),
// or whether the window background should show through
void SetUseWindowBackgroundColour(bool useWinBackground = true)
{ m_useWinBackgroundColour = useWinBackground; }
bool IsUsingWindowBackgroundColour() const
{ return m_useWinBackgroundColour; }
// This overload of Play() lets you specify if the animation must loop or not
bool Play(bool looped);
// Draw the current frame of the animation into given DC.
// This is fast as current frame is always cached.
void DrawCurrentFrame(wxDC& dc);
// Returns a wxBitmap with the current frame drawn in it
wxBitmap& GetBackingStore()
{ return m_backingStore; }
protected: // internal utilities
// resize this control to fit m_animation
void FitToAnimation();
// Draw the background; use this when e.g. previous frame had wxANIM_TOBACKGROUND disposal.
void DisposeToBackground();
void DisposeToBackground(wxDC& dc);
void DisposeToBackground(wxDC& dc, const wxPoint &pos, const wxSize &sz);
void IncrementalUpdateBackingStore();
bool RebuildBackingStoreUpToFrame(unsigned int);
void DrawFrame(wxDC &dc, unsigned int);
virtual void DisplayStaticImage() wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
protected:
unsigned int m_currentFrame; // Current frame
bool m_looped; // Looped, or not
wxTimer m_timer; // The timer
wxAnimation m_animation; // The animation
bool m_isPlaying; // Is the animation playing?
bool m_useWinBackgroundColour; // Use animation bg colour or window bg colour?
wxBitmap m_backingStore; // The frames are drawn here and then blitted
// on the screen
private:
typedef wxAnimationCtrlBase base_type;
wxDECLARE_DYNAMIC_CLASS(wxAnimationCtrl);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_GENERIC_ANIMATEH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/helpext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/helpext.h
// Purpose: an external help controller for wxWidgets
// Author: Karsten Ballueder ([email protected])
// Modified by:
// Copyright: (c) Karsten Ballueder 1998
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __WX_HELPEXT_H_
#define __WX_HELPEXT_H_
#if wxUSE_HELP
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/helpbase.h"
// ----------------------------------------------------------------------------
// wxExtHelpController
// ----------------------------------------------------------------------------
// This class implements help via an external browser.
class WXDLLIMPEXP_ADV wxExtHelpController : public wxHelpControllerBase
{
public:
wxExtHelpController(wxWindow* parentWindow = NULL);
virtual ~wxExtHelpController();
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED(void SetBrowser(const wxString& browsername = wxEmptyString, bool isNetscape = false) );
#endif
// Set viewer: new name for SetBrowser
virtual void SetViewer(const wxString& viewer = wxEmptyString,
long flags = wxHELP_NETSCAPE) wxOVERRIDE;
virtual bool Initialize(const wxString& dir, int WXUNUSED(server)) wxOVERRIDE
{ return Initialize(dir); }
virtual bool Initialize(const wxString& dir) wxOVERRIDE;
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE;
virtual bool DisplayContents(void) wxOVERRIDE;
virtual bool DisplaySection(int sectionNo) wxOVERRIDE;
virtual bool DisplaySection(const wxString& section) wxOVERRIDE;
virtual bool DisplayBlock(long blockNo) wxOVERRIDE;
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE;
virtual bool Quit(void) wxOVERRIDE;
virtual void OnQuit(void) wxOVERRIDE;
virtual bool DisplayHelp(const wxString &) ;
virtual void SetFrameParameters(const wxString& WXUNUSED(title),
const wxSize& WXUNUSED(size),
const wxPoint& WXUNUSED(pos) = wxDefaultPosition,
bool WXUNUSED(newFrameEachTime) = false) wxOVERRIDE
{
// does nothing by default
}
virtual wxFrame *GetFrameParameters(wxSize *WXUNUSED(size) = NULL,
wxPoint *WXUNUSED(pos) = NULL,
bool *WXUNUSED(newFrameEachTime) = NULL) wxOVERRIDE
{
return NULL; // does nothing by default
}
protected:
// Filename of currently active map file.
wxString m_helpDir;
// How many entries do we have in the map file?
int m_NumOfEntries;
// A list containing all id,url,documentation triples.
wxList *m_MapList;
private:
// parse a single line of the map file (called by LoadFile())
//
// return true if the line was valid or false otherwise
bool ParseMapFileLine(const wxString& line);
// Deletes the list and all objects.
void DeleteList(void);
// How to call the html viewer.
wxString m_BrowserName;
// Is the viewer a variant of netscape?
bool m_BrowserIsNetscape;
wxDECLARE_CLASS(wxExtHelpController);
};
#endif // wxUSE_HELP
#endif // __WX_HELPEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/generic/statusbr.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/generic/statusbr.h
// Purpose: wxStatusBarGeneric class
// Author: Julian Smart
// Modified by: VZ at 05.02.00 to derive from wxStatusBarBase
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_STATUSBR_H_
#define _WX_GENERIC_STATUSBR_H_
#include "wx/defs.h"
#if wxUSE_STATUSBAR
#include "wx/pen.h"
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// wxStatusBarGeneric
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStatusBarGeneric : public wxStatusBarBase
{
public:
wxStatusBarGeneric() { Init(); }
wxStatusBarGeneric(wxWindow *parent,
wxWindowID winid = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr)
{
Init();
Create(parent, winid, style, name);
}
virtual ~wxStatusBarGeneric();
bool Create(wxWindow *parent, wxWindowID winid = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr);
// implement base class methods
virtual void SetStatusWidths(int n, const int widths_field[]) wxOVERRIDE;
virtual bool GetFieldRect(int i, wxRect& rect) const wxOVERRIDE;
virtual void SetMinHeight(int height) wxOVERRIDE;
virtual int GetBorderX() const wxOVERRIDE { return m_borderX; }
virtual int GetBorderY() const wxOVERRIDE { return m_borderY; }
// implementation only (not part of wxStatusBar public API):
int GetFieldFromPoint(const wxPoint& point) const;
protected:
virtual void DoUpdateStatusText(int number) wxOVERRIDE;
// event handlers
void OnPaint(wxPaintEvent& event);
void OnSize(wxSizeEvent& event);
void OnLeftDown(wxMouseEvent& event);
void OnRightDown(wxMouseEvent& event);
// Responds to colour changes
void OnSysColourChanged(wxSysColourChangedEvent& event);
protected:
virtual void DrawFieldText(wxDC& dc, const wxRect& rc, int i, int textHeight);
virtual void DrawField(wxDC& dc, int i, int textHeight);
void SetBorderX(int x);
void SetBorderY(int y);
virtual void InitColours();
// true if the status bar shows the size grip: for this it must have
// wxSTB_SIZEGRIP style and the window it is attached to must be resizable
// and not maximized
bool ShowsSizeGrip() const;
// returns the position and the size of the size grip
wxRect GetSizeGripRect() const;
// common part of all ctors
void Init();
// the last known size, fields widths must be updated whenever it's out of
// date
wxSize m_lastClientSize;
// the absolute widths of the status bar panes in pixels
wxArrayInt m_widthsAbs;
int m_borderX;
int m_borderY;
wxPen m_mediumShadowPen;
wxPen m_hilightPen;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
private:
// Update m_lastClientSize and m_widthsAbs from the current size.
void DoUpdateFieldWidths();
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStatusBarGeneric);
};
#endif // wxUSE_STATUSBAR
#endif
// _WX_GENERIC_STATUSBR_H_
| h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.