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/gtk1/dcscreen.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/dcscreen.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDCSCREENH__
#define __GTKDCSCREENH__
#include "wx/gtk1/dcclient.h"
//-----------------------------------------------------------------------------
// wxScreenDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxScreenDCImpl : public wxPaintDCImpl
{
public:
wxScreenDCImpl(wxScreenDC *owner);
virtual ~wxScreenDCImpl();
// implementation
static GdkWindow *sm_overlayWindow;
static int sm_overlayWindowX;
static int sm_overlayWindowY;
protected:
virtual void DoGetSize(int *width, int *height) const;
private:
wxDECLARE_DYNAMIC_CLASS(wxScreenDCImpl);
};
#endif // __GTKDCSCREENH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/combobox.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/combobox.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCOMBOBOXH__
#define __GTKCOMBOBOXH__
#include "wx/defs.h"
#if wxUSE_COMBOBOX
#include "wx/object.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxComboBox;
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
extern WXDLLIMPEXP_DATA_CORE(const char) wxComboBoxNameStr[];
extern WXDLLIMPEXP_BASE const wxChar* wxEmptyString;
//-----------------------------------------------------------------------------
// wxComboBox
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxComboBox :
public wxWindowWithItems<wxControl, wxComboBoxBase>
{
public:
inline wxComboBox() {}
inline wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
Create(parent, id, value, pos, size, n, choices, style, validator, name);
}
inline wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
Create(parent, id, value, pos, size, choices, style, validator, name);
}
virtual ~wxComboBox();
bool Create(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
void DoClear();
void DoDeleteOneItem(unsigned int n);
virtual int FindString(const wxString& s, bool bCase = false) const;
int GetSelection() const;
int GetCurrentSelection() const;
virtual wxString GetString(unsigned int n) const;
wxString GetStringSelection() const;
virtual unsigned int GetCount() const;
virtual void SetSelection(int n);
virtual void SetString(unsigned int n, const wxString &text);
wxString GetValue() const { return DoGetValue(); }
void SetValue(const wxString& value);
void WriteText(const wxString& value);
void Copy();
void Cut();
void Paste();
bool CanCopy() const;
bool CanCut() const;
bool CanPaste() const;
void SetInsertionPoint( long pos );
void SetInsertionPointEnd() { SetInsertionPoint( -1 ); }
long GetInsertionPoint() const;
virtual wxTextPos GetLastPosition() const;
void Remove(long from, long to) { Replace(from, to, wxEmptyString); }
void Replace( long from, long to, const wxString& value );
void SetSelection( long from, long to );
void GetSelection( long* from, long* to ) const;
void SetEditable( bool editable );
void Undo() ;
void Redo() ;
bool CanUndo() const;
bool CanRedo() const;
void SelectAll();
bool IsEditable() const ;
bool HasSelection() const ;
// implementation
virtual void SetFocus();
void OnSize( wxSizeEvent &event );
void OnChar( wxKeyEvent &event );
// Standard event handling
void OnCut(wxCommandEvent& event);
void OnCopy(wxCommandEvent& event);
void OnPaste(wxCommandEvent& event);
void OnUndo(wxCommandEvent& event);
void OnRedo(wxCommandEvent& event);
void OnDelete(wxCommandEvent& event);
void OnSelectAll(wxCommandEvent& event);
void OnUpdateCut(wxUpdateUIEvent& event);
void OnUpdateCopy(wxUpdateUIEvent& event);
void OnUpdatePaste(wxUpdateUIEvent& event);
void OnUpdateUndo(wxUpdateUIEvent& event);
void OnUpdateRedo(wxUpdateUIEvent& event);
void OnUpdateDelete(wxUpdateUIEvent& event);
void OnUpdateSelectAll(wxUpdateUIEvent& event);
bool m_ignoreNextUpdate:1;
wxList m_clientDataList;
wxList m_clientObjectList;
int m_prevSelection;
void DisableEvents();
void EnableEvents();
GtkWidget* GetConnectWidget();
bool IsOwnGtkWindow( GdkWindow *window );
void DoApplyWidgetStyle(GtkRcStyle *style);
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual void DoSetItemClientData(unsigned int n, void* clientData);
virtual void* DoGetItemClientData(unsigned int n) const;
virtual wxSize DoGetBestSize() const;
// implement wxTextEntry pure virtual methods
virtual wxString DoGetValue() const;
virtual wxWindow *GetEditableWindow() { return this; }
// Widgets that use the style->base colour for the BG colour should
// override this and return true.
virtual bool UseGTKStyleBase() const { return true; }
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxComboBox);
wxDECLARE_EVENT_TABLE();
};
#endif
#endif
// __GTKCOMBOBOXH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/glcanvas.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/glcanvas.h
// Purpose: wxGLCanvas, for using OpenGL/Mesa with wxWidgets and GTK
// Author: Robert Roebling
// Modified by:
// Created: 17/8/98
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GLCANVAS_H_
#define _WX_GLCANVAS_H_
#include "wx/unix/glx11.h"
//---------------------------------------------------------------------------
// wxGLCanvas
//---------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasX11
{
public:
wxGLCanvas(wxWindow *parent,
const wxGLAttributes& dispAttrs,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const wxPalette& palette = wxNullPalette);
explicit // avoid implicitly converting a wxWindow* to wxGLCanvas
wxGLCanvas(wxWindow *parent,
wxWindowID id = wxID_ANY,
const int *attribList = NULL,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const wxPalette& palette = wxNullPalette);
bool Create(wxWindow *parent,
const wxGLAttributes& dispAttrs,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const wxPalette& palette = wxNullPalette);
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette);
// implement wxGLCanvasX11 methods
// -------------------------------
virtual Window GetXWindow() const;
// deprecated methods
// ------------------
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR(
wxGLCanvas(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette)
);
wxDEPRECATED_CONSTRUCTOR(
wxGLCanvas(wxWindow *parent,
const wxGLContext *shared,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette)
);
wxDEPRECATED_CONSTRUCTOR(
wxGLCanvas(wxWindow *parent,
const wxGLCanvas *shared,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette)
);
// called from "realized" callback to create the implicit context if needed
void GTKInitImplicitContext();
#endif // WXWIN_COMPATIBILITY_2_8
// implementation from now on
virtual void OnInternalIdle();
GtkWidget *m_glWidget;
#if WXWIN_COMPATIBILITY_2_8
wxGLContext *m_sharedContext;
wxGLCanvas *m_sharedContextOf;
const bool m_createImplicitContext;
#endif // WXWIN_COMPATIBILITY_2_8
private:
wxDECLARE_CLASS(wxGLCanvas);
};
#endif // _WX_GLCANVAS_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/window.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/window.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKWINDOWH__
#define __GTKWINDOWH__
typedef struct _GtkTooltips GtkTooltips;
#ifdef HAVE_XIM
typedef struct _GdkIC GdkIC;
typedef struct _GdkICAttr GdkICAttr;
#endif
//-----------------------------------------------------------------------------
// callback definition for inserting a window (internal)
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxWindowGTK;
typedef void (*wxInsertChildFunction)( wxWindowGTK*, wxWindowGTK* );
//-----------------------------------------------------------------------------
// wxWindowGTK
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowGTK : public wxWindowBase
{
public:
// creating the window
// -------------------
wxWindowGTK();
wxWindowGTK(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
virtual ~wxWindowGTK();
// implement base class (pure) virtual methods
// -------------------------------------------
virtual void SetLabel(const wxString& WXUNUSED(label)) { }
virtual wxString GetLabel() const { return wxEmptyString; }
virtual bool Destroy();
virtual void Raise();
virtual void Lower();
virtual bool Show( bool show = true );
virtual void DoEnable( bool enable );
virtual void SetWindowStyleFlag( long style );
virtual bool IsRetained() const;
virtual void SetFocus();
virtual bool AcceptsFocus() const;
virtual bool Reparent( wxWindowBase *newParent );
virtual void WarpPointer(int x, int y);
virtual void Refresh( bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL );
virtual void Update();
virtual void ClearBackground();
virtual bool SetBackgroundColour( const wxColour &colour );
virtual bool SetForegroundColour( const wxColour &colour );
virtual bool SetCursor( const wxCursor &cursor );
virtual bool SetFont( const wxFont &font );
virtual bool SetBackgroundStyle(wxBackgroundStyle style) ;
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
virtual void SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh = true );
virtual void SetScrollPos( int orient, int pos, bool refresh = true );
virtual int GetScrollPos( int orient ) const;
virtual int GetScrollThumb( int orient ) const;
virtual int GetScrollRange( int orient ) const;
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = NULL );
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
#endif // wxUSE_DRAG_AND_DROP
virtual bool IsDoubleBuffered() const { return false; }
GdkWindow* GTKGetDrawingWindow() const;
// implementation
// --------------
virtual WXWidget GetHandle() const { return m_widget; }
// I don't want users to override what's done in idle so everything that
// has to be done in idle time in order for wxGTK to work is done in
// OnInternalIdle
virtual void OnInternalIdle();
// Internal representation of Update()
void GtkUpdate();
// For compatibility across platforms (not in event table)
void OnIdle(wxIdleEvent& WXUNUSED(event)) {}
// Used by all window classes in the widget creation process.
bool PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size );
void PostCreation();
// Internal addition of child windows. differs from class
// to class not by using virtual functions but by using
// the m_insertCallback.
void DoAddChild(wxWindowGTK *child);
// This methods sends wxPaintEvents to the window. It reads the
// update region, breaks it up into rects and sends an event
// for each rect. It is also responsible for background erase
// events and NC paint events. It is called from "draw" and
// "expose" handlers as well as from ::Update()
void GtkSendPaintEvents();
// The methods below are required because many native widgets
// are composed of several subwidgets and setting a style for
// the widget means setting it for all subwidgets as well.
// also, it is not clear which native widget is the top
// widget where (most of) the input goes. even tooltips have
// to be applied to all subwidgets.
virtual GtkWidget* GetConnectWidget();
virtual bool IsOwnGtkWindow( GdkWindow *window );
void ConnectWidget( GtkWidget *widget );
#if wxUSE_TOOLTIPS
virtual void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );
#endif // wxUSE_TOOLTIPS
// Call after modifing the value of m_hAdjust or m_vAdjust to bring the
// scrolbar in sync (this does not generate any wx events)
void GtkUpdateScrollbar(int orient);
// Called from GTK signal handlers. it indicates that
// the layout functions have to be called later on
// (i.e. in idle time, implemented in OnInternalIdle() ).
void GtkUpdateSize() { m_sizeSet = false; }
// fix up the mouse event coords, used by wxListBox only so far
virtual void FixUpMouseEvent(GtkWidget * WXUNUSED(widget),
wxCoord& WXUNUSED(x),
wxCoord& WXUNUSED(y)) { }
// is this window transparent for the mouse events (as wxStaticBox is)?
virtual bool IsTransparentForMouse() const { return false; }
// is this a radiobutton (used by radiobutton code itself only)?
virtual bool IsRadioButton() const { return false; }
// position and size of the window
int m_x, m_y;
int m_width, m_height;
int m_oldClientWidth,m_oldClientHeight;
// see the docs in src/gtk/window.cpp
GtkWidget *m_widget; // mostly the widget seen by the rest of GTK
GtkWidget *m_wxwindow; // mostly the client area as per wxWidgets
// this widget will be queried for GTK's focus events
GtkWidget *m_focusWidget;
#ifdef HAVE_XIM
// XIM support for wxWidgets
GdkIC *m_ic;
GdkICAttr *m_icattr;
#endif // HAVE_XIM
// The area to be cleared (and not just refreshed)
// We cannot make this distinction under GTK 2.0.
wxRegion m_clearRegion;
// scrolling stuff
GtkAdjustment *m_hAdjust,*m_vAdjust;
float m_oldHorizontalPos;
float m_oldVerticalPos;
// extra (wxGTK-specific) flags
bool m_needParent:1; // ! wxFrame, wxDialog, wxNotebookPage ?
bool m_noExpose:1; // wxGLCanvas has its own redrawing
bool m_nativeSizeEvent:1; // wxGLCanvas sends wxSizeEvent upon "alloc_size"
bool m_hasScrolling:1;
bool m_hasVMT:1;
bool m_sizeSet:1;
bool m_resizing:1;
bool m_acceptsFocus:1; // true if not static
bool m_hasFocus:1; // true if == FindFocus()
bool m_isScrolling:1; // dragging scrollbar thumb?
bool m_clipPaintRegion:1; // true after ScrollWindow()
bool m_needsStyleChange:1; // May not be able to change
// background style until OnIdle
// C++ has no virtual methods in the constrcutor of any class but we need
// different methods of inserting a child window into a wxFrame,
// wxMDIFrame, wxNotebook etc. this is the callback that will get used.
wxInsertChildFunction m_insertCallback;
// implement the base class pure virtuals
virtual void DoGetTextExtent(const wxString& string,
int *x, int *y,
int *descent = NULL,
int *externalLeading = NULL,
const wxFont *theFont = NULL) const;
#if wxUSE_MENUS_NATIVE
virtual bool DoPopupMenu( wxMenu *menu, int x, int y );
#endif // wxUSE_MENUS_NATIVE
virtual void DoClientToScreen( int *x, int *y ) const;
virtual void DoScreenToClient( int *x, int *y ) const;
virtual void DoGetPosition( int *x, int *y ) const;
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoGetClientSize( int *width, int *height ) const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoSetClientSize(int width, int height);
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual void DoCaptureMouse();
virtual void DoReleaseMouse();
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
protected:
// common part of all ctors (not virtual because called from ctor)
void Init();
// Called by ApplyWidgetStyle (which is called by SetFont() and
// SetXXXColour etc to apply style changed to native widgets) to create
// modified GTK style with non-standard attributes. If forceStyle=true,
// creates empty GtkRcStyle if there are no modifications, otherwise
// returns NULL in such case.
GtkRcStyle *CreateWidgetStyle(bool forceStyle = false);
// Overridden in many GTK widgets who have to handle subwidgets
virtual void ApplyWidgetStyle(bool forceStyle = false);
// helper function to ease native widgets wrapping, called by
// ApplyWidgetStyle -- override this, not ApplyWidgetStyle
virtual void DoApplyWidgetStyle(GtkRcStyle *style);
private:
wxDECLARE_DYNAMIC_CLASS(wxWindowGTK);
wxDECLARE_NO_COPY_CLASS(wxWindowGTK);
};
extern WXDLLIMPEXP_CORE wxWindow *wxFindFocusedChild(wxWindowGTK *win);
#endif // __GTKWINDOWH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/dc.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/dc.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDCH__
#define __GTKDCH__
#include "wx/dc.h"
//-----------------------------------------------------------------------------
// wxDC
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGTKDCImpl : public wxDCImpl
{
public:
wxGTKDCImpl(wxDC *owner);
virtual ~wxGTKDCImpl() { }
#if wxUSE_PALETTE
void SetColourMap( const wxPalette& palette ) { SetPalette(palette); }
#endif // wxUSE_PALETTE
// Resolution in pixels per logical inch
virtual wxSize GetPPI() const;
virtual bool StartDoc( const wxString& WXUNUSED(message) ) { return true; }
virtual void EndDoc() { }
virtual void StartPage() { }
virtual void EndPage() { }
virtual GdkWindow* GetGDKWindow() const { return NULL; }
public:
// implementation
wxCoord XDEV2LOG(wxCoord x) const { return DeviceToLogicalX(x); }
wxCoord XDEV2LOGREL(wxCoord x) const { return DeviceToLogicalXRel(x); }
wxCoord YDEV2LOG(wxCoord y) const { return DeviceToLogicalY(y); }
wxCoord YDEV2LOGREL(wxCoord y) const { return DeviceToLogicalYRel(y); }
wxCoord XLOG2DEV(wxCoord x) const { return LogicalToDeviceX(x); }
wxCoord XLOG2DEVREL(wxCoord x) const { return LogicalToDeviceXRel(x); }
wxCoord YLOG2DEV(wxCoord y) const { return LogicalToDeviceY(y); }
wxCoord YLOG2DEVREL(wxCoord y) const { return LogicalToDeviceYRel(y); }
// base class pure virtuals implemented here
virtual void DoSetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoGetSizeMM(int* width, int* height) const;
private:
wxDECLARE_ABSTRACT_CLASS(wxDC);
};
// this must be defined when wxDC::Blit() honours the DC origian and needed to
// allow wxUniv code in univ/winuniv.cpp to work with versions of wxGTK
// 2.3.[23]
#ifndef wxHAS_WORKING_GTK_DC_BLIT
#define wxHAS_WORKING_GTK_DC_BLIT
#endif
#endif // __GTKDCH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/msgdlg.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/msgdlg.h
// Purpose: wxMessageDialog for GTK+2
// Author: Vaclav Slavik
// Modified by:
// Created: 2003/02/28
// Copyright: (c) Vaclav Slavik, 2003
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __MSGDLG_H__
#define __MSGDLG_H__
#include "wx/defs.h"
#include "wx/dialog.h"
// type is an 'or' (|) of wxOK, wxCANCEL, wxYES_NO
// Returns wxYES/NO/OK/CANCEL
extern WXDLLIMPEXP_DATA_CORE(const wxChar) wxMessageBoxCaptionStr[];
class WXDLLIMPEXP_CORE wxMessageDialog: public wxDialog, public wxMessageDialogBase
{
public:
wxMessageDialog(wxWindow *parent, const wxString& message,
const wxString& caption = wxMessageBoxCaptionStr,
long style = wxOK|wxCENTRE,
const wxPoint& pos = wxDefaultPosition);
virtual ~wxMessageDialog();
int ShowModal();
virtual bool Show( bool WXUNUSED(show) = true ) { return false; }
protected:
// implement some base class methods to do nothing to avoid asserts and
// GTK warnings, since this is not a real wxDialog.
virtual void DoSetSize(int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(sizeFlags) = wxSIZE_AUTO) {}
virtual void DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(width), int WXUNUSED(height)) {}
private:
wxString m_caption;
wxString m_message;
wxDECLARE_DYNAMIC_CLASS(wxMessageDialog);
};
#endif
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/notebook.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/notebook.h
// Purpose: wxNotebook class
// Author: Robert Roebling
// Modified by:
// Copyright: (c) Julian Smart and Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKNOTEBOOKH__
#define __GTKNOTEBOOKH__
//-----------------------------------------------------------------------------
// internal class
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxGtkNotebookPage;
#include "wx/list.h"
WX_DECLARE_LIST(wxGtkNotebookPage, wxGtkNotebookPagesList);
//-----------------------------------------------------------------------------
// wxNotebook
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNotebook : public wxNotebookBase
{
public:
// default for dynamic class
wxNotebook();
// the same arguments as for wxControl
wxNotebook(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
// Create() function
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
// dtor
virtual ~wxNotebook();
// accessors
// ---------
// set the currently selected page, return the index of the previously
// selected one (or wxNOT_FOUND on error)
// NB: this function will _not_ generate wxEVT_NOTEBOOK_PAGE_xxx events
int SetSelection(size_t nPage) { return DoSetSelection(nPage, SetSelection_SendEvent); }
// get the currently selected page
int GetSelection() const;
// changes selected page without sending events
int ChangeSelection(size_t nPage) { return DoSetSelection(nPage); }
// set/get the title of a page
bool SetPageText(size_t nPage, const wxString& strText);
wxString GetPageText(size_t nPage) const;
// sets/returns item's image index in the current image list
int GetPageImage(size_t nPage) const;
bool SetPageImage(size_t nPage, int nImage);
// control the appearance of the notebook pages
// set the size (the same for all pages)
void SetPageSize(const wxSize& size);
// set the padding between tabs (in pixels)
void SetPadding(const wxSize& padding);
// sets the size of the tabs (assumes all tabs are the same size)
void SetTabSize(const wxSize& sz);
virtual int HitTest(const wxPoint& pt, long *flags = NULL) const;
// operations
// ----------
// remove all pages
bool DeleteAllPages();
// adds a new page to the notebook (it will be deleted by the notebook,
// don't delete it yourself). If bSelect, this page becomes active.
// the same as AddPage(), but adds it at the specified position
bool InsertPage( size_t position,
wxNotebookPage *win,
const wxString& strText,
bool bSelect = false,
int imageId = NO_IMAGE );
// handler for tab navigation
// --------------------------
void OnNavigationKey(wxNavigationKeyEvent& event);
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation
// --------------
#if wxUSE_CONSTRAINTS
void SetConstraintSizes(bool recurse);
bool DoPhase(int phase);
#endif
// set all page's attributes
void DoApplyWidgetStyle(GtkRcStyle *style);
// report if window belongs to notebook
bool IsOwnGtkWindow( GdkWindow *window );
// common part of all ctors
void Init();
// helper function
wxGtkNotebookPage* GetNotebookPage(int page) const;
// the additional page data (the pages themselves are in m_pages array)
wxGtkNotebookPagesList m_pagesData;
// for reasons explained in gtk/notebook.cpp we store the current
// selection internally instead of querying the notebook for it
int m_selection;
// flag set to true while we're inside "switch_page" callback
bool m_inSwitchPage;
// flag set to true when the switch-page signal has been programmatically generated
bool m_skipNextPageChangeEvent;
protected:
// remove one page from the notebook but do not destroy it
virtual wxNotebookPage *DoRemovePage(size_t nPage);
int DoSetSelection(size_t nPage, int flags = 0);
private:
// the padding set by SetPadding()
int m_padding;
wxDECLARE_DYNAMIC_CLASS(wxNotebook);
wxDECLARE_EVENT_TABLE();
};
#endif
// __GTKNOTEBOOKH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/statline.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/statline.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSTATICLINEH__
#define __GTKSTATICLINEH__
#include "wx/defs.h"
#if wxUSE_STATLINE
// ----------------------------------------------------------------------------
// wxStaticLine
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStaticLine : public wxStaticLineBase
{
public:
wxStaticLine();
wxStaticLine(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint &pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLI_HORIZONTAL,
const wxString &name = wxStaticLineNameStr);
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLI_HORIZONTAL,
const wxString &name = wxStaticLineNameStr);
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
private:
wxDECLARE_DYNAMIC_CLASS(wxStaticLine);
};
#endif // wxUSE_STATLINE
#endif // __GTKSTATICLINEH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/frame.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/frame.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFRAMEH__
#define __GTKFRAMEH__
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxMDIChildFrame;
class WXDLLIMPEXP_FWD_CORE wxMDIClientWindow;
class WXDLLIMPEXP_FWD_CORE wxMenu;
class WXDLLIMPEXP_FWD_CORE wxMenuBar;
class WXDLLIMPEXP_FWD_CORE wxToolBar;
class WXDLLIMPEXP_FWD_CORE wxStatusBar;
//-----------------------------------------------------------------------------
// wxFrame
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFrame : public wxFrameBase
{
public:
// construction
wxFrame() { Init(); }
wxFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
#if wxUSE_STATUSBAR
virtual void PositionStatusBar();
virtual wxStatusBar* CreateStatusBar(int number = 1,
long style = wxSTB_DEFAULT_STYLE,
wxWindowID id = 0,
const wxString& name = wxStatusLineNameStr);
void SetStatusBar(wxStatusBar *statbar);
#endif // wxUSE_STATUSBAR
#if wxUSE_TOOLBAR
virtual wxToolBar* CreateToolBar(long style = -1,
wxWindowID id = -1,
const wxString& name = wxToolBarNameStr);
void SetToolBar(wxToolBar *toolbar);
#endif // wxUSE_TOOLBAR
wxPoint GetClientAreaOrigin() const { return wxPoint(0, 0); }
// implementation from now on
// --------------------------
// GTK callbacks
virtual void GtkOnSize( int x, int y, int width, int height );
virtual void OnInternalIdle();
bool m_menuBarDetached;
int m_menuBarHeight;
bool m_toolBarDetached;
protected:
// common part of all ctors
void Init();
// override wxWindow methods to take into account tool/menu/statusbars
virtual void DoSetClientSize(int width, int height);
virtual void DoGetClientSize( int *width, int *height ) const;
#if wxUSE_MENUS_NATIVE
virtual void DetachMenuBar();
virtual void AttachMenuBar(wxMenuBar *menubar);
public:
// Menu size is dynamic now, call this whenever it might change.
void UpdateMenuBarSize();
#endif // wxUSE_MENUS_NATIVE
wxDECLARE_DYNAMIC_CLASS(wxFrame);
};
#endif // __GTKFRAMEH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/dataobj.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/dataobj.h
// Purpose: declaration of the wxDataObject
// Author: Robert Roebling
// Copyright: (c) 1998, 1999 Vadim Zeitlin, Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_DATAOBJ_H_
#define _WX_GTK_DATAOBJ_H_
// ----------------------------------------------------------------------------
// wxDataObject is the same as wxDataObjectBase under wxGTK
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDataObject : public wxDataObjectBase
{
public:
wxDataObject();
virtual ~wxDataObject();
virtual bool IsSupportedFormat( const wxDataFormat& format, Direction dir = Get ) const;
};
#endif // _WX_GTK_DATAOBJ_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/statbox.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/statbox.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSTATICBOXH__
#define __GTKSTATICBOXH__
//-----------------------------------------------------------------------------
// wxStaticBox
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStaticBox : public wxStaticBoxBase
{
public:
wxStaticBox();
wxStaticBox( wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticBoxNameStr );
bool Create( wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticBoxNameStr );
virtual void SetLabel( const wxString &label );
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation
virtual bool IsTransparentForMouse() const { return TRUE; }
protected:
void DoApplyWidgetStyle(GtkRcStyle *style);
private:
wxDECLARE_DYNAMIC_CLASS(wxStaticBox);
};
#endif // __GTKSTATICBOXH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/control.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/control.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCONTROLH__
#define __GTKCONTROLH__
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/window.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxControl;
typedef struct _GtkLabel GtkLabel;
typedef struct _GtkFrame GtkFrame;
//-----------------------------------------------------------------------------
// wxControl
//-----------------------------------------------------------------------------
// C-linkage function pointer types for GetDefaultAttributesFromGTKWidget
extern "C" {
typedef GtkWidget* (*wxGtkWidgetNew_t)(void);
typedef GtkWidget* (*wxGtkWidgetNewFromStr_t)(const char*);
typedef GtkWidget* (*wxGtkWidgetNewFromAdj_t)(GtkAdjustment*);
}
class WXDLLIMPEXP_CORE wxControl : public wxControlBase
{
public:
wxControl();
wxControl(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr);
virtual void SetLabel( const wxString &label );
virtual wxString GetLabel() const;
virtual wxVisualAttributes GetDefaultAttributes() const;
protected:
virtual wxSize DoGetBestSize() const;
void PostCreation(const wxSize& size);
// sets the label to the given string and also sets it for the given widget
void GTKSetLabelForLabel(GtkLabel *w, const wxString& label);
// as GTKSetLabelForLabel() but for a GtkFrame widget
void GTKSetLabelForFrame(GtkFrame *w, const wxString& label);
// remove mnemonics ("&"s) from the label
static wxString GTKRemoveMnemonics(const wxString& label);
// These are used by GetDefaultAttributes
static wxVisualAttributes
GetDefaultAttributesFromGTKWidget(GtkWidget* widget,
bool useBase = false,
int state = -1);
static wxVisualAttributes
GetDefaultAttributesFromGTKWidget(wxGtkWidgetNew_t,
bool useBase = false,
int state = -1);
static wxVisualAttributes
GetDefaultAttributesFromGTKWidget(wxGtkWidgetNewFromStr_t,
bool useBase = false,
int state = -1);
static wxVisualAttributes
GetDefaultAttributesFromGTKWidget(wxGtkWidgetNewFromAdj_t,
bool useBase = false,
int state = -1);
// Widgets that use the style->base colour for the BG colour should
// override this and return true.
virtual bool UseGTKStyleBase() const { return false; }
// this field contains the label in wx format, i.e. with "&" mnemonics
wxString m_label;
private:
wxDECLARE_DYNAMIC_CLASS(wxControl);
};
#endif // __GTKCONTROLH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/colordlg.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/colordlg.h
// Purpose: wxColourDialog
// Author: Vaclav Slavik
// Modified by:
// Created: 2004/06/04
// Copyright: (c) Vaclav Slavik, 2004
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __COLORDLG_H__
#define __COLORDLG_H__
#include "wx/defs.h"
#include "wx/gdicmn.h"
#include "wx/dialog.h"
class WXDLLIMPEXP_CORE wxColourDialog : public wxDialog
{
public:
wxColourDialog() {}
wxColourDialog(wxWindow *parent,
wxColourData *data = NULL);
virtual ~wxColourDialog() {}
bool Create(wxWindow *parent, wxColourData *data = NULL);
wxColourData &GetColourData() { return m_data; }
virtual int ShowModal();
protected:
// implement some base class methods to do nothing to avoid asserts and
// GTK warnings, since this is not a real wxDialog.
virtual void DoSetSize(int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(sizeFlags) = wxSIZE_AUTO) {}
virtual void DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(width), int WXUNUSED(height)) {}
// copy data between the dialog and m_colourData:
void ColourDataToDialog();
void DialogToColourData();
wxColourData m_data;
wxDECLARE_DYNAMIC_CLASS(wxColourDialog);
};
#endif
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/button.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/button.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKBUTTONH__
#define __GTKBUTTONH__
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/list.h"
//-----------------------------------------------------------------------------
// wxButton
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxButton: public wxButtonBase
{
public:
wxButton();
wxButton(wxWindow *parent, wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
virtual ~wxButton();
bool Create(wxWindow *parent, wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual wxWindow *SetDefault();
virtual void SetLabel( const wxString &label );
virtual bool Enable( bool enable = TRUE );
// implementation
// --------------
void DoApplyWidgetStyle(GtkRcStyle *style);
bool IsOwnGtkWindow( GdkWindow *window );
// Since this wxButton doesn't derive from wxButtonBase (why?) we need
// to override this here too...
virtual bool ShouldInheritColours() const { return false; }
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
virtual wxSize DoGetBestSize() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxButton);
};
#endif // __GTKBUTTONH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/treectrl.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/treectrl.h
// Purpose: wxTreeCtrl class
// Author: Denis Pershin
// Modified by:
// Created: 08/08/98
// Copyright: (c) Denis Pershin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TREECTRL_H_
#define _WX_TREECTRL_H_
#include "wx/textctrl.h"
#include "wx/imaglist.h"
#include <gtk/gtk.h>
// the type for "untyped" data
typedef long wxDataType;
// fwd decl
class WXDLLIMPEXP_CORE wxImageList;
struct wxTreeViewItem;
// a callback function used for sorting tree items, it should return -1 if the
// first item precedes the second, +1 if the second precedes the first or 0 if
// they're equivalent
class WXDLLIMPEXP_FWD_CORE wxTreeItemData;
typedef int (*wxTreeItemCmpFunc)(wxTreeItemData *item1, wxTreeItemData *item2);
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// values for the `flags' parameter of wxTreeCtrl::HitTest() which determine
// where exactly the specified point is situated:
// above the client area.
static const int wxTREE_HITTEST_ABOVE = 0x0001;
// below the client area.
static const int wxTREE_HITTEST_BELOW = 0x0002;
// in the client area but below the last item.
static const int wxTREE_HITTEST_NOWHERE = 0x0004;
// on the button associated with an item.
static const int wxTREE_HITTEST_ONITEMBUTTON = 0x0010;
// on the bitmap associated with an item.
static const int wxTREE_HITTEST_ONITEMICON = 0x0020;
// in the indentation associated with an item.
static const int wxTREE_HITTEST_ONITEMINDENT = 0x0040;
// on the label (string) associated with an item.
static const int wxTREE_HITTEST_ONITEMLABEL = 0x0080;
// in the area to the right of an item.
static const int wxTREE_HITTEST_ONITEMRIGHT = 0x0100;
// on the state icon for a tree view item that is in a user-defined state.
static const int wxTREE_HITTEST_ONITEMSTATEICON = 0x0200;
// to the right of the client area.
static const int wxTREE_HITTEST_TOLEFT = 0x0400;
// to the left of the client area.
static const int wxTREE_HITTEST_TORIGHT = 0x0800;
// anywhere on the item
static const int wxTREE_HITTEST_ONITEM = wxTREE_HITTEST_ONITEMICON |
wxTREE_HITTEST_ONITEMLABEL |
wxTREE_HITTEST_ONITEMSTATEICON;
// ----------------------------------------------------------------------------
// wxTreeItemId identifies an element of the tree. In this implementation, it's
// just a trivial wrapper around GTK GtkTreeItem *. It's opaque for the
// application.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTreeItemId {
public:
// ctors
wxTreeItemId() { m_itemId = NULL; }
// default copy ctor/assignment operator are ok for us
// accessors
// is this a valid tree item?
bool IsOk() const { return m_itemId != NULL; }
// conversion to/from either real (system-dependent) tree item id or
// to "long" which used to be the type for tree item ids in previous
// versions of wxWidgets
// for wxTreeCtrl usage only
wxTreeItemId(GtkTreeItem *itemId) { m_itemId = itemId; }
operator GtkTreeItem *() const { return m_itemId; }
void operator =(GtkTreeItem *item) { m_itemId = item; }
protected:
GtkTreeItem *m_itemId;
};
// ----------------------------------------------------------------------------
// wxTreeItemData is some (arbitrary) user class associated with some item. The
// main advantage of having this class (compared to old untyped interface) is
// that wxTreeItemData's are destroyed automatically by the tree and, as this
// class has virtual dtor, it means that the memory will be automatically
// freed. OTOH, we don't just use wxObject instead of wxTreeItemData because
// the size of this class is critical: in any real application, each tree leaf
// will have wxTreeItemData associated with it and number of leaves may be
// quite big.
//
// Because the objects of this class are deleted by the tree, they should
// always be allocated on the heap!
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTreeItemData : private wxTreeItemId {
public:
// default ctor/copy ctor/assignment operator are ok
// dtor is virtual and all the items are deleted by the tree control when
// it's deleted, so you normally don't have to care about freeing memory
// allocated in your wxTreeItemData-derived class
virtual ~wxTreeItemData() { }
// accessors: set/get the item associated with this node
void SetId(const wxTreeItemId& id) { m_itemId = id; }
const wxTreeItemId& GetId() const { return (wxTreeItemId&) m_itemId; }
};
class WXDLLIMPEXP_CORE wxTreeCtrl: public wxControl {
public:
// creation
// --------
wxTreeCtrl() { Init(); }
wxTreeCtrl(wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = "wxTreeCtrl") {
Create(parent, id, pos, size, style, validator, name);
}
virtual ~wxTreeCtrl();
bool Create(wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = "wxTreeCtrl");
// accessors
// ---------
// get the total number of items in the control
virtual unsigned int GetCount() const;
// indent is the number of pixels the children are indented relative to
// the parents position. SetIndent() also redraws the control
// immediately.
unsigned int GetIndent() const;
void SetIndent(unsigned int indent);
// image list: these functions allow to associate an image list with
// the control and retrieve it. Note that the control does _not_ delete
// the associated image list when it's deleted in order to allow image
// lists to be shared between different controls.
//
// The normal image list is for the icons which correspond to the
// normal tree item state (whether it is selected or not).
// Additionally, the application might choose to show a state icon
// which corresponds to an app-defined item state (for example,
// checked/unchecked) which are taken from the state image list.
wxImageList *GetImageList() const;
wxImageList *GetStateImageList() const;
void SetImageList(wxImageList *imageList);
void SetStateImageList(wxImageList *imageList);
// Functions to work with tree ctrl items. Unfortunately, they can _not_ be
// member functions of wxTreeItem because they must know the tree the item
// belongs to for Windows implementation and storing the pointer to
// wxTreeCtrl in each wxTreeItem is just too much waste.
// accessors
// ---------
// retrieve items label
wxString GetItemText(const wxTreeItemId& item) const;
// get the normal item image
int GetItemImage(const wxTreeItemId& item) const;
// get the data associated with the item
wxTreeItemData *GetItemData(const wxTreeItemId& item) const;
// modifiers
// ---------
// set items label
void SetItemText(const wxTreeItemId& item, const wxString& text);
// set the normal item image
void SetItemImage(const wxTreeItemId& item, int image);
// associate some data with the item
void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
// item status inquiries
// ---------------------
// is the item visible (it might be outside the view or not expanded)?
bool IsVisible(const wxTreeItemId& item) const;
// does the item has any children?
bool ItemHasChildren(const wxTreeItemId& item) const;
// is the item expanded (only makes sense if HasChildren())?
bool IsExpanded(const wxTreeItemId& item) const;
// is this item currently selected (the same as has focus)?
bool IsSelected(const wxTreeItemId& item) const;
// number of children
// ------------------
// if 'recursively' is false, only immediate children count, otherwise
// the returned number is the number of all items in this branch
size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = true);
// navigation
// ----------
// wxTreeItemId.IsOk() will return false if there is no such item
// get the root tree item
wxTreeItemId GetRootItem() const;
// get the item currently selected (may return NULL if no selection)
wxTreeItemId GetSelection() const;
// get the parent of this item (may return NULL if root)
wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
// for this enumeration function you must pass in a "cookie" parameter
// which is opaque for the application but is necessary for the library
// to make these functions reentrant (i.e. allow more than one
// enumeration on one and the same object simultaneously). Of course,
// the "cookie" passed to GetFirstChild() and GetNextChild() should be
// the same!
// get the last child of this item - this method doesn't use cookies
wxTreeItemId GetLastChild(const wxTreeItemId& item) const;
// get the next sibling of this item
wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
// get the previous sibling
wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
// get first visible item
wxTreeItemId GetFirstVisibleItem() const;
// get the next visible item: item must be visible itself!
// see IsVisible() and wxTreeCtrl::GetFirstVisibleItem()
wxTreeItemId GetNextVisible(const wxTreeItemId& item) const;
// get the previous visible item: item must be visible itself!
wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const;
// operations
// ----------
// add the root node to the tree
wxTreeItemId AddRoot(const wxString& text,
int image = -1, int selectedImage = -1,
wxTreeItemData *data = NULL);
// insert a new item in as the first child of the parent
wxTreeItemId PrependItem(const wxTreeItemId& parent,
const wxString& text,
int image = -1, int selectedImage = -1,
wxTreeItemData *data = NULL);
// insert a new item after a given one
wxTreeItemId InsertItem(const wxTreeItemId& parent,
const wxTreeItemId& idPrevious,
const wxString& text,
int image = -1, int selectedImage = -1,
wxTreeItemData *data = NULL);
// insert a new item in as the last child of the parent
wxTreeItemId AppendItem(const wxTreeItemId& parent,
const wxString& text,
int image = -1, int selectedImage = -1,
wxTreeItemData *data = NULL);
// delete this item and associated data if any
void Delete(const wxTreeItemId& item);
// delete all items from the tree
void DeleteAllItems();
// expand this item
void Expand(const wxTreeItemId& item);
// collapse the item without removing its children
void Collapse(const wxTreeItemId& item);
// collapse the item and remove all children
void CollapseAndReset(const wxTreeItemId& item);
// toggles the current state
void Toggle(const wxTreeItemId& item);
// remove the selection from currently selected item (if any)
void Unselect();
// select this item
void SelectItem(const wxTreeItemId& item);
// make sure this item is visible (expanding the parent item and/or
// scrolling to this item if necessary)
void EnsureVisible(const wxTreeItemId& item);
// scroll to this item (but don't expand its parent)
void ScrollTo(const wxTreeItemId& item);
// start editing the item label: this (temporarily) replaces the item
// with a one line edit control. The item will be selected if it hadn't
// been before. textCtrlClass parameter allows you to create an edit
// control of arbitrary user-defined class deriving from wxTextCtrl.
wxTextCtrl* EditLabel(const wxTreeItemId& item,
wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl));
// returns the same pointer as StartEdit() if the item is being edited,
// NULL otherwise (it's assumed that no more than one item may be
// edited simultaneously)
wxTextCtrl* GetEditControl() const;
// end editing and accept or discard the changes to item label
void EndEditLabel(const wxTreeItemId& item, bool discardChanges = false);
// sort the children of this item using the specified callback function
// (it should return -1, 0 or +1 as usual), if it's not specified
// alphabetical comparaison is performed.
//
// NB: this function is not reentrant!
void SortChildren(const wxTreeItemId& item,
wxTreeItemCmpFunc *cmpFunction = NULL);
// use Set/GetImageList and Set/GetStateImageList
wxImageList *GetImageList(int) const
{ return GetImageList(); }
void SendExpanding(const wxTreeItemId& item);
void SendExpanded(const wxTreeItemId& item);
void SendCollapsing(const wxTreeItemId& item);
void SendCollapsed(const wxTreeItemId& item);
void SendSelChanging(const wxTreeItemId& item);
void SendSelChanged(const wxTreeItemId& item);
protected:
wxTreeItemId m_editItem;
GtkTree *m_tree;
GtkTreeItem *m_anchor;
wxTextCtrl* m_textCtrl;
wxImageList* m_imageListNormal;
wxImageList* m_imageListState;
long m_curitemId;
void SendMessage(wxEventType command, const wxTreeItemId& item);
// GtkTreeItem *findGtkTreeItem(wxTreeCtrlId &id) const;
// the common part of all ctors
void Init();
// insert a new item in as the last child of the parent
wxTreeItemId p_InsertItem(GtkTreeItem *p,
const wxString& text,
int image, int selectedImage,
wxTreeItemData *data);
wxDECLARE_DYNAMIC_CLASS(wxTreeCtrl);
};
#endif
// _WX_TREECTRL_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/textctrl.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/textctrl.h
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKTEXTCTRLH__
#define __GTKTEXTCTRLH__
//-----------------------------------------------------------------------------
// wxTextCtrl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTextCtrl: public wxTextCtrlBase
{
public:
wxTextCtrl() { Init(); }
wxTextCtrl(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 = wxTextCtrlNameStr);
virtual ~wxTextCtrl();
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 = wxTextCtrlNameStr);
// implement base class pure virtuals
// ----------------------------------
virtual int GetLineLength(long lineNo) const;
virtual wxString GetLineText(long lineNo) const;
virtual int GetNumberOfLines() const;
virtual bool IsModified() const;
virtual bool IsEditable() const;
// If the return values from and to are the same, there is no selection.
virtual void GetSelection(long* from, long* to) const;
// operations
// ----------
// editing
virtual void Clear();
virtual void Replace(long from, long to, const wxString& value);
virtual void Remove(long from, long to);
// sets/clears the dirty flag
virtual void MarkDirty();
virtual void DiscardEdits();
virtual void SetMaxLength(unsigned long len);
// writing text inserts it at the current position, appending always
// inserts it at the end
virtual void WriteText(const wxString& text);
virtual void AppendText(const wxString& text);
// apply text attribute to the range of text (only works with richedit
// controls)
virtual bool SetStyle(long start, long end, const wxTextAttr& style);
// 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;
virtual bool PositionToXY(long pos, long *x, long *y) const;
virtual void ShowPosition(long pos);
// Clipboard operations
virtual void Copy();
virtual void Cut();
virtual void Paste();
// Undo/redo
virtual void Undo();
virtual void Redo();
virtual bool CanUndo() const;
virtual bool CanRedo() const;
// Insertion point
virtual void SetInsertionPoint(long pos);
virtual void SetInsertionPointEnd();
virtual long GetInsertionPoint() const;
virtual wxTextPos GetLastPosition() const;
virtual void SetSelection(long from, long to);
virtual void SetEditable(bool editable);
virtual void DoEnable( bool enable );
// Implementation from now on
void OnDropFiles( wxDropFilesEvent &event );
void OnChar( wxKeyEvent &event );
void OnCut(wxCommandEvent& event);
void OnCopy(wxCommandEvent& event);
void OnPaste(wxCommandEvent& event);
void OnUndo(wxCommandEvent& event);
void OnRedo(wxCommandEvent& event);
void OnUpdateCut(wxUpdateUIEvent& event);
void OnUpdateCopy(wxUpdateUIEvent& event);
void OnUpdatePaste(wxUpdateUIEvent& event);
void OnUpdateUndo(wxUpdateUIEvent& event);
void OnUpdateRedo(wxUpdateUIEvent& event);
bool SetFont(const wxFont& font);
bool SetForegroundColour(const wxColour& colour);
bool SetBackgroundColour(const wxColour& colour);
GtkWidget* GetConnectWidget();
bool IsOwnGtkWindow( GdkWindow *window );
void DoApplyWidgetStyle(GtkRcStyle *style);
void CalculateScrollbar();
void OnInternalIdle();
void SetUpdateFont(bool update) { m_updateFont = update; }
void UpdateFontIfNeeded();
void SetModified() { m_modified = true; }
// textctrl specific scrolling
virtual bool ScrollLines(int lines);
virtual bool ScrollPages(int pages);
// implementation only from now on
// tell the control to ignore next text changed signal
void IgnoreNextTextUpdate();
// should we ignore the changed signal? always resets the flag
bool IgnoreTextUpdate();
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
virtual wxSize DoGetBestSize() const;
// common part of all ctors
void Init();
// overridden wxWindow methods
virtual void DoFreeze();
virtual void DoThaw();
// get the vertical adjustment, if any, NULL otherwise
GtkAdjustment *GetVAdj() const;
// scroll the control by the given number of pixels, return true if the
// scroll position changed
bool DoScroll(GtkAdjustment *adj, int diff);
// Widgets that use the style->base colour for the BG colour should
// override this and return true.
virtual bool UseGTKStyleBase() const { return true; }
virtual void DoSetValue(const wxString &value, int flags = 0);
virtual wxString DoGetValue() const;
private:
// change the font for everything in this control
void ChangeFontGlobally();
GtkWidget *m_text;
GtkWidget *m_vScrollbar;
bool m_modified:1;
bool m_vScrollbarVisible:1;
bool m_updateFont:1;
bool m_ignoreNextUpdate:1;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxTextCtrl);
};
#endif // __GTKTEXTCTRLH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/private/mnemonics.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/private/mnemonics.h
// Purpose: helper functions for dealing with GTK+ mnemonics
// Author: Vadim Zeitlin
// Created: 2007-11-12
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _GTK_PRIVATE_MNEMONICS_H_
#define _GTK_PRIVATE_MNEMONICS_H_
#if wxUSE_CONTROLS || wxUSE_MENUS
#include "wx/string.h"
// ----------------------------------------------------------------------------
// functions to convert between wxWidgets and GTK+ string containing mnemonics
// ----------------------------------------------------------------------------
// remove all mnemonics from a string
wxString wxGTKRemoveMnemonics(const wxString& label);
// convert a wx string with '&' to GTK+ string with '_'s
wxString wxConvertMnemonicsToGTK(const wxString& label);
// convert a wx string with '&' to indicate mnemonics as well as HTML entities
// to a GTK+ string with "&" used instead of '&', i.e. suitable for use
// with GTK+ functions using markup strings
wxString wxConvertMnemonicsToGTKMarkup(const wxString& label);
// convert GTK+ string with '_'s to wx string with '&'s
wxString wxConvertMnemonicsFromGTK(const wxString& label);
#endif // wxUSE_CONTROLS || wxUSE_MENUS
#endif // _GTK_PRIVATE_MNEMONICS_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/private/addremovectrl.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/private/addremovectrl.h
// Purpose: GTK specific wxAddRemoveImpl implementation
// Author: Vadim Zeitlin
// Created: 2015-02-05
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_PRIVATE_ADDREMOVECTRL_H_
#define _WX_GTK_PRIVATE_ADDREMOVECTRL_H_
#include "wx/artprov.h"
#include "wx/bmpbuttn.h"
#include "wx/toolbar.h"
#include <gtk/gtk.h>
// ----------------------------------------------------------------------------
// wxAddRemoveImpl
// ----------------------------------------------------------------------------
class wxAddRemoveImpl : public wxAddRemoveImplBase
{
public:
wxAddRemoveImpl(wxAddRemoveAdaptor* adaptor,
wxAddRemoveCtrl* parent,
wxWindow* ctrlItems)
: wxAddRemoveImplBase(adaptor, parent, ctrlItems),
m_tbar(new wxToolBar(parent, wxID_ANY))
{
m_tbar->AddTool(wxID_ADD, wxString(), GetNamedBitmap("list-add"));
m_tbar->AddTool(wxID_REMOVE, wxString(), GetNamedBitmap("list-remove"));
#if defined(__WXGTK3__) && !defined(__WXUNIVERSAL__)
// Tweak the toolbar appearance to correspond to how the toolbars used
// in other GNOME applications for similar purposes look.
GtkToolbar* const toolbar = m_tbar->GTKGetToolbar();
GtkStyleContext* context = gtk_widget_get_style_context(GTK_WIDGET(toolbar));
gtk_style_context_add_class(context, GTK_STYLE_CLASS_INLINE_TOOLBAR);
gtk_style_context_set_junction_sides(context, GTK_JUNCTION_TOP);
#endif // GTK+3
wxSizer* const sizerTop = new wxBoxSizer(wxVERTICAL);
sizerTop->Add(ctrlItems, wxSizerFlags(1).Expand());
sizerTop->Add(m_tbar, wxSizerFlags().Expand());
parent->SetSizer(sizerTop);
m_tbar->Bind(wxEVT_UPDATE_UI,
&wxAddRemoveImplBase::OnUpdateUIAdd, this, wxID_ADD);
m_tbar->Bind(wxEVT_UPDATE_UI,
&wxAddRemoveImplBase::OnUpdateUIRemove, this, wxID_REMOVE);
m_tbar->Bind(wxEVT_TOOL, &wxAddRemoveImplBase::OnAdd, this, wxID_ADD);
m_tbar->Bind(wxEVT_TOOL, &wxAddRemoveImplBase::OnRemove, this, wxID_REMOVE);
}
virtual void SetButtonsToolTips(const wxString& addtip,
const wxString& removetip) wxOVERRIDE
{
m_tbar->SetToolShortHelp(wxID_ADD, addtip);
m_tbar->SetToolShortHelp(wxID_REMOVE, removetip);
}
private:
static wxBitmap GetNamedBitmap(const wxString& name)
{
// GTK UI guidelines recommend using "symbolic" versions of the icons
// for these buttons, so try them first but fall back to the normal
// ones if symbolic theme is not installed.
wxBitmap bmp = wxArtProvider::GetBitmap(name + "-symbolic", wxART_MENU);
if ( !bmp.IsOk() )
bmp = wxArtProvider::GetBitmap(name, wxART_MENU);
return bmp;
}
wxToolBar* const m_tbar;
};
#endif // _WX_GTK_PRIVATE_ADDREMOVECTRL_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/gtk1/private/timer.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/private/timer.h
// Purpose: wxTimerImpl for wxGTK
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK1_PRIVATE_TIMER_H_
#define _WX_GTK1_PRIVATE_TIMER_H_
#include "wx/private/timer.h"
//-----------------------------------------------------------------------------
// wxTimer
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGTKTimerImpl : public wxTimerImpl
{
public:
wxGTKTimerImpl(wxTimer *timer) : wxTimerImpl(timer) { m_tag = -1; }
virtual bool Start(int millisecs = -1, bool oneShot = FALSE);
virtual void Stop();
virtual bool IsRunning() const { return m_tag != -1; }
private:
// registered timeout id, -1 if the timer isn't running
int m_tag;
};
#endif // _WX_GTK1_PRIVATE_TIMER_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/setup.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/setup.h
// Purpose: Configuration for the universal build of the library
// Author: Julian Smart
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
/* --- start common options --- */
// ----------------------------------------------------------------------------
// global settings
// ----------------------------------------------------------------------------
// define this to 0 when building wxBase library - this can also be done from
// makefile/project file overriding the value here
#ifndef wxUSE_GUI
#define wxUSE_GUI 1
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// compatibility settings
// ----------------------------------------------------------------------------
// This setting determines the compatibility with 2.8 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_2_8 0
// This setting determines the compatibility with 3.0 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_3_0 1
// MSW-only: Set to 0 for accurate dialog units, else 1 for old behaviour when
// default system font is used for wxWindow::GetCharWidth/Height() instead of
// the current font.
//
// Default is 0
//
// Recommended setting: 0
#define wxDIALOG_UNIT_COMPATIBILITY 0
// Provide unsafe implicit conversions in wxString to "const char*" or
// "std::string" (depending on wxUSE_STD_STRING_CONV_IN_WXSTRING value).
//
// Default is 1 but only for compatibility reasons, it is recommended to set
// this to 0 because converting wxString to a narrow (non-Unicode) string may
// fail unless a locale using UTF-8 encoding is used, which is never the case
// under MSW, for example, hence such conversions can result in silent data
// loss.
//
// Recommended setting: 0
#define wxUSE_UNSAFE_WXSTRING_CONV 1
// If set to 1, enables "reproducible builds", i.e. build output should be
// exactly the same if the same build is redone again. As using __DATE__ and
// __TIME__ macros clearly makes the build irreproducible, setting this option
// to 1 disables their use in the library code.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_REPRODUCIBLE_BUILD 0
// ----------------------------------------------------------------------------
// debugging settings
// ----------------------------------------------------------------------------
// wxDEBUG_LEVEL will be defined as 1 in wx/debug.h so normally there is no
// need to define it here. You may do it for two reasons: either completely
// disable/compile out the asserts in release version (then do it inside #ifdef
// NDEBUG) or, on the contrary, enable more asserts, including the usually
// disabled ones, in the debug build (then do it inside #ifndef NDEBUG)
//
// #ifdef NDEBUG
// #define wxDEBUG_LEVEL 0
// #else
// #define wxDEBUG_LEVEL 2
// #endif
// wxHandleFatalExceptions() may be used to catch the program faults at run
// time and, instead of terminating the program with a usual GPF message box,
// call the user-defined wxApp::OnFatalException() function. If you set
// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
//
// This setting is for Win32 only and can only be enabled if your compiler
// supports Win32 structured exception handling (currently only VC++ does)
//
// Default is 1
//
// Recommended setting: 1 if your compiler supports it.
#define wxUSE_ON_FATAL_EXCEPTION 1
// Set this to 1 to be able to generate a human-readable (unlike
// machine-readable minidump created by wxCrashReport::Generate()) stack back
// trace when your program crashes using wxStackWalker
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_STACKWALKER 1
// Set this to 1 to compile in wxDebugReport class which allows you to create
// and optionally upload to your web site a debug report consisting of back
// trace of the crash (if wxUSE_STACKWALKER == 1) and other information.
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, it is compiled into a separate library so there
// is no overhead if you don't use it
#define wxUSE_DEBUGREPORT 1
// Generic comment about debugging settings: they are very useful if you don't
// use any other memory leak detection tools such as Purify/BoundsChecker, but
// are probably redundant otherwise. Also, Visual C++ CRT has the same features
// as wxWidgets memory debugging subsystem built in since version 5.0 and you
// may prefer to use it instead of built in memory debugging code because it is
// faster and more fool proof.
//
// Using VC++ CRT memory debugging is enabled by default in debug build (_DEBUG
// is defined) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
// and if __NO_VC_CRTDBG__ is not defined.
// The rest of the options in this section are obsolete and not supported,
// enable them at your own risk.
// If 1, enables wxDebugContext, for writing error messages to file, etc. If
// __WXDEBUG__ is not defined, will still use the normal memory operators.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_CONTEXT 0
// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
// __WXDEBUG__ is also defined.
//
// WARNING: this code may not work with all architectures, especially if
// alignment is an issue. This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 1 if you are not using a memory debugging tool, else 0
#define wxUSE_MEMORY_TRACING 0
// In debug mode, cause new and delete to be redefined globally.
// If this causes problems (e.g. link errors which is a common problem
// especially if you use another library which also redefines the global new
// and delete), set this to 0.
// This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
// this causes problems (e.g. link errors), set this to 0. You may need to set
// this to 0 if using templates (at least for VC++). This switch is currently
// ignored for MinGW/Cygwin.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_NEW_ALWAYS 0
// ----------------------------------------------------------------------------
// Unicode support
// ----------------------------------------------------------------------------
// These settings are obsolete: the library is always built in Unicode mode
// now, only set wxUSE_UNICODE to 0 to compile legacy code in ANSI mode if
// absolutely necessary -- updating it is strongly recommended as the ANSI mode
// will disappear completely in future wxWidgets releases.
#ifndef wxUSE_UNICODE
#define wxUSE_UNICODE 1
#endif
// wxUSE_WCHAR_T is required by wxWidgets now, don't change.
#define wxUSE_WCHAR_T 1
// ----------------------------------------------------------------------------
// global features
// ----------------------------------------------------------------------------
// Compile library in exception-safe mode? If set to 1, the library will try to
// behave correctly in presence of exceptions (even though it still will not
// use the exceptions itself) and notify the user code about any unhandled
// exceptions. If set to 0, propagation of the exceptions through the library
// code will lead to undefined behaviour -- but the code itself will be
// slightly smaller and faster.
//
// Note that like wxUSE_THREADS this option is automatically set to 0 if
// wxNO_EXCEPTIONS is defined.
//
// Default is 1
//
// Recommended setting: depends on whether you intend to use C++ exceptions
// in your own code (1 if you do, 0 if you don't)
#define wxUSE_EXCEPTIONS 1
// Set wxUSE_EXTENDED_RTTI to 1 to use extended RTTI
//
// Default is 0
//
// Recommended setting: 0 (this is still work in progress...)
#define wxUSE_EXTENDED_RTTI 0
// Support for message/error logging. This includes wxLogXXX() functions and
// wxLog and derived classes. Don't set this to 0 unless you really know what
// you are doing.
//
// Default is 1
//
// Recommended setting: 1 (always)
#define wxUSE_LOG 1
// Recommended setting: 1
#define wxUSE_LOGWINDOW 1
// Recommended setting: 1
#define wxUSE_LOGGUI 1
// Recommended setting: 1
#define wxUSE_LOG_DIALOG 1
// Support for command line parsing using wxCmdLineParser class.
//
// Default is 1
//
// Recommended setting: 1 (can be set to 0 if you don't use the cmd line)
#define wxUSE_CMDLINE_PARSER 1
// Support for multithreaded applications: if 1, compile in thread classes
// (thread.h) and make the library a bit more thread safe. Although thread
// support is quite stable by now, you may still consider recompiling the
// library without it if you have no use for it - this will result in a
// somewhat smaller and faster operation.
//
// Notice that if wxNO_THREADS is defined, wxUSE_THREADS is automatically reset
// to 0 in wx/chkconf.h, so, for example, if you set USE_THREADS to 0 in
// build/msw/config.* file this value will have no effect.
//
// Default is 1
//
// Recommended setting: 0 unless you do plan to develop MT applications
#define wxUSE_THREADS 1
// If enabled, compiles wxWidgets streams classes
//
// wx stream classes are used for image IO, process IO redirection, network
// protocols implementation and much more and so disabling this results in a
// lot of other functionality being lost.
//
// Default is 1
//
// Recommended setting: 1 as setting it to 0 disables many other things
#define wxUSE_STREAMS 1
// Support for positional parameters (e.g. %1$d, %2$s ...) in wxVsnprintf.
// Note that if the system's implementation does not support positional
// parameters, setting this to 1 forces the use of the wxWidgets implementation
// of wxVsnprintf. The standard vsnprintf() supports positional parameters on
// many Unix systems but usually doesn't under Windows.
//
// Positional parameters are very useful when translating a program since using
// them in formatting strings allow translators to correctly reorder the
// translated sentences.
//
// Default is 1
//
// Recommended setting: 1 if you want to support multiple languages
#define wxUSE_PRINTF_POS_PARAMS 1
// Enable the use of compiler-specific thread local storage keyword, if any.
// This is used for wxTLS_XXX() macros implementation and normally should use
// the compiler-provided support as it's simpler and more efficient, but is
// disabled under Windows in wx/msw/chkconf.h as it can't be used if wxWidgets
// is used in a dynamically loaded Win32 DLL (i.e. using LoadLibrary()) under
// XP as this triggers a bug in compiler TLS support that results in crashes
// when any TLS variables are used.
//
// If you're absolutely sure that your build of wxWidgets is never going to be
// used in such situation, either because it's not going to be linked from any
// kind of plugin or because you only target Vista or later systems, you can
// set this to 2 to force the use of compiler TLS even under MSW.
//
// Default is 1 meaning that compiler TLS is used only if it's 100% safe.
//
// Recommended setting: 2 if you want to have maximal performance and don't
// care about the scenario described above.
#define wxUSE_COMPILER_TLS 1
// ----------------------------------------------------------------------------
// Interoperability with the standard library.
// ----------------------------------------------------------------------------
// Set wxUSE_STL to 1 to enable maximal interoperability with the standard
// library, even at the cost of backwards compatibility.
//
// Default is 0
//
// Recommended setting: 0 as the options below already provide a relatively
// good level of interoperability and changing this option arguably isn't worth
// diverging from the official builds of the library.
#define wxUSE_STL 0
// This is not a real option but is used as the default value for
// wxUSE_STD_IOSTREAM, wxUSE_STD_STRING and wxUSE_STD_CONTAINERS_COMPATIBLY.
//
// Set it to 0 if you want to disable the use of all standard classes
// completely for some reason.
#define wxUSE_STD_DEFAULT 1
// Use standard C++ containers where it can be done without breaking backwards
// compatibility.
//
// This provides better interoperability with the standard library, e.g. with
// this option on it's possible to insert std::vector<> into many wxWidgets
// containers directly.
//
// Default is 1.
//
// Recommended setting is 1 unless you want to avoid all dependencies on the
// standard library.
#define wxUSE_STD_CONTAINERS_COMPATIBLY wxUSE_STD_DEFAULT
// Use standard C++ containers to implement wxVector<>, wxStack<>, wxDList<>
// and wxHashXXX<> classes. If disabled, wxWidgets own (mostly compatible but
// usually more limited) implementations are used which allows to avoid the
// dependency on the C++ run-time library.
//
// Default is 0 for compatibility reasons.
//
// Recommended setting: 1 unless compatibility with the official wxWidgets
// build and/or the existing code is a concern.
#define wxUSE_STD_CONTAINERS 0
// Use standard C++ streams if 1 instead of wx streams in some places. If
// disabled, wx streams are used everywhere and wxWidgets doesn't depend on the
// standard streams library.
//
// Notice that enabling this does not replace wx streams with std streams
// everywhere, in a lot of places wx streams are used no matter what.
//
// Default is 1 if compiler supports it.
//
// Recommended setting: 1 if you use the standard streams anyhow and so
// dependency on the standard streams library is not a
// problem
#define wxUSE_STD_IOSTREAM wxUSE_STD_DEFAULT
// Enable minimal interoperability with the standard C++ string class if 1.
// "Minimal" means that wxString can be constructed from std::string or
// std::wstring but can't be implicitly converted to them. You need to enable
// the option below for the latter.
//
// Default is 1 for most compilers.
//
// Recommended setting: 1 unless you want to ensure your program doesn't use
// the standard C++ library at all.
#define wxUSE_STD_STRING wxUSE_STD_DEFAULT
// Make wxString as much interchangeable with std::[w]string as possible, in
// particular allow implicit conversion of wxString to either of these classes.
// This comes at a price (or a benefit, depending on your point of view) of not
// allowing implicit conversion to "const char *" and "const wchar_t *".
//
// Because a lot of existing code relies on these conversions, this option is
// disabled by default but can be enabled for your build if you don't care
// about compatibility.
//
// Default is 0 if wxUSE_STL has its default value or 1 if it is enabled.
//
// Recommended setting: 0 to remain compatible with the official builds of
// wxWidgets.
#define wxUSE_STD_STRING_CONV_IN_WXSTRING wxUSE_STL
// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
// them. Set this option to 1 to use <iostream.h>, 0 to use <iostream>.
//
// Note that newer compilers (including VC++ 7.1 and later) don't support
// wxUSE_IOSTREAMH == 1 and so <iostream> will be used anyhow.
//
// Default is 0.
//
// Recommended setting: 0, only set to 1 if you use a really old compiler
#define wxUSE_IOSTREAMH 0
// ----------------------------------------------------------------------------
// non GUI features selection
// ----------------------------------------------------------------------------
// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
// integer which is implemented in terms of native 64 bit integers if any or
// uses emulation otherwise.
//
// This class is required by wxDateTime and so you should enable it if you want
// to use wxDateTime. For most modern platforms, it will use the native 64 bit
// integers in which case (almost) all of its functions are inline and it
// almost does not take any space, so there should be no reason to switch it
// off.
//
// Recommended setting: 1
#define wxUSE_LONGLONG 1
// Set wxUSE_BASE64 to 1, to compile in Base64 support. This is required for
// storing binary data in wxConfig on most platforms.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_BASE64 1
// Set this to 1 to be able to use wxEventLoop even in console applications
// (i.e. using base library only, without GUI). This is mostly useful for
// processing socket events but is also necessary to use timers in console
// applications
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_CONSOLE_EVENTLOOP 1
// Set wxUSE_(F)FILE to 1 to compile wx(F)File classes. wxFile uses low level
// POSIX functions for file access, wxFFile uses ANSI C stdio.h functions.
//
// Default is 1
//
// Recommended setting: 1 (wxFile is highly recommended as it is required by
// i18n code, wxFileConfig and others)
#define wxUSE_FILE 1
#define wxUSE_FFILE 1
// Use wxFSVolume class providing access to the configured/active mount points
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_FSVOLUME 1
// Use wxSecretStore class for storing passwords using OS-specific facilities.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_SECRETSTORE 1
// Use wxStandardPaths class which allows to retrieve some standard locations
// in the file system
//
// Default is 1
//
// Recommended setting: 1 (may be disabled to save space, but not much)
#define wxUSE_STDPATHS 1
// use wxTextBuffer class: required by wxTextFile
#define wxUSE_TEXTBUFFER 1
// use wxTextFile class: requires wxFile and wxTextBuffer, required by
// wxFileConfig
#define wxUSE_TEXTFILE 1
// i18n support: _() macro, wxLocale class. Requires wxTextFile.
#define wxUSE_INTL 1
// Provide wxFoo_l() functions similar to standard foo() functions but taking
// an extra locale parameter.
//
// Notice that this is fully implemented only for the systems providing POSIX
// xlocale support or Microsoft Visual C++ >= 8 (which provides proprietary
// almost-equivalent of xlocale functions), otherwise wxFoo_l() functions will
// only work for the current user locale and "C" locale. You can use
// wxHAS_XLOCALE_SUPPORT to test whether the full support is available.
//
// Default is 1
//
// Recommended setting: 1 but may be disabled if you are writing programs
// running only in C locale anyhow
#define wxUSE_XLOCALE 1
// Set wxUSE_DATETIME to 1 to compile the wxDateTime and related classes which
// allow to manipulate dates, times and time intervals.
//
// Requires: wxUSE_LONGLONG
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_DATETIME 1
// Set wxUSE_TIMER to 1 to compile wxTimer class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_TIMER 1
// Use wxStopWatch clas.
//
// Default is 1
//
// Recommended setting: 1 (needed by wxSocket)
#define wxUSE_STOPWATCH 1
// Set wxUSE_FSWATCHER to 1 if you want to enable wxFileSystemWatcher
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FSWATCHER 1
// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
// which allow the application to store its settings in the persistent
// storage. Setting this to 1 will also enable on-demand creation of the
// global config object in wxApp.
//
// See also wxUSE_CONFIG_NATIVE below.
//
// Recommended setting: 1
#define wxUSE_CONFIG 1
// If wxUSE_CONFIG is 1, you may choose to use either the native config
// classes under Windows (using .INI files under Win16 and the registry under
// Win32) or the portable text file format used by the config classes under
// Unix.
//
// Default is 1 to use native classes. Note that you may still use
// wxFileConfig even if you set this to 1 - just the config object created by
// default for the applications needs will be a wxRegConfig or wxIniConfig and
// not wxFileConfig.
//
// Recommended setting: 1
#define wxUSE_CONFIG_NATIVE 1
// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
// to connect/disconnect from the network and be notified whenever the dial-up
// network connection is established/terminated. Requires wxUSE_DYNAMIC_LOADER.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DIALUP_MANAGER 1
// Compile in classes for run-time DLL loading and function calling.
// Required by wxUSE_DIALUP_MANAGER.
//
// This setting is for Win32 only
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DYNLIB_CLASS 1
// experimental, don't use for now
#define wxUSE_DYNAMIC_LOADER 1
// Set to 1 to use socket classes
#define wxUSE_SOCKETS 1
// Set to 1 to use ipv6 socket classes (requires wxUSE_SOCKETS)
//
// Notice that currently setting this option under Windows will result in
// programs which can only run on recent OS versions (with ws2_32.dll
// installed) which is why it is disabled by default.
//
// Default is 1.
//
// Recommended setting: 1 if you need IPv6 support
#define wxUSE_IPV6 0
// Set to 1 to enable virtual file systems (required by wxHTML)
#define wxUSE_FILESYSTEM 1
// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ZIP 1
// Set to 1 to enable virtual archive filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ARCHIVE 1
// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_INET 1
// wxArchive classes for accessing archives such as zip and tar
#define wxUSE_ARCHIVE_STREAMS 1
// Set to 1 to compile wxZipInput/OutputStream classes.
#define wxUSE_ZIPSTREAM 1
// Set to 1 to compile wxTarInput/OutputStream classes.
#define wxUSE_TARSTREAM 1
// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
// wxUSE_LIBPNG
#define wxUSE_ZLIB 1
// Set to 1 if liblzma is available to enable wxLZMA{Input,Output}Stream
// classes.
//
// Notice that if you enable this build option when not using configure or
// CMake, you need to ensure that liblzma headers and libraries are available
// (i.e. by building the library yourself or downloading its binaries) and can
// be found, either by copying them to one of the locations searched by the
// compiler/linker by default (e.g. any of the directories in the INCLUDE or
// LIB environment variables, respectively, when using MSVC) or modify the
// make- or project files to add references to these directories.
//
// Default is 0 under MSW, auto-detected by configure.
//
// Recommended setting: 1 if you need LZMA compression.
#define wxUSE_LIBLZMA 0
// If enabled, the code written by Apple will be used to write, in a portable
// way, float on the disk. See extended.c for the license which is different
// from wxWidgets one.
//
// Default is 1.
//
// Recommended setting: 1 unless you don't like the license terms (unlikely)
#define wxUSE_APPLE_IEEE 1
// Joystick support class
#define wxUSE_JOYSTICK 1
// wxFontEnumerator class
#define wxUSE_FONTENUM 1
// wxFontMapper class
#define wxUSE_FONTMAP 1
// wxMimeTypesManager class
#define wxUSE_MIMETYPE 1
// wxProtocol and related classes: if you want to use either of wxFTP, wxHTTP
// or wxURL you need to set this to 1.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_PROTOCOL 1
// The settings for the individual URL schemes
#define wxUSE_PROTOCOL_FILE 1
#define wxUSE_PROTOCOL_FTP 1
#define wxUSE_PROTOCOL_HTTP 1
// Define this to use wxURL class.
#define wxUSE_URL 1
// Define this to use native platform url and protocol support.
// Currently valid only for MS-Windows.
// Note: if you set this to 1, you can open ftp/http/gopher sites
// and obtain a valid input stream for these sites
// even when you set wxUSE_PROTOCOL_FTP/HTTP to 0.
// Doing so reduces the code size.
//
// This code is experimental and subject to change.
#define wxUSE_URL_NATIVE 0
// Support for wxVariant class used in several places throughout the library,
// notably in wxDataViewCtrl API.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size as much as
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
// Support for wxAny class, the successor for wxVariant.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size by a small amount,
// or your compiler cannot for some reason cope with complexity of templates used.
#define wxUSE_ANY 1
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
//
// Default is 0
//
// Recommended setting: 1 if your compiler supports it, if it doesn't please
// contribute us a makefile for src/regex for it
#define wxUSE_REGEX 1
// wxSystemOptions class
#define wxUSE_SYSTEM_OPTIONS 1
// wxSound class
#define wxUSE_SOUND 1
// Use wxMediaCtrl
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_MEDIACTRL 1
// Use wxWidget's XRC XML-based resource system. Recommended.
//
// Default is 1
//
// Recommended setting: 1 (requires wxUSE_XML)
#define wxUSE_XRC 1
// XML parsing classes. Note that their API will change in the future, so
// using wxXmlDocument and wxXmlNode in your app is not recommended.
//
// Default is the same as wxUSE_XRC, i.e. 1 by default.
//
// Recommended setting: 1 (required by XRC)
#define wxUSE_XML wxUSE_XRC
// Use wxWidget's AUI docking system
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_AUI 1
// Use wxWidget's Ribbon classes for interfaces
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_RIBBON 1
// Use wxPropertyGrid.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_PROPGRID 1
// Use wxStyledTextCtrl, a wxWidgets implementation of Scintilla.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STC 1
// Use wxWidget's web viewing classes
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_WEBVIEW 1
// Use the IE wxWebView backend
//
// Default is 1 on MSW
//
// Recommended setting: 1
#ifdef __WXMSW__
#define wxUSE_WEBVIEW_IE 1
#else
#define wxUSE_WEBVIEW_IE 0
#endif
// Use the WebKit wxWebView backend
//
// Default is 1 on GTK and OSX
//
// Recommended setting: 1
#if (defined(__WXGTK__) && !defined(__WXGTK3__)) || defined(__WXOSX__)
#define wxUSE_WEBVIEW_WEBKIT 1
#else
#define wxUSE_WEBVIEW_WEBKIT 0
#endif
// Use the WebKit2 wxWebView backend
//
// Default is 1 on GTK3
//
// Recommended setting: 1
#if defined(__WXGTK3__)
#define wxUSE_WEBVIEW_WEBKIT2 1
#else
#define wxUSE_WEBVIEW_WEBKIT2 0
#endif
// Enable wxGraphicsContext and related classes for a modern 2D drawing API.
//
// Default is 1 except if you're using a compiler without support for GDI+
// under MSW, i.e. gdiplus.h and related headers (MSVC and MinGW >= 4.8 are
// known to have them). For other compilers (e.g. older mingw32) you may need
// to install the headers (and just the headers) yourself. If you do, change
// the setting below manually.
//
// Recommended setting: 1 if supported by the compilation environment
// Notice that we can't use wxCHECK_VISUALC_VERSION() nor wxCHECK_GCC_VERSION()
// here as this file is included from wx/platform.h before they're defined.
#if defined(_MSC_VER) || \
(defined(__MINGW32__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 8))
#define wxUSE_GRAPHICS_CONTEXT 1
#else
// Disable support for other Windows compilers, enable it if your compiler
// comes with new enough SDK or you installed the headers manually.
//
// Notice that this will be set by configure under non-Windows platforms
// anyhow so the value there is not important.
#define wxUSE_GRAPHICS_CONTEXT 0
#endif
// Enable wxGraphicsContext implementation using Cairo library.
//
// This is not needed under Windows and detected automatically by configure
// under other systems, however you may set this to 1 manually if you installed
// Cairo under Windows yourself and prefer to use it instead the native GDI+
// implementation.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_CAIRO 0
// ----------------------------------------------------------------------------
// Individual GUI controls
// ----------------------------------------------------------------------------
// You must set wxUSE_CONTROLS to 1 if you are using any controls at all
// (without it, wxControl class is not compiled)
//
// Default is 1
//
// Recommended setting: 1 (don't change except for very special programs)
#define wxUSE_CONTROLS 1
// Support markup in control labels, i.e. provide wxControl::SetLabelMarkup().
// Currently markup is supported only by a few controls and only some ports but
// their number will increase with time.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you want to save on code size)
#define wxUSE_MARKUP 1
// wxPopupWindow class is a top level transient window. It is currently used
// to implement wxTipWindow
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you don't wxUSE_TIPWINDOW)
#define wxUSE_POPUPWIN 1
// wxTipWindow allows to implement the custom tooltips, it is used by the
// context help classes. Requires wxUSE_POPUPWIN.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0)
#define wxUSE_TIPWINDOW 1
// Each of the settings below corresponds to one wxWidgets control. They are
// all switched on by default but may be disabled if you are sure that your
// program (including any standard dialogs it can show!) doesn't need them and
// if you desperately want to save some space. If you use any of these you must
// set wxUSE_CONTROLS as well.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_ACTIVITYINDICATOR 1 // wxActivityIndicator
#define wxUSE_ANIMATIONCTRL 1 // wxAnimationCtrl
#define wxUSE_BANNERWINDOW 1 // wxBannerWindow
#define wxUSE_BUTTON 1 // wxButton
#define wxUSE_BMPBUTTON 1 // wxBitmapButton
#define wxUSE_CALENDARCTRL 1 // wxCalendarCtrl
#define wxUSE_CHECKBOX 1 // wxCheckBox
#define wxUSE_CHECKLISTBOX 1 // wxCheckListBox (requires wxUSE_OWNER_DRAWN)
#define wxUSE_CHOICE 1 // wxChoice
#define wxUSE_COLLPANE 1 // wxCollapsiblePane
#define wxUSE_COLOURPICKERCTRL 1 // wxColourPickerCtrl
#define wxUSE_COMBOBOX 1 // wxComboBox
#define wxUSE_COMMANDLINKBUTTON 1 // wxCommandLinkButton
#define wxUSE_DATAVIEWCTRL 1 // wxDataViewCtrl
#define wxUSE_DATEPICKCTRL 1 // wxDatePickerCtrl
#define wxUSE_DIRPICKERCTRL 1 // wxDirPickerCtrl
#define wxUSE_EDITABLELISTBOX 1 // wxEditableListBox
#define wxUSE_FILECTRL 1 // wxFileCtrl
#define wxUSE_FILEPICKERCTRL 1 // wxFilePickerCtrl
#define wxUSE_FONTPICKERCTRL 1 // wxFontPickerCtrl
#define wxUSE_GAUGE 1 // wxGauge
#define wxUSE_HEADERCTRL 1 // wxHeaderCtrl
#define wxUSE_HYPERLINKCTRL 1 // wxHyperlinkCtrl
#define wxUSE_LISTBOX 1 // wxListBox
#define wxUSE_LISTCTRL 1 // wxListCtrl
#define wxUSE_RADIOBOX 1 // wxRadioBox
#define wxUSE_RADIOBTN 1 // wxRadioButton
#define wxUSE_RICHMSGDLG 1 // wxRichMessageDialog
#define wxUSE_SCROLLBAR 1 // wxScrollBar
#define wxUSE_SEARCHCTRL 1 // wxSearchCtrl
#define wxUSE_SLIDER 1 // wxSlider
#define wxUSE_SPINBTN 1 // wxSpinButton
#define wxUSE_SPINCTRL 1 // wxSpinCtrl
#define wxUSE_STATBOX 1 // wxStaticBox
#define wxUSE_STATLINE 1 // wxStaticLine
#define wxUSE_STATTEXT 1 // wxStaticText
#define wxUSE_STATBMP 1 // wxStaticBitmap
#define wxUSE_TEXTCTRL 1 // wxTextCtrl
#define wxUSE_TIMEPICKCTRL 1 // wxTimePickerCtrl
#define wxUSE_TOGGLEBTN 1 // requires wxButton
#define wxUSE_TREECTRL 1 // wxTreeCtrl
#define wxUSE_TREELISTCTRL 1 // wxTreeListCtrl
// Use a status bar class? Depending on the value of wxUSE_NATIVE_STATUSBAR
// below either wxStatusBar95 or a generic wxStatusBar will be used.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STATUSBAR 1
// Two status bar implementations are available under Win32: the generic one
// or the wrapper around native control. For native look and feel the native
// version should be used.
//
// Default is 1 for the platforms where native status bar is supported.
//
// Recommended setting: 1 (there is no advantage in using the generic one)
#define wxUSE_NATIVE_STATUSBAR 1
// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
// classes at all. Otherwise, use the native toolbar class unless
// wxUSE_TOOLBAR_NATIVE is 0.
//
// Default is 1 for all settings.
//
// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE.
#define wxUSE_TOOLBAR 1
#define wxUSE_TOOLBAR_NATIVE 1
// wxNotebook is a control with several "tabs" located on one of its sides. It
// may be used to logically organise the data presented to the user instead of
// putting everything in one huge dialog. It replaces wxTabControl and related
// classes of wxWin 1.6x.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTEBOOK 1
// wxListbook control is similar to wxNotebook but uses wxListCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_LISTBOOK 1
// wxChoicebook control is similar to wxNotebook but uses wxChoice instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CHOICEBOOK 1
// wxTreebook control is similar to wxNotebook but uses wxTreeCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TREEBOOK 1
// wxToolbook control is similar to wxNotebook but uses wxToolBar instead of
// tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLBOOK 1
// wxTaskBarIcon is a small notification icon shown in the system toolbar or
// dock.
//
// Default is 1.
//
// Recommended setting: 1 (but can be set to 0 if you don't need it)
#define wxUSE_TASKBARICON 1
// wxGrid class
//
// Default is 1, set to 0 to cut down compilation time and binaries size if you
// don't use it.
//
// Recommended setting: 1
//
#define wxUSE_GRID 1
// wxMiniFrame class: a frame with narrow title bar
//
// Default is 1.
//
// Recommended setting: 1 (it doesn't cost almost anything)
#define wxUSE_MINIFRAME 1
// wxComboCtrl and related classes: combobox with custom popup window and
// not necessarily a listbox.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 except for wxUniv where it
// it used by wxComboBox
#define wxUSE_COMBOCTRL 1
// wxOwnerDrawnComboBox is a custom combobox allowing to paint the combobox
// items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0, except where it is
// needed as a base class for generic wxBitmapComboBox.
#define wxUSE_ODCOMBOBOX 1
// wxBitmapComboBox is a combobox that can have images in front of text items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0
#define wxUSE_BITMAPCOMBOBOX 1
// wxRearrangeCtrl is a wxCheckListBox with two buttons allowing to move items
// up and down in it. It is also used as part of wxRearrangeDialog.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 (currently used only by
// wxHeaderCtrl)
#define wxUSE_REARRANGECTRL 1
// wxAddRemoveCtrl is a composite control containing a control showing some
// items (e.g. wxListBox, wxListCtrl, wxTreeCtrl, wxDataViewCtrl, ...) and "+"/
// "-" buttons allowing to add and remove items to/from the control.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 if you don't need it (not
// used by the library itself).
#define wxUSE_ADDREMOVECTRL 1
// ----------------------------------------------------------------------------
// Miscellaneous GUI stuff
// ----------------------------------------------------------------------------
// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
#define wxUSE_ACCEL 1
// Use the standard art provider. The icons returned by this provider are
// embedded into the library as XPMs so disabling it reduces the library size
// somewhat but this should only be done if you use your own custom art
// provider returning the icons or never use any icons not provided by the
// native art provider (which might not be implemented at all for some
// platforms) or by the Tango icons provider (if it's not itself disabled
// below).
//
// Default is 1.
//
// Recommended setting: 1 unless you use your own custom art provider.
#define wxUSE_ARTPROVIDER_STD 1
// Use art provider providing Tango icons: this art provider has higher quality
// icons than the default ones using smaller size XPM icons without
// transparency but the embedded PNG icons add to the library size.
//
// Default is 1 under non-GTK ports. Under wxGTK the native art provider using
// the GTK+ stock icons replaces it so it is normally not necessary.
//
// Recommended setting: 1 but can be turned off to reduce the library size.
#define wxUSE_ARTPROVIDER_TANGO 1
// Hotkey support (currently Windows only)
#define wxUSE_HOTKEY 1
// Use wxCaret: a class implementing a "cursor" in a text control (called caret
// under Windows).
//
// Default is 1.
//
// Recommended setting: 1 (can be safely set to 0, not used by the library)
#define wxUSE_CARET 1
// Use wxDisplay class: it allows enumerating all displays on a system and
// their geometries as well as finding the display on which the given point or
// window lies.
//
// Default is 1.
//
// Recommended setting: 1 if you need it, can be safely set to 0 otherwise
#define wxUSE_DISPLAY 1
// Miscellaneous geometry code: needed for Canvas library
#define wxUSE_GEOMETRY 1
// Use wxImageList. This class is needed by wxNotebook, wxTreeCtrl and
// wxListCtrl.
//
// Default is 1.
//
// Recommended setting: 1 (set it to 0 if you don't use any of the controls
// enumerated above, then this class is mostly useless too)
#define wxUSE_IMAGLIST 1
// Use wxInfoBar class.
//
// Default is 1.
//
// Recommended setting: 1 (but can be disabled without problems as nothing
// depends on it)
#define wxUSE_INFOBAR 1
// Use wxMenu, wxMenuBar, wxMenuItem.
//
// Default is 1.
//
// Recommended setting: 1 (can't be disabled under MSW)
#define wxUSE_MENUS 1
// Use wxNotificationMessage.
//
// wxNotificationMessage allows to show non-intrusive messages to the user
// using balloons, banners, popups or whatever is the appropriate method for
// the current platform.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTIFICATION_MESSAGE 1
// wxPreferencesEditor provides a common API for different ways of presenting
// the standard "Preferences" or "Properties" dialog under different platforms
// (e.g. some use modal dialogs, some use modeless ones; some apply the changes
// immediately while others require an explicit "Apply" button).
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_PREFERENCES_EDITOR 1
// wxFont::AddPrivateFont() allows to use fonts not installed on the system by
// loading them from font files during run-time.
//
// Default is 1 except under Unix where it will be turned off by configure if
// the required libraries are not available or not new enough.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it and
// want to avoid extra dependencies under Linux, for example).
#define wxUSE_PRIVATE_FONTS 1
// wxRichToolTip is a customizable tooltip class which has more functionality
// than the stock (but native, unlike this class) wxToolTip.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely set to 0 if you don't need it)
#define wxUSE_RICHTOOLTIP 1
// Use wxSashWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SASH 1
// Use wxSplitterWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SPLITTER 1
// Use wxToolTip and wxWindow::Set/GetToolTip() methods.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLTIPS 1
// wxValidator class and related methods
#define wxUSE_VALIDATORS 1
// Use reference counted ID management: this means that wxWidgets will track
// the automatically allocated ids (those used when you use wxID_ANY when
// creating a window, menu or toolbar item &c) instead of just supposing that
// the program never runs out of them. This is mostly useful only under wxMSW
// where the total ids range is limited to SHRT_MIN..SHRT_MAX and where
// long-running programs can run into problems with ids reuse without this. On
// the other platforms, where the ids have the full int range, this shouldn't
// be necessary.
#ifdef __WXMSW__
#define wxUSE_AUTOID_MANAGEMENT 1
#else
#define wxUSE_AUTOID_MANAGEMENT 0
#endif
// ----------------------------------------------------------------------------
// common dialogs
// ----------------------------------------------------------------------------
// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
// file selector, printer dialog). Switching this off also switches off the
// printing architecture and interactive wxPrinterDC.
//
// Default is 1
//
// Recommended setting: 1 (unless it really doesn't work)
#define wxUSE_COMMON_DIALOGS 1
// wxBusyInfo displays window with message when app is busy. Works in same way
// as wxBusyCursor
#define wxUSE_BUSYINFO 1
// Use single/multiple choice dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_CHOICEDLG 1
// Use colour picker dialog
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_COLOURDLG 1
// wxDirDlg class for getting a directory name from user
#define wxUSE_DIRDLG 1
// TODO: setting to choose the generic or native one
// Use file open/save dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in many places in the library itself)
#define wxUSE_FILEDLG 1
// Use find/replace dialogs.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely set to 0)
#define wxUSE_FINDREPLDLG 1
// Use font picker dialog
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_FONTDLG 1
// Use wxMessageDialog and wxMessageBox.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_MSGDLG 1
// progress dialog class for lengthy operations
#define wxUSE_PROGRESSDLG 1
// Set to 0 to disable the use of the native progress dialog (currently only
// available under MSW and suffering from some bugs there, hence this option).
#define wxUSE_NATIVE_PROGRESSDLG 1
// support for startup tips (wxShowTip &c)
#define wxUSE_STARTUP_TIPS 1
// text entry dialog and wxGetTextFromUser function
#define wxUSE_TEXTDLG 1
// number entry dialog
#define wxUSE_NUMBERDLG 1
// splash screen class
#define wxUSE_SPLASH 1
// wizards
#define wxUSE_WIZARDDLG 1
// Compile in wxAboutBox() function showing the standard "About" dialog.
//
// Default is 1
//
// Recommended setting: 1 but can be set to 0 to save some space if you don't
// use this function
#define wxUSE_ABOUTDLG 1
// wxFileHistory class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FILE_HISTORY 1
// ----------------------------------------------------------------------------
// Metafiles support
// ----------------------------------------------------------------------------
// Windows supports the graphics format known as metafile which, though not
// portable, is widely used under Windows and so is supported by wxWidgets
// (under Windows only, of course). Both the so-called "Window MetaFiles" or
// WMFs, and "Enhanced MetaFiles" or EMFs are supported in wxWin and, by
// default, EMFs will be used. This may be changed by setting
// wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting wxUSE_ENH_METAFILE to 0.
// You may also set wxUSE_METAFILE to 0 to not compile in any metafile
// related classes at all.
//
// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
//
// Recommended setting: default or 0 for everything for portable programs.
#define wxUSE_METAFILE 1
#define wxUSE_ENH_METAFILE 1
#define wxUSE_WIN_METAFILES_ALWAYS 0
// ----------------------------------------------------------------------------
// Big GUI components
// ----------------------------------------------------------------------------
// Set to 0 to disable MDI support.
//
// Requires wxUSE_NOTEBOOK under platforms other than MSW.
//
// Default is 1.
//
// Recommended setting: 1, can be safely set to 0.
#define wxUSE_MDI 1
// Set to 0 to disable document/view architecture
#define wxUSE_DOC_VIEW_ARCHITECTURE 1
// Set to 0 to disable MDI document/view architecture
//
// Requires wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 1
// Set to 0 to disable print/preview architecture code
#define wxUSE_PRINTING_ARCHITECTURE 1
// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
// much more.
//
// Default is 1.
//
// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
// smaller library.
#define wxUSE_HTML 1
// Setting wxUSE_GLCANVAS to 1 enables OpenGL support. You need to have OpenGL
// headers and libraries to be able to compile the library with wxUSE_GLCANVAS
// set to 1 and, under Windows, also to add opengl32.lib and glu32.lib to the
// list of libraries used to link your application (although this is done
// implicitly for Microsoft Visual C++ users).
//
// Default is 1.
//
// Recommended setting: 1 if you intend to use OpenGL, can be safely set to 0
// otherwise.
#define wxUSE_GLCANVAS 1
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 if you want compile a
// smaller library.
#define wxUSE_RICHTEXT 1
// ----------------------------------------------------------------------------
// Data transfer
// ----------------------------------------------------------------------------
// Use wxClipboard class for clipboard copy/paste.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CLIPBOARD 1
// Use wxDataObject and related classes. Needed for clipboard and OLE drag and
// drop
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DATAOBJ 1
// Use wxDropTarget and wxDropSource classes for drag and drop (this is
// different from "built in" drag and drop in wxTreeCtrl which is always
// available). Requires wxUSE_DATAOBJ.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DRAG_AND_DROP 1
// Use wxAccessible for enhanced and customisable accessibility.
// Depends on wxUSE_OLE on MSW.
//
// Default is 1 on MSW, 0 elsewhere.
//
// Recommended setting (at present): 1 (MSW-only)
#ifdef __WXMSW__
#define wxUSE_ACCESSIBILITY 1
#else
#define wxUSE_ACCESSIBILITY 0
#endif
// ----------------------------------------------------------------------------
// miscellaneous settings
// ----------------------------------------------------------------------------
// wxSingleInstanceChecker class allows to verify at startup if another program
// instance is running.
//
// Default is 1
//
// Recommended setting: 1 (the class is tiny, disabling it won't save much
// space)
#define wxUSE_SNGLINST_CHECKER 1
#define wxUSE_DRAGIMAGE 1
#define wxUSE_IPC 1
// 0 for no interprocess comms
#define wxUSE_HELP 1
// 0 for no help facility
// Should we use MS HTML help for wxHelpController? If disabled, neither
// wxCHMHelpController nor wxBestHelpController are available.
//
// Default is 1 under MSW, 0 is always used for the other platforms.
//
// Recommended setting: 1, only set to 0 if you have trouble compiling
// wxCHMHelpController (could be a problem with really ancient compilers)
#define wxUSE_MS_HTML_HELP 1
// Use wxHTML-based help controller?
#define wxUSE_WXHTML_HELP 1
#define wxUSE_CONSTRAINTS 1
// 0 for no window layout constraint system
#define wxUSE_SPLINES 1
// 0 for no splines
#define wxUSE_MOUSEWHEEL 1
// Include mouse wheel support
// Compile wxUIActionSimulator class?
#define wxUSE_UIACTIONSIMULATOR 1
// ----------------------------------------------------------------------------
// wxDC classes for various output formats
// ----------------------------------------------------------------------------
// Set to 1 for PostScript device context.
#define wxUSE_POSTSCRIPT 0
// Set to 1 to use font metric files in GetTextExtent
#define wxUSE_AFM_FOR_POSTSCRIPT 1
// Set to 1 to compile in support for wxSVGFileDC, a wxDC subclass which allows
// to create files in SVG (Scalable Vector Graphics) format.
#define wxUSE_SVG 1
// Should wxDC provide SetTransformMatrix() and related methods?
//
// Default is 1 but can be set to 0 if this functionality is not used. Notice
// that currently wxMSW, wxGTK3 support this for wxDC and all platforms support
// this for wxGCDC so setting this to 0 doesn't change much if neither of these
// is used (although it will still save a few bytes probably).
//
// Recommended setting: 1.
#define wxUSE_DC_TRANSFORM_MATRIX 1
// ----------------------------------------------------------------------------
// image format support
// ----------------------------------------------------------------------------
// wxImage supports many different image formats which can be configured at
// compile-time. BMP is always supported, others are optional and can be safely
// disabled if you don't plan to use images in such format sometimes saving
// substantial amount of code in the final library.
//
// Some formats require an extra library which is included in wxWin sources
// which is mentioned if it is the case.
// Set to 1 for wxImage support (recommended).
#define wxUSE_IMAGE 1
// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
#define wxUSE_LIBPNG 1
// Set to 1 for JPEG format support (requires libjpeg)
#define wxUSE_LIBJPEG 1
// Set to 1 for TIFF format support (requires libtiff)
#define wxUSE_LIBTIFF 1
// Set to 1 for TGA format support (loading only)
#define wxUSE_TGA 1
// Set to 1 for GIF format support
#define wxUSE_GIF 1
// Set to 1 for PNM format support
#define wxUSE_PNM 1
// Set to 1 for PCX format support
#define wxUSE_PCX 1
// Set to 1 for IFF format support (Amiga format)
#define wxUSE_IFF 0
// Set to 1 for XPM format support
#define wxUSE_XPM 1
// Set to 1 for MS Icons and Cursors format support
#define wxUSE_ICO_CUR 1
// Set to 1 to compile in wxPalette class
#define wxUSE_PALETTE 1
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
/* --- end common options --- */
/* --- start MSW options --- */
// ----------------------------------------------------------------------------
// Windows-only settings
// ----------------------------------------------------------------------------
// Set this to 1 for generic OLE support: this is required for drag-and-drop,
// clipboard, OLE Automation. Only set it to 0 if your compiler is very old and
// can't compile/doesn't have the OLE headers.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_OLE 1
// Set this to 1 to enable wxAutomationObject class.
//
// Default is 1.
//
// Recommended setting: 1 if you need to control other applications via OLE
// Automation, can be safely set to 0 otherwise
#define wxUSE_OLE_AUTOMATION 1
// Set this to 1 to enable wxActiveXContainer class allowing to embed OLE
// controls in wx.
//
// Default is 1.
//
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
// wxBitmap data.
//
// Default is 1, set it to 0 only if you don't use wxImage neither
//
// Recommended setting: 1 (without it conversion to/from wxImage won't work)
#define wxUSE_WXDIB 1
// Set to 0 to disable PostScript print/preview architecture code under Windows
// (just use Windows printing).
#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
// Set this to 1 to compile in wxRegKey class.
//
// Default is 1
//
// Recommended setting: 1, this is used internally by wx in a few places
#define wxUSE_REGKEY 1
// Set this to 1 to use RICHEDIT controls for wxTextCtrl with style wxTE_RICH
// which allows to put more than ~32Kb of text in it even under Win9x (NT
// doesn't have such limitation).
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1, only set it to 0 if your compiler doesn't have
// or can't compile <richedit.h>
#define wxUSE_RICHEDIT 1
// Set this to 1 to use extra features of richedit v2 and later controls
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1
#define wxUSE_RICHEDIT2 1
// Set this to 1 to enable support for the owner-drawn menu and listboxes. This
// is required by wxUSE_CHECKLISTBOX.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a small library size reduction
#define wxUSE_OWNER_DRAWN 1
// Set this to 1 to enable MSW-specific wxTaskBarIcon::ShowBalloon() method. It
// is required by native wxNotificationMessage implementation.
//
// Default is 1 but disabled in wx/msw/chkconf.h if SDK is too old to contain
// the necessary declarations.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARICON_BALLOONS 1
// Set to 1 to compile MS Windows XP theme engine support
#define wxUSE_UXTHEME 1
// Set to 1 to use InkEdit control (Tablet PC), if available
#define wxUSE_INKEDIT 0
// Set to 1 to enable .INI files based wxConfig implementation (wxIniConfig)
//
// Default is 0.
//
// Recommended setting: 0, nobody uses .INI files any more
#define wxUSE_INICONF 0
// ----------------------------------------------------------------------------
// Generic versions of native controls
// ----------------------------------------------------------------------------
// Set this to 1 to be able to use wxDatePickerCtrlGeneric in addition to the
// native wxDatePickerCtrl
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_DATEPICKCTRL_GENERIC 0
// ----------------------------------------------------------------------------
// Crash debugging helpers
// ----------------------------------------------------------------------------
// Set this to 1 to be able to use wxCrashReport::Generate() to create mini
// dumps of your program when it crashes (or at any other moment)
//
// Default is 1 if supported by the compiler (VC++ and recent BC++ only).
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_CRASHREPORT 1
/* --- end MSW options --- */
/* --- start wxUniv options --- */
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
/* --- end wxUniv options --- */
#endif // _WX_SETUP_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/app.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/app.h
// Purpose: wxUniversalApp class extends wxApp for wxUniv port
// Author: Vadim Zeitlin
// Modified by:
// Created: 06.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_APP_H_
#define _WX_UNIX_APP_H_
class WXDLLIMPEXP_CORE wxUniversalApp : public wxApp
{
public:
};
#endif // _WX_UNIX_APP_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/anybutton.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/anybutton.h
// Purpose: wxAnyButton class
// Author: Vadim Zeitlin
// Created: 2000-08-15 (extracted from button.h)
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_ANYBUTTON_H_
#define _WX_UNIV_ANYBUTTON_H_
#include "wx/univ/inphand.h"
// ----------------------------------------------------------------------------
// Common button functionality
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAnyButton : public wxAnyButtonBase
{
public:
wxAnyButton() {}
virtual ~wxAnyButton() {}
// wxAnyButton actions
virtual void Toggle();
virtual void Press();
virtual void Release();
virtual void Click(){}
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
protected:
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_STATIC; }
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual bool DoDrawBackground(wxDC& dc) wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
// current state
bool m_isPressed,
m_isDefault;
// the (optional) image to show and the margins around it
wxBitmap m_bitmap;
wxCoord m_marginBmpX,
m_marginBmpY;
private:
wxDECLARE_NO_COPY_CLASS(wxAnyButton);
};
// ----------------------------------------------------------------------------
// wxStdAnyButtonInputHandler: translates SPACE and ENTER keys and the left mouse
// click into button press/release actions
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStdAnyButtonInputHandler : public wxStdInputHandler
{
public:
wxStdAnyButtonInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed) wxOVERRIDE;
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event) wxOVERRIDE;
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event) wxOVERRIDE;
virtual bool HandleFocus(wxInputConsumer *consumer,
const wxFocusEvent& event) wxOVERRIDE;
virtual bool HandleActivation(wxInputConsumer *consumer, bool activated) wxOVERRIDE;
private:
// the window (button) which has capture or NULL and the flag telling if
// the mouse is inside the button which captured it or not
wxWindow *m_winCapture;
bool m_winHasMouse;
};
#endif // _WX_UNIV_ANYBUTTON_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/toplevel.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/toplevel.h
// Purpose: Top level window, abstraction of wxFrame and wxDialog
// Author: Vaclav Slavik
// Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __WX_UNIV_TOPLEVEL_H__
#define __WX_UNIV_TOPLEVEL_H__
#include "wx/univ/inpcons.h"
#include "wx/univ/inphand.h"
#include "wx/icon.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// frame decorations type flags used in wxRenderer and wxColourScheme
enum
{
wxTOPLEVEL_ACTIVE = 0x00000001,
wxTOPLEVEL_MAXIMIZED = 0x00000002,
wxTOPLEVEL_TITLEBAR = 0x00000004,
wxTOPLEVEL_ICON = 0x00000008,
wxTOPLEVEL_RESIZEABLE = 0x00000010,
wxTOPLEVEL_BORDER = 0x00000020,
wxTOPLEVEL_BUTTON_CLOSE = 0x01000000,
wxTOPLEVEL_BUTTON_MAXIMIZE = 0x02000000,
wxTOPLEVEL_BUTTON_ICONIZE = 0x04000000,
wxTOPLEVEL_BUTTON_RESTORE = 0x08000000,
wxTOPLEVEL_BUTTON_HELP = 0x10000000
};
// frame hit test return values:
enum
{
wxHT_TOPLEVEL_NOWHERE = 0x00000000,
wxHT_TOPLEVEL_CLIENT_AREA = 0x00000001,
wxHT_TOPLEVEL_ICON = 0x00000002,
wxHT_TOPLEVEL_TITLEBAR = 0x00000004,
wxHT_TOPLEVEL_BORDER_N = 0x00000010,
wxHT_TOPLEVEL_BORDER_S = 0x00000020,
wxHT_TOPLEVEL_BORDER_E = 0x00000040,
wxHT_TOPLEVEL_BORDER_W = 0x00000080,
wxHT_TOPLEVEL_BORDER_NE = wxHT_TOPLEVEL_BORDER_N | wxHT_TOPLEVEL_BORDER_E,
wxHT_TOPLEVEL_BORDER_SE = wxHT_TOPLEVEL_BORDER_S | wxHT_TOPLEVEL_BORDER_E,
wxHT_TOPLEVEL_BORDER_NW = wxHT_TOPLEVEL_BORDER_N | wxHT_TOPLEVEL_BORDER_W,
wxHT_TOPLEVEL_BORDER_SW = wxHT_TOPLEVEL_BORDER_S | wxHT_TOPLEVEL_BORDER_W,
wxHT_TOPLEVEL_ANY_BORDER = 0x000000F0,
wxHT_TOPLEVEL_BUTTON_CLOSE = /*0x01000000*/ wxTOPLEVEL_BUTTON_CLOSE,
wxHT_TOPLEVEL_BUTTON_MAXIMIZE = /*0x02000000*/ wxTOPLEVEL_BUTTON_MAXIMIZE,
wxHT_TOPLEVEL_BUTTON_ICONIZE = /*0x04000000*/ wxTOPLEVEL_BUTTON_ICONIZE,
wxHT_TOPLEVEL_BUTTON_RESTORE = /*0x08000000*/ wxTOPLEVEL_BUTTON_RESTORE,
wxHT_TOPLEVEL_BUTTON_HELP = /*0x10000000*/ wxTOPLEVEL_BUTTON_HELP,
wxHT_TOPLEVEL_ANY_BUTTON = 0x1F000000
};
// Flags for interactive frame manipulation functions (only in wxUniversal):
enum
{
wxINTERACTIVE_MOVE = 0x00000001,
wxINTERACTIVE_RESIZE = 0x00000002,
wxINTERACTIVE_RESIZE_S = 0x00000010,
wxINTERACTIVE_RESIZE_N = 0x00000020,
wxINTERACTIVE_RESIZE_W = 0x00000040,
wxINTERACTIVE_RESIZE_E = 0x00000080,
wxINTERACTIVE_WAIT_FOR_INPUT = 0x10000000
};
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
#define wxACTION_TOPLEVEL_ACTIVATE wxT("activate") // (de)activate the frame
#define wxACTION_TOPLEVEL_BUTTON_PRESS wxT("pressbtn") // press titlebar btn
#define wxACTION_TOPLEVEL_BUTTON_RELEASE wxT("releasebtn") // press titlebar btn
#define wxACTION_TOPLEVEL_BUTTON_CLICK wxT("clickbtn") // press titlebar btn
#define wxACTION_TOPLEVEL_MOVE wxT("move") // move the frame
#define wxACTION_TOPLEVEL_RESIZE wxT("resize") // resize the frame
//-----------------------------------------------------------------------------
// wxTopLevelWindow
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindow : public wxTopLevelWindowNative,
public wxInputConsumer
{
public:
// construction
wxTopLevelWindow() { Init(); }
wxTopLevelWindow(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
// wxUniv-specific methods: do [not] use native decorations for this (or
// all) window(s)
//
// notice that this has no effect if the system doesn't support any native
// decorations anyhow and that by default native decorations are used
//
// if UseNativeDecorations() is used, it must be called before Create()
static void UseNativeDecorationsByDefault(bool native = true);
void UseNativeDecorations(bool native = true);
bool IsUsingNativeDecorations() const;
// implement base class pure virtuals
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) wxOVERRIDE;
virtual wxPoint GetClientAreaOrigin() const wxOVERRIDE;
virtual void SetIcons(const wxIconBundle& icons) wxOVERRIDE;
// implementation from now on
// --------------------------
// tests for frame's part at given point
long HitTest(const wxPoint& pt) const;
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
// move/resize the frame interactively, i.e. let the user do it
virtual void InteractiveMove(int flags = wxINTERACTIVE_MOVE);
virtual wxSize GetMinSize() const wxOVERRIDE;
virtual wxWindow *GetInputWindow() const wxOVERRIDE { return const_cast<wxTopLevelWindow*>(this); }
protected:
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
// handle titlebar button click event
virtual void ClickTitleBarButton(long button);
// return wxTOPLEVEL_xxx combination based on current state of the frame
long GetDecorationsStyle() const;
// common part of all ctors
void Init();
void RefreshTitleBar();
void OnNcPaint(wxNcPaintEvent& event);
void OnSystemMenu(wxCommandEvent& event);
// true if wxTLW should render decorations (aka titlebar) itself
static int ms_drawDecorations;
// true if wxTLW can be iconized
static int ms_canIconize;
// true if we're using native decorations
bool m_usingNativeDecorations;
// true for currently active frame
bool m_isActive;
// version of icon for titlebar (16x16)
wxIcon m_titlebarIcon;
// saved window style in fullscreen mdoe
long m_fsSavedStyle;
// currently pressed titlebar button
long m_pressedButton;
wxDECLARE_DYNAMIC_CLASS(wxTopLevelWindow);
wxDECLARE_EVENT_TABLE();
WX_DECLARE_INPUT_CONSUMER()
};
#endif // __WX_UNIV_TOPLEVEL_H__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/stattext.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/stattext.h
// Purpose: wxStaticText
// Author: Vadim Zeitlin
// Modified by:
// Created: 14.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_STATTEXT_H_
#define _WX_UNIV_STATTEXT_H_
#include "wx/generic/stattextg.h"
class WXDLLIMPEXP_CORE wxStaticText : public wxGenericStaticText
{
public:
wxStaticText() { }
// usual ctor
wxStaticText(wxWindow *parent,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize)
{
Create(parent, wxID_ANY, label, pos, size, 0, wxStaticTextNameStr);
}
// full form
wxStaticText(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticTextNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
// function ctor
bool Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticTextNameStr);
// implementation only from now on
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool IsFocused() const wxOVERRIDE { return false; }
protected:
// draw the control
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
virtual void DoSetLabel(const wxString& str) wxOVERRIDE;
virtual wxString DoGetLabel() const wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxStaticText);
};
#endif // _WX_UNIV_STATTEXT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/statusbr.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/statusbr.h
// Purpose: wxStatusBarUniv: wxStatusBar for wxUniversal declaration
// Author: Vadim Zeitlin
// Modified by:
// Created: 14.10.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_STATUSBR_H_
#define _WX_UNIV_STATUSBR_H_
#include "wx/univ/inpcons.h"
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// wxStatusBarUniv: a window near the bottom of the frame used for status info
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStatusBarUniv : public wxStatusBarBase
{
public:
wxStatusBarUniv() { Init(); }
wxStatusBarUniv(wxWindow *parent,
wxWindowID id = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxPanelNameStr)
{
Init();
(void)Create(parent, id, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxPanelNameStr);
// implement base class methods
virtual void SetFieldsCount(int number = 1, const int *widths = NULL) wxOVERRIDE;
virtual void SetStatusWidths(int n, const int widths[]) wxOVERRIDE;
virtual bool GetFieldRect(int i, wxRect& rect) const wxOVERRIDE;
virtual void SetMinHeight(int height) wxOVERRIDE;
virtual int GetBorderX() const wxOVERRIDE;
virtual int GetBorderY() const wxOVERRIDE;
// wxInputConsumer pure virtual
virtual wxWindow *GetInputWindow() const wxOVERRIDE
{ return const_cast<wxStatusBar*>(this); }
protected:
virtual void DoUpdateStatusText(int i) wxOVERRIDE;
// recalculate the field widths
void OnSize(wxSizeEvent& event);
// draw the statusbar
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
// tell them about our preferred height
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// override DoSetSize() to prevent the status bar height from changing
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
// get the (fixed) status bar height
wxCoord GetHeight() const;
// get the rectangle containing all the fields and the border between them
//
// also updates m_widthsAbs if necessary
wxRect GetTotalFieldRect(wxCoord *borderBetweenFields);
// get the rect for this field without ani side effects (see code)
wxRect DoGetFieldRect(int n) const;
// common part of all ctors
void Init();
private:
// the current status fields strings
//wxArrayString m_statusText;
// the absolute status fields widths
wxArrayInt m_widthsAbs;
wxDECLARE_DYNAMIC_CLASS(wxStatusBarUniv);
wxDECLARE_EVENT_TABLE();
WX_DECLARE_INPUT_CONSUMER()
};
#endif // _WX_UNIV_STATUSBR_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/scrarrow.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/scrarrow.h
// Purpose: wxScrollArrows class
// Author: Vadim Zeitlin
// Modified by:
// Created: 22.01.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_SCRARROW_H_
#define _WX_UNIV_SCRARROW_H_
#if wxUSE_SCROLLBAR
// ----------------------------------------------------------------------------
// wxScrollArrows is not a control but just a class containing the common
// functionality of scroll arrows, whether part of scrollbars, spin ctrls or
// anything else.
//
// To customize its behaviour, wxScrollArrows doesn't use any virtual methods
// but instead a callback pointer to a wxControlWithArrows object which is used
// for all control-dependent stuff. Thus, to use wxScrollArrows, you just need
// to derive from the wxControlWithArrows interface and implement its methods.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxControlWithArrows;
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxMouseEvent;
class WXDLLIMPEXP_FWD_CORE wxRect;
class WXDLLIMPEXP_FWD_CORE wxRenderer;
// ----------------------------------------------------------------------------
// wxScrollArrows: an abstraction of scrollbar arrow
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxScrollArrows
{
public:
enum Arrow
{
Arrow_None = -1,
Arrow_First, // left or top
Arrow_Second, // right or bottom
Arrow_Max
};
// ctor requires a back pointer to wxControlWithArrows
wxScrollArrows(wxControlWithArrows *control);
// draws the arrow on the given DC in the given rectangle, uses
// wxControlWithArrows::GetArrowState() to get its current state
void DrawArrow(Arrow arrow, wxDC& dc, const wxRect& rect,
bool scrollbarLike = false) const;
// process a mouse move, enter or leave event, possibly calling
// wxControlWithArrows::SetArrowState() if
// wxControlWithArrows::HitTestArrow() says that the mouse has left/entered
// an arrow
bool HandleMouseMove(const wxMouseEvent& event) const;
// process a mouse click event
bool HandleMouse(const wxMouseEvent& event) const;
// dtor
~wxScrollArrows();
private:
// set or clear the wxCONTROL_CURRENT flag for the arrow
void UpdateCurrentFlag(Arrow arrow, Arrow arrowCur) const;
// the main control
wxControlWithArrows *m_control;
// the data for the mouse capture
struct wxScrollArrowCaptureData *m_captureData;
};
// ----------------------------------------------------------------------------
// wxControlWithArrows: interface implemented by controls using wxScrollArrows
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxControlWithArrows
{
public:
virtual ~wxControlWithArrows() {}
// get the renderer to use for drawing the arrows
virtual wxRenderer *GetRenderer() const = 0;
// get the controls window (used for mouse capturing)
virtual wxWindow *GetWindow() = 0;
// get the orientation of the arrows (vertical or horizontal)
virtual bool IsVertical() const = 0;
// get the state of this arrow as combination of wxCONTROL_XXX flags
virtual int GetArrowState(wxScrollArrows::Arrow arrow) const = 0;
// set or clear the specified flag in the arrow state: this function is
// responsible for refreshing the control
virtual void SetArrowFlag(wxScrollArrows::Arrow arrow,
int flag, bool set = true) = 0;
// hit testing: return on which arrow the point is (or Arrow_None)
virtual wxScrollArrows::Arrow HitTestArrow(const wxPoint& pt) const = 0;
// called when the arrow is pressed, return true to continue scrolling and
// false to stop it
virtual bool OnArrow(wxScrollArrows::Arrow arrow) = 0;
};
#endif // wxUSE_SCROLLBAR
#endif // _WX_UNIV_SCRARROW_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/radiobut.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/radiobut.h
// Purpose: wxRadioButton declaration
// Author: Vadim Zeitlin
// Modified by:
// Created: 10.09.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_RADIOBUT_H_
#define _WX_UNIV_RADIOBUT_H_
#include "wx/checkbox.h"
// ----------------------------------------------------------------------------
// wxRadioButton
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioButton : public wxCheckBox
{
public:
// constructors
wxRadioButton() { Init(); }
wxRadioButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr)
{
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 = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr);
// override some base class methods
virtual void ChangeValue(bool value) wxOVERRIDE;
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// implement our own drawing
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
// we use the radio button bitmaps for size calculation
virtual wxSize GetBitmapSize() const wxOVERRIDE;
// the radio button can only be cleared using this method, not
// ChangeValue() above - and it is protected as it can only be called by
// another radiobutton
void ClearValue();
// called when the radio button becomes checked: we clear all the buttons
// in the same group with us here
virtual void OnCheck() wxOVERRIDE;
// send event about radio button selection
virtual void SendEvent() wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioButton);
};
#endif // _WX_UNIV_RADIOBUT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/radiobox.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/radiobox.h
// Purpose: wxRadioBox declaration
// Author: Vadim Zeitlin
// Modified by:
// Created: 11.09.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_RADIOBOX_H_
#define _WX_UNIV_RADIOBOX_H_
class WXDLLIMPEXP_FWD_CORE wxRadioButton;
#include "wx/statbox.h"
#include "wx/dynarray.h"
WX_DEFINE_EXPORTED_ARRAY_PTR(wxRadioButton *, wxArrayRadioButtons);
// ----------------------------------------------------------------------------
// wxRadioBox: a box full of radio buttons
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioBox : public wxStaticBox,
public wxRadioBoxBase
{
public:
// wxRadioBox construction
wxRadioBox() { Init(); }
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString *choices = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, n, choices,
majorDim, style, val, name);
}
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString *choices = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
virtual ~wxRadioBox();
// implement wxRadioBox interface
virtual void SetSelection(int n) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual unsigned int GetCount() const wxOVERRIDE
{ return (unsigned int)m_buttons.GetCount(); }
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& label) wxOVERRIDE;
virtual bool Enable(unsigned int n, bool enable = true) wxOVERRIDE;
virtual bool Show(unsigned int n, bool show = true) wxOVERRIDE;
virtual bool IsItemEnabled(unsigned int n) const wxOVERRIDE;
virtual bool IsItemShown(unsigned int n) const wxOVERRIDE;
// we also override the wxControl methods to avoid virtual function hiding
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual wxString GetLabel() const wxOVERRIDE;
virtual void SetLabel(const wxString& label) wxOVERRIDE;
// we inherit a version always returning false from wxStaticBox, override
// it to behave normally
virtual bool AcceptsFocus() const wxOVERRIDE { return wxControl::AcceptsFocus(); }
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
// wxUniversal-only methods
// another Append() version
void Append(int n, const wxString *choices);
// implementation only: called by wxRadioHookHandler
void OnRadioButton(wxEvent& event);
bool OnKeyDown(wxKeyEvent& event);
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// override the base class methods dealing with window positioning/sizing
// as we must move/size the buttons as well
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// generate a radiobutton click event for the current item
void SendRadioEvent();
// common part of all ctors
void Init();
// calculate the max size of all buttons
wxSize GetMaxButtonSize() const;
// the currently selected radio button or -1
int m_selection;
// all radio buttons
wxArrayRadioButtons m_buttons;
// the event handler which is used to translate radiobutton events into
// radiobox one
wxEvtHandler *m_evtRadioHook;
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
};
#endif // _WX_UNIV_RADIOBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/checklst.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/checklst.h
// Purpose: wxCheckListBox class for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 12.09.00
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_CHECKLST_H_
#define _WX_UNIV_CHECKLST_H_
// ----------------------------------------------------------------------------
// actions
// ----------------------------------------------------------------------------
#define wxACTION_CHECKLISTBOX_TOGGLE wxT("toggle")
// ----------------------------------------------------------------------------
// wxCheckListBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
public:
// ctors
wxCheckListBox() { Init(); }
wxCheckListBox(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Init();
Create(parent, id, pos, size, nStrings, choices, style, validator, name);
}
wxCheckListBox(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// implement check list box methods
virtual bool IsChecked(unsigned int item) const wxOVERRIDE;
virtual void Check(unsigned int item, bool check = true) wxOVERRIDE;
// and input handling
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1l,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
protected:
// override all methods which add/delete items to update m_checks array as
// well
virtual void OnItemInserted(unsigned int pos) wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual void DoClear() wxOVERRIDE;
// draw the check items instead of the usual ones
virtual void DoDrawRange(wxControlRenderer *renderer,
int itemFirst, int itemLast) wxOVERRIDE;
// take them also into account for size calculation
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// common part of all ctors
void Init();
private:
// the array containing the checked status of the items
wxArrayInt m_checks;
wxDECLARE_DYNAMIC_CLASS(wxCheckListBox);
};
#endif // _WX_UNIV_CHECKLST_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/listbox.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/listbox.h
// Purpose: the universal listbox
// Author: Vadim Zeitlin
// Modified by:
// Created: 30.08.00
// Copyright: (c) 2000 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_LISTBOX_H_
#define _WX_UNIV_LISTBOX_H_
#include "wx/scrolwin.h" // for wxScrollHelper
#include "wx/dynarray.h"
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
// change the current item
#define wxACTION_LISTBOX_SETFOCUS wxT("setfocus") // select the item
#define wxACTION_LISTBOX_MOVEDOWN wxT("down") // select item below
#define wxACTION_LISTBOX_MOVEUP wxT("up") // select item above
#define wxACTION_LISTBOX_PAGEDOWN wxT("pagedown") // go page down
#define wxACTION_LISTBOX_PAGEUP wxT("pageup") // go page up
#define wxACTION_LISTBOX_START wxT("start") // go to first item
#define wxACTION_LISTBOX_END wxT("end") // go to last item
#define wxACTION_LISTBOX_FIND wxT("find") // find item by 1st letter
// do something with the current item
#define wxACTION_LISTBOX_ACTIVATE wxT("activate") // activate (choose)
#define wxACTION_LISTBOX_TOGGLE wxT("toggle") // togglee selected state
#define wxACTION_LISTBOX_SELECT wxT("select") // sel this, unsel others
#define wxACTION_LISTBOX_SELECTADD wxT("selectadd") // add to selection
#define wxACTION_LISTBOX_UNSELECT wxT("unselect") // unselect
#define wxACTION_LISTBOX_ANCHOR wxT("selanchor") // anchor selection
// do something with the selection globally (not for single selection ones)
#define wxACTION_LISTBOX_SELECTALL wxT("selectall") // select all items
#define wxACTION_LISTBOX_UNSELECTALL wxT("unselectall") // unselect all items
#define wxACTION_LISTBOX_SELTOGGLE wxT("togglesel") // invert the selection
#define wxACTION_LISTBOX_EXTENDSEL wxT("extend") // extend to item
// ----------------------------------------------------------------------------
// wxListBox: a list of selectable items
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxListBox : public wxListBoxBase, public wxScrollHelper
{
public:
// ctors and such
wxListBox() : wxScrollHelper(this) { Init(); }
wxListBox(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr )
: wxScrollHelper(this)
{
Init();
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxListBox(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr );
virtual ~wxListBox();
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// implement the listbox interface defined by wxListBoxBase
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& s) wxOVERRIDE;
virtual int FindString(const wxString& s, bool bCase = false) const wxOVERRIDE;
virtual bool IsSelected(int n) const wxOVERRIDE
{ return m_selections.Index(n) != wxNOT_FOUND; }
virtual int GetSelection() const wxOVERRIDE;
virtual int GetSelections(wxArrayInt& aSelections) const wxOVERRIDE;
protected:
virtual void DoSetSelection(int n, bool select) wxOVERRIDE;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData,
wxClientDataType type) wxOVERRIDE;
virtual int DoListHitTest(const wxPoint& point) const wxOVERRIDE;
// universal wxComboBox implementation internally uses wxListBox
friend class WXDLLIMPEXP_FWD_CORE wxComboBox;
virtual void DoSetFirstItem(int n) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
public:
// override some more base class methods
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
// the wxUniversal-specific methods
// --------------------------------
// the current item is the same as the selected one for wxLB_SINGLE
// listboxes but for the other ones it is just the focused item which may
// be selected or not
int GetCurrentItem() const { return m_current; }
void SetCurrentItem(int n);
// select the item which is diff items below the current one
void ChangeCurrent(int diff);
// activate (i.e. send a LISTBOX_DOUBLECLICKED message) the specified or
// current (if -1) item
void Activate(int item = -1);
// select or unselect the specified or current (if -1) item
void DoSelect(int item = -1, bool sel = true);
// more readable wrapper
void DoUnselect(int item) { DoSelect(item, false); }
// select an item and send a notification about it
void SelectAndNotify(int item);
// ensure that the given item is visible by scrolling it into view
virtual void EnsureVisible(int n) wxOVERRIDE;
// find the first item [strictly] after the current one which starts with
// the given string and make it the current one, return true if the current
// item changed
bool FindItem(const wxString& prefix, bool strictlyAfter = false);
bool FindNextItem(const wxString& prefix) { return FindItem(prefix, true); }
// extend the selection to span the range from the anchor (see below) to
// the specified or current item
void ExtendSelection(int itemTo = -1);
// make this item the new selection anchor: extending selection with
// ExtendSelection() will work with it
void AnchorSelection(int itemFrom) { m_selAnchor = itemFrom; }
// get, calculating it if necessary, the number of items per page, the
// height of each line and the max width of an item
int GetItemsPerPage() const;
wxCoord GetLineHeight() const;
wxCoord GetMaxWidth() const;
// override the wxControl virtual methods
virtual bool PerformAction(const wxControlAction& action,
long numArg = 0l,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
// idle processing
virtual void OnInternalIdle() wxOVERRIDE;
protected:
// geometry
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
virtual wxBorder GetDefaultBorder() const wxOVERRIDE;
// special hook for wxCheckListBox which allows it to update its internal
// data when a new item is inserted into the listbox
virtual void OnItemInserted(unsigned int WXUNUSED(pos)) { }
// common part of all ctors
void Init();
// event handlers
void OnSize(wxSizeEvent& event);
// refresh the given item(s) or everything
void RefreshItems(int from, int count);
void RefreshItem(int n);
void RefreshFromItemToEnd(int n);
void RefreshAll();
// send an event of the given type (using m_current by default)
bool SendEvent(wxEventType type, int item = -1);
// calculate the number of items per page using our current size
void CalcItemsPerPage();
// can/should we have a horz scrollbar?
bool HasHorzScrollbar() const
{ return (m_windowStyle & wxLB_HSCROLL) != 0; }
// redraw the items in the given range only: called from DoDraw()
virtual void DoDrawRange(wxControlRenderer *renderer,
int itemFirst, int itemLast);
// update the scrollbars and then ensure that the item is visible
void DoEnsureVisible(int n);
// mark horz scrollbar for updating
void RefreshHorzScrollbar();
// update (show/hide/adjust) the scrollbars
void UpdateScrollbars();
// refresh the items specified by m_updateCount and m_updateFrom
void UpdateItems();
// the array containing all items (it is sorted if the listbox has
// wxLB_SORT style)
union
{
wxArrayString *unsorted;
wxSortedArrayString *sorted;
} m_strings;
// this array contains the indices of the selected items (for the single
// selection listboxes only the first element of it is used and contains
// the current selection)
wxArrayInt m_selections;
// and this one the client data (either void or wxClientData)
wxArrayPtrVoid m_itemsClientData;
// this is hold the input handler type. the input handler is different
// between ListBox and its subclass--CheckListbox
wxString m_inputHandlerType;
// the current item
int m_current;
private:
// the range of elements which must be updated: if m_updateCount is 0 no
// update is needed, if it is -1 everything must be updated, otherwise
// m_updateCount items starting from m_updateFrom have to be redrawn
int m_updateFrom,
m_updateCount;
// the height of one line in the listbox (all lines have the same height)
wxCoord m_lineHeight;
// the maximal width of a listbox item and the item which has it
wxCoord m_maxWidth;
int m_maxWidthItem;
// the extents of horz and vert scrollbars
int m_scrollRangeX,
m_scrollRangeY;
// the number of items per page
size_t m_itemsPerPage;
// if the number of items has changed we may need to show/hide the
// scrollbar
bool m_updateScrollbarX, m_updateScrollbarY,
m_showScrollbarX, m_showScrollbarY;
// if the current item has changed, we might need to scroll if it went out
// of the window
bool m_currentChanged;
// the anchor from which the selection is extended for the listboxes with
// wxLB_EXTENDED style - this is set to the last item which was selected
// by not extending the selection but by choosing it directly
int m_selAnchor;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxListBox);
};
#endif // _WX_UNIV_LISTBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/spinbutt.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/spinbutt.h
// Purpose: universal version of wxSpinButton
// Author: Vadim Zeitlin
// Modified by:
// Created: 21.01.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_SPINBUTT_H_
#define _WX_UNIV_SPINBUTT_H_
#include "wx/univ/scrarrow.h"
// ----------------------------------------------------------------------------
// wxSpinButton
// ----------------------------------------------------------------------------
// actions supported by this control
#define wxACTION_SPIN_INC wxT("inc")
#define wxACTION_SPIN_DEC wxT("dec")
class WXDLLIMPEXP_CORE wxSpinButton : public wxSpinButtonBase,
public wxControlWithArrows
{
public:
wxSpinButton();
wxSpinButton(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME);
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME);
// implement wxSpinButtonBase methods
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int val) wxOVERRIDE;
virtual void SetRange(int minVal, int maxVal) wxOVERRIDE;
// implement wxControlWithArrows methods
virtual wxRenderer *GetRenderer() const wxOVERRIDE { return m_renderer; }
virtual wxWindow *GetWindow() wxOVERRIDE { return this; }
virtual bool IsVertical() const wxOVERRIDE { return wxSpinButtonBase::IsVertical(); }
virtual int GetArrowState(wxScrollArrows::Arrow arrow) const wxOVERRIDE;
virtual void SetArrowFlag(wxScrollArrows::Arrow arrow, int flag, bool set) wxOVERRIDE;
virtual bool OnArrow(wxScrollArrows::Arrow arrow) wxOVERRIDE;
virtual wxScrollArrows::Arrow HitTestArrow(const wxPoint& pt) const wxOVERRIDE;
// for wxStdSpinButtonInputHandler
const wxScrollArrows& GetArrows() { return m_arrows; }
virtual bool PerformAction(const wxControlAction& action,
long numArg = 0,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// the common part of all ctors
void Init();
// normalize the value to fit into min..max range
int NormalizeValue(int value) const;
// change the value by +1/-1 and send the event, return true if value was
// changed
bool ChangeValue(int inc);
// get the rectangles for our 2 arrows
void CalcArrowRects(wxRect *rect1, wxRect *rect2) const;
// the current controls value
int m_value;
private:
// the object which manages our arrows
wxScrollArrows m_arrows;
// the state (combination of wxCONTROL_XXX flags) of the arrows
int m_arrowsState[wxScrollArrows::Arrow_Max];
wxDECLARE_DYNAMIC_CLASS(wxSpinButton);
};
// ----------------------------------------------------------------------------
// wxStdSpinButtonInputHandler: manages clicks on them (use arrows like
// wxStdScrollBarInputHandler) and processes keyboard events too
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStdSpinButtonInputHandler : public wxStdInputHandler
{
public:
wxStdSpinButtonInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed) wxOVERRIDE;
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event) wxOVERRIDE;
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event) wxOVERRIDE;
};
#endif // _WX_UNIV_SPINBUTT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/renderer.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/renderer.h
// Purpose: wxRenderer class declaration
// Author: Vadim Zeitlin
// Modified by:
// Created: 06.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_RENDERER_H_
#define _WX_UNIV_RENDERER_H_
/*
wxRenderer class is used to draw all wxWidgets controls. This is an ABC and
the look of the application is determined by the concrete derivation of
wxRenderer used in the program.
It also contains a few static methods which may be used by the concrete
renderers and provide the functionality which is often similar or identical
in all renderers (using inheritance here would be more restrictive as the
given concrete renderer may need an arbitrary subset of the base class
methods).
Finally note that wxRenderer supersedes wxRendererNative in wxUniv build and
includes the latters functionality (which it may delegate to the generic
implementation of the latter or reimplement itself).
*/
#include "wx/renderer.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxCheckListBox;
#if wxUSE_LISTBOX
class WXDLLIMPEXP_FWD_CORE wxListBox;
#endif // wxUSE_LISTBOX
#if wxUSE_MENUS
class WXDLLIMPEXP_FWD_CORE wxMenu;
class WXDLLIMPEXP_FWD_CORE wxMenuGeometryInfo;
#endif // wxUSE_MENUS
class WXDLLIMPEXP_FWD_CORE wxScrollBar;
#if wxUSE_TEXTCTRL
class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
#endif
#if wxUSE_GAUGE
class WXDLLIMPEXP_FWD_CORE wxGauge;
#endif // wxUSE_GAUGE
#include "wx/string.h"
#include "wx/gdicmn.h"
#include "wx/icon.h"
// helper class used by wxMenu-related functions
class WXDLLIMPEXP_CORE wxMenuGeometryInfo
{
public:
// get the total size of the menu
virtual wxSize GetSize() const = 0;
virtual ~wxMenuGeometryInfo();
};
// ----------------------------------------------------------------------------
// wxRenderer: abstract renderers interface
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRenderer : public wxDelegateRendererNative
{
public:
// drawing functions
// -----------------
// draw the controls background
virtual void DrawBackground(wxDC& dc,
const wxColour& col,
const wxRect& rect,
int flags,
wxWindow *window = NULL) = 0;
// draw the button surface
virtual void DrawButtonSurface(wxDC& dc,
const wxColour& col,
const wxRect& rect,
int flags) = 0;
// draw the label inside the given rectangle with the specified alignment
// and optionally emphasize the character with the given index
virtual void DrawLabel(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0,
int alignment = wxALIGN_LEFT | wxALIGN_TOP,
int indexAccel = -1,
wxRect *rectBounds = NULL) = 0;
// same but also draw a bitmap if it is valid
virtual void DrawButtonLabel(wxDC& dc,
const wxString& label,
const wxBitmap& image,
const wxRect& rect,
int flags = 0,
int alignment = wxALIGN_LEFT | wxALIGN_TOP,
int indexAccel = -1,
wxRect *rectBounds = NULL) = 0;
// draw the border and optionally return the rectangle containing the
// region inside the border
virtual void DrawBorder(wxDC& dc,
wxBorder border,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) = 0;
// draw text control border (I hate to have a separate method for this but
// it is needed to accommodate GTK+)
virtual void DrawTextBorder(wxDC& dc,
wxBorder border,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) = 0;
// draw push button border and return the rectangle left for the label
virtual void DrawButtonBorder(wxDC& dc,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) = 0;
// draw a horizontal line
virtual void DrawHorizontalLine(wxDC& dc,
wxCoord y, wxCoord x1, wxCoord x2) = 0;
// draw a vertical line
virtual void DrawVerticalLine(wxDC& dc,
wxCoord x, wxCoord y1, wxCoord y2) = 0;
// draw a frame with the label (horizontal alignment can be specified)
virtual void DrawFrame(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0,
int alignment = wxALIGN_LEFT,
int indexAccel = -1) = 0;
// draw an arrow in the given direction
virtual void DrawArrow(wxDC& dc,
wxDirection dir,
const wxRect& rect,
int flags = 0) = 0;
// draw a scrollbar arrow (may be the same as arrow but may be not)
virtual void DrawScrollbarArrow(wxDC& dc,
wxDirection dir,
const wxRect& rect,
int flags = 0) = 0;
// draw the scrollbar thumb
virtual void DrawScrollbarThumb(wxDC& dc,
wxOrientation orient,
const wxRect& rect,
int flags = 0) = 0;
// draw a (part of) scrollbar shaft
virtual void DrawScrollbarShaft(wxDC& dc,
wxOrientation orient,
const wxRect& rect,
int flags = 0) = 0;
// draw the rectangle in the corner between two scrollbars
virtual void DrawScrollCorner(wxDC& dc,
const wxRect& rect) = 0;
// draw an item of a wxListBox
virtual void DrawItem(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0) = 0;
// draw an item of a wxCheckListBox
virtual void DrawCheckItem(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0) = 0;
// draw a checkbutton (bitmap may be invalid to use default one)
virtual void DrawCheckButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
wxAlignment align = wxALIGN_LEFT,
int indexAccel = -1) = 0;
// draw a radio button
virtual void DrawRadioButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
wxAlignment align = wxALIGN_LEFT,
int indexAccel = -1) = 0;
#if wxUSE_TOOLBAR
// draw a toolbar button (label may be empty, bitmap may be invalid, if
// both conditions are true this function draws a separator)
virtual void DrawToolBarButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
long style = 0,
int tbarStyle = 0) = 0;
#endif // wxUSE_TOOLBAR
#if wxUSE_TEXTCTRL
// draw a (part of) line in the text control
virtual void DrawTextLine(wxDC& dc,
const wxString& text,
const wxRect& rect,
int selStart = -1,
int selEnd = -1,
int flags = 0) = 0;
// draw a line wrap indicator
virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect) = 0;
#endif // wxUSE_TEXTCTRL
#if wxUSE_NOTEBOOK
// draw a notebook tab
virtual void DrawTab(wxDC& dc,
const wxRect& rect,
wxDirection dir,
const wxString& label,
const wxBitmap& bitmap = wxNullBitmap,
int flags = 0,
int indexAccel = -1) = 0;
#endif // wxUSE_NOTEBOOK
#if wxUSE_SLIDER
// draw the slider shaft
virtual void DrawSliderShaft(wxDC& dc,
const wxRect& rect,
int lenThumb,
wxOrientation orient,
int flags = 0,
long style = 0,
wxRect *rectShaft = NULL) = 0;
// draw the slider thumb
virtual void DrawSliderThumb(wxDC& dc,
const wxRect& rect,
wxOrientation orient,
int flags = 0,
long style = 0) = 0;
// draw the slider ticks
virtual void DrawSliderTicks(wxDC& dc,
const wxRect& rect,
int lenThumb,
wxOrientation orient,
int start,
int end,
int step = 1,
int flags = 0,
long style = 0) = 0;
#endif // wxUSE_SLIDER
#if wxUSE_MENUS
// draw a menu bar item
virtual void DrawMenuBarItem(wxDC& dc,
const wxRect& rect,
const wxString& label,
int flags = 0,
int indexAccel = -1) = 0;
// draw a menu item (also used for submenus if flags has ISSUBMENU flag)
//
// the geometryInfo is calculated by GetMenuGeometry() function from below
virtual void DrawMenuItem(wxDC& dc,
wxCoord y,
const wxMenuGeometryInfo& geometryInfo,
const wxString& label,
const wxString& accel,
const wxBitmap& bitmap = wxNullBitmap,
int flags = 0,
int indexAccel = -1) = 0;
// draw a menu bar separator
virtual void DrawMenuSeparator(wxDC& dc,
wxCoord y,
const wxMenuGeometryInfo& geomInfo) = 0;
#endif // wxUSE_MENUS
#if wxUSE_STATUSBAR
// draw a status bar field: wxCONTROL_ISDEFAULT bit in the flags is
// interpreted specially and means "draw the status bar grip" here
virtual void DrawStatusField(wxDC& dc,
const wxRect& rect,
const wxString& label,
int flags = 0, int style = 0) = 0;
#endif // wxUSE_STATUSBAR
// draw complete frame/dialog titlebar
virtual void DrawFrameTitleBar(wxDC& dc,
const wxRect& rect,
const wxString& title,
const wxIcon& icon,
int flags,
int specialButton = 0,
int specialButtonFlags = 0) = 0;
// draw frame borders
virtual void DrawFrameBorder(wxDC& dc,
const wxRect& rect,
int flags) = 0;
// draw frame titlebar background
virtual void DrawFrameBackground(wxDC& dc,
const wxRect& rect,
int flags) = 0;
// draw frame title
virtual void DrawFrameTitle(wxDC& dc,
const wxRect& rect,
const wxString& title,
int flags) = 0;
// draw frame icon
virtual void DrawFrameIcon(wxDC& dc,
const wxRect& rect,
const wxIcon& icon,
int flags) = 0;
// draw frame buttons
virtual void DrawFrameButton(wxDC& dc,
wxCoord x, wxCoord y,
int button,
int flags = 0) = 0;
// misc functions
// --------------
#if wxUSE_COMBOBOX
// return the bitmaps to use for combobox button
virtual void GetComboBitmaps(wxBitmap *bmpNormal,
wxBitmap *bmpFocus,
wxBitmap *bmpPressed,
wxBitmap *bmpDisabled) = 0;
#endif // wxUSE_COMBOBOX
// geometry functions
// ------------------
// get the dimensions of the border: rect.x/y contain the width/height of
// the left/top side, width/heigh - of the right/bottom one
virtual wxRect GetBorderDimensions(wxBorder border) const = 0;
// the scrollbars may be drawn either inside the window border or outside
// it - this function is used to decide how to draw them
virtual bool AreScrollbarsInsideBorder() const = 0;
// adjust the size of the control of the given class: for most controls,
// this just takes into account the border, but for some (buttons, for
// example) it is more complicated - the result being, in any case, that
// the control looks "nice" if it uses the adjusted rectangle
virtual void AdjustSize(wxSize *size, const wxWindow *window) = 0;
#if wxUSE_SCROLLBAR
// get the size of a scrollbar arrow
virtual wxSize GetScrollbarArrowSize() const = 0;
#endif // wxUSE_SCROLLBAR
// get the height of a listbox item from the base font height
virtual wxCoord GetListboxItemHeight(wxCoord fontHeight) = 0;
// get the size of a checkbox/radio button bitmap
virtual wxSize GetCheckBitmapSize() const = 0;
virtual wxSize GetRadioBitmapSize() const = 0;
virtual wxCoord GetCheckItemMargin() const = 0;
#if wxUSE_TOOLBAR
// get the standard size of a toolbar button and also return the size of
// a toolbar separator in the provided pointer
virtual wxSize GetToolBarButtonSize(wxCoord *separator) const = 0;
// get the margins between/around the toolbar buttons
virtual wxSize GetToolBarMargin() const = 0;
#endif // wxUSE_TOOLBAR
#if wxUSE_TEXTCTRL
// convert between text rectangle and client rectangle for text controls:
// the former is typicall smaller to leave margins around text
virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
const wxRect& rectText) const = 0;
// extra space is for line indicators
virtual wxRect GetTextClientArea(const wxTextCtrl *text,
const wxRect& rectTotal,
wxCoord *extraSpaceBeyond) const = 0;
#endif // wxUSE_TEXTCTRL
#if wxUSE_NOTEBOOK
// get the overhang of a selected tab
virtual wxSize GetTabIndent() const = 0;
// get the padding around the text in a tab
virtual wxSize GetTabPadding() const = 0;
#endif // wxUSE_NOTEBOOK
#if wxUSE_SLIDER
// get the default size of the slider in lesser dimension (i.e. height of a
// horizontal slider or width of a vertical one)
virtual wxCoord GetSliderDim() const = 0;
// get the length of the slider ticks displayed along side slider
virtual wxCoord GetSliderTickLen() const = 0;
// get the slider shaft rect from the total slider rect
virtual wxRect GetSliderShaftRect(const wxRect& rect,
int lenThumb,
wxOrientation orient,
long style = 0) const = 0;
// get the size of the slider thumb for the given total slider rect
virtual wxSize GetSliderThumbSize(const wxRect& rect,
int lenThumb,
wxOrientation orient) const = 0;
#endif // wxUSE_SLIDER
// get the size of one progress bar step (in horz and vertical directions)
virtual wxSize GetProgressBarStep() const = 0;
#if wxUSE_MENUS
// get the size of rectangle to use in the menubar for the given text rect
virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const = 0;
// get the struct storing all layout info needed to draw all menu items
// (this can't be calculated for each item separately as they should be
// aligned)
//
// the returned pointer must be deleted by the caller
virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
const wxMenu& menu) const = 0;
#endif // wxUSE_MENUS
#if wxUSE_STATUSBAR
// get the borders around the status bar fields (x and y fields of the
// return value)
virtual wxSize GetStatusBarBorders() const = 0;
// get the border between the status bar fields
virtual wxCoord GetStatusBarBorderBetweenFields() const = 0;
// get the mergin between a field and its border
virtual wxSize GetStatusBarFieldMargins() const = 0;
#endif // wxUSE_STATUSBAR
// get client area rectangle of top level window (i.e. subtract
// decorations from given rectangle)
virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const = 0;
// get size of whole top level window, given size of its client area size
virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const = 0;
// get the minimal size of top level window
virtual wxSize GetFrameMinSize(int flags) const = 0;
// get titlebar icon size
virtual wxSize GetFrameIconSize() const = 0;
// returns one of wxHT_TOPLEVEL_XXX constants
virtual int HitTestFrame(const wxRect& rect,
const wxPoint& pt,
int flags = 0) const = 0;
// virtual dtor for any base class
virtual ~wxRenderer();
};
// ----------------------------------------------------------------------------
// wxDelegateRenderer: it is impossible to inherit from any of standard
// renderers as their declarations are in private code, but you can use this
// class to override only some of the Draw() functions - all the other ones
// will be left to the original renderer
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDelegateRenderer : public wxRenderer
{
public:
wxDelegateRenderer(wxRenderer *renderer) : m_renderer(renderer) { }
virtual void DrawBackground(wxDC& dc,
const wxColour& col,
const wxRect& rect,
int flags,
wxWindow *window = NULL ) wxOVERRIDE
{ m_renderer->DrawBackground(dc, col, rect, flags, window ); }
virtual void DrawButtonSurface(wxDC& dc,
const wxColour& col,
const wxRect& rect,
int flags) wxOVERRIDE
{ m_renderer->DrawButtonSurface(dc, col, rect, flags); }
virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0) wxOVERRIDE
{ m_renderer->DrawFocusRect(win, dc, rect, flags); }
virtual void DrawLabel(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0,
int align = wxALIGN_LEFT | wxALIGN_TOP,
int indexAccel = -1,
wxRect *rectBounds = NULL) wxOVERRIDE
{ m_renderer->DrawLabel(dc, label, rect,
flags, align, indexAccel, rectBounds); }
virtual void DrawButtonLabel(wxDC& dc,
const wxString& label,
const wxBitmap& image,
const wxRect& rect,
int flags = 0,
int align = wxALIGN_LEFT | wxALIGN_TOP,
int indexAccel = -1,
wxRect *rectBounds = NULL) wxOVERRIDE
{ m_renderer->DrawButtonLabel(dc, label, image, rect,
flags, align, indexAccel, rectBounds); }
virtual void DrawBorder(wxDC& dc,
wxBorder border,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) wxOVERRIDE
{ m_renderer->DrawBorder(dc, border, rect, flags, rectIn); }
virtual void DrawTextBorder(wxDC& dc,
wxBorder border,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) wxOVERRIDE
{ m_renderer->DrawTextBorder(dc, border, rect, flags, rectIn); }
virtual void DrawButtonBorder(wxDC& dc,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) wxOVERRIDE
{ m_renderer->DrawButtonBorder(dc, rect, flags, rectIn); }
virtual void DrawFrame(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0,
int align = wxALIGN_LEFT,
int indexAccel = -1) wxOVERRIDE
{ m_renderer->DrawFrame(dc, label, rect, flags, align, indexAccel); }
virtual void DrawHorizontalLine(wxDC& dc,
wxCoord y, wxCoord x1, wxCoord x2) wxOVERRIDE
{ m_renderer->DrawHorizontalLine(dc, y, x1, x2); }
virtual void DrawVerticalLine(wxDC& dc,
wxCoord x, wxCoord y1, wxCoord y2) wxOVERRIDE
{ m_renderer->DrawVerticalLine(dc, x, y1, y2); }
virtual void DrawArrow(wxDC& dc,
wxDirection dir,
const wxRect& rect,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawArrow(dc, dir, rect, flags); }
virtual void DrawScrollbarArrow(wxDC& dc,
wxDirection dir,
const wxRect& rect,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawScrollbarArrow(dc, dir, rect, flags); }
virtual void DrawScrollbarThumb(wxDC& dc,
wxOrientation orient,
const wxRect& rect,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawScrollbarThumb(dc, orient, rect, flags); }
virtual void DrawScrollbarShaft(wxDC& dc,
wxOrientation orient,
const wxRect& rect,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawScrollbarShaft(dc, orient, rect, flags); }
virtual void DrawScrollCorner(wxDC& dc,
const wxRect& rect) wxOVERRIDE
{ m_renderer->DrawScrollCorner(dc, rect); }
virtual void DrawItem(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawItem(dc, label, rect, flags); }
virtual void DrawCheckItem(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawCheckItem(dc, label, bitmap, rect, flags); }
virtual void DrawCheckButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
wxAlignment align = wxALIGN_LEFT,
int indexAccel = -1) wxOVERRIDE
{ m_renderer->DrawCheckButton(dc, label, bitmap, rect,
flags, align, indexAccel); }
virtual void DrawRadioButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
wxAlignment align = wxALIGN_LEFT,
int indexAccel = -1) wxOVERRIDE
{ m_renderer->DrawRadioButton(dc, label, bitmap, rect,
flags, align, indexAccel); }
#if wxUSE_TOOLBAR
virtual void DrawToolBarButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
long style = 0,
int tbarStyle = 0) wxOVERRIDE
{ m_renderer->DrawToolBarButton(dc, label, bitmap, rect, flags, style, tbarStyle); }
#endif // wxUSE_TOOLBAR
#if wxUSE_TEXTCTRL
virtual void DrawTextLine(wxDC& dc,
const wxString& text,
const wxRect& rect,
int selStart = -1,
int selEnd = -1,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawTextLine(dc, text, rect, selStart, selEnd, flags); }
virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect) wxOVERRIDE
{ m_renderer->DrawLineWrapMark(dc, rect); }
#endif // wxUSE_TEXTCTRL
#if wxUSE_NOTEBOOK
virtual void DrawTab(wxDC& dc,
const wxRect& rect,
wxDirection dir,
const wxString& label,
const wxBitmap& bitmap = wxNullBitmap,
int flags = 0,
int accel = -1) wxOVERRIDE
{ m_renderer->DrawTab(dc, rect, dir, label, bitmap, flags, accel); }
#endif // wxUSE_NOTEBOOK
#if wxUSE_SLIDER
virtual void DrawSliderShaft(wxDC& dc,
const wxRect& rect,
int lenThumb,
wxOrientation orient,
int flags = 0,
long style = 0,
wxRect *rectShaft = NULL) wxOVERRIDE
{ m_renderer->DrawSliderShaft(dc, rect, lenThumb, orient, flags, style, rectShaft); }
virtual void DrawSliderThumb(wxDC& dc,
const wxRect& rect,
wxOrientation orient,
int flags = 0,
long style = 0) wxOVERRIDE
{ m_renderer->DrawSliderThumb(dc, rect, orient, flags, style); }
virtual void DrawSliderTicks(wxDC& dc,
const wxRect& rect,
int lenThumb,
wxOrientation orient,
int start,
int end,
int WXUNUSED(step) = 1,
int flags = 0,
long style = 0) wxOVERRIDE
{ m_renderer->DrawSliderTicks(dc, rect, lenThumb, orient,
start, end, start, flags, style); }
#endif // wxUSE_SLIDER
#if wxUSE_MENUS
virtual void DrawMenuBarItem(wxDC& dc,
const wxRect& rect,
const wxString& label,
int flags = 0,
int indexAccel = -1) wxOVERRIDE
{ m_renderer->DrawMenuBarItem(dc, rect, label, flags, indexAccel); }
virtual void DrawMenuItem(wxDC& dc,
wxCoord y,
const wxMenuGeometryInfo& gi,
const wxString& label,
const wxString& accel,
const wxBitmap& bitmap = wxNullBitmap,
int flags = 0,
int indexAccel = -1) wxOVERRIDE
{ m_renderer->DrawMenuItem(dc, y, gi, label, accel,
bitmap, flags, indexAccel); }
virtual void DrawMenuSeparator(wxDC& dc,
wxCoord y,
const wxMenuGeometryInfo& geomInfo) wxOVERRIDE
{ m_renderer->DrawMenuSeparator(dc, y, geomInfo); }
#endif // wxUSE_MENUS
#if wxUSE_STATUSBAR
virtual void DrawStatusField(wxDC& dc,
const wxRect& rect,
const wxString& label,
int flags = 0, int style = 0) wxOVERRIDE
{ m_renderer->DrawStatusField(dc, rect, label, flags, style); }
#endif // wxUSE_STATUSBAR
virtual void DrawFrameTitleBar(wxDC& dc,
const wxRect& rect,
const wxString& title,
const wxIcon& icon,
int flags,
int specialButton = 0,
int specialButtonFlag = 0) wxOVERRIDE
{ m_renderer->DrawFrameTitleBar(dc, rect, title, icon, flags,
specialButton, specialButtonFlag); }
virtual void DrawFrameBorder(wxDC& dc,
const wxRect& rect,
int flags) wxOVERRIDE
{ m_renderer->DrawFrameBorder(dc, rect, flags); }
virtual void DrawFrameBackground(wxDC& dc,
const wxRect& rect,
int flags) wxOVERRIDE
{ m_renderer->DrawFrameBackground(dc, rect, flags); }
virtual void DrawFrameTitle(wxDC& dc,
const wxRect& rect,
const wxString& title,
int flags) wxOVERRIDE
{ m_renderer->DrawFrameTitle(dc, rect, title, flags); }
virtual void DrawFrameIcon(wxDC& dc,
const wxRect& rect,
const wxIcon& icon,
int flags) wxOVERRIDE
{ m_renderer->DrawFrameIcon(dc, rect, icon, flags); }
virtual void DrawFrameButton(wxDC& dc,
wxCoord x, wxCoord y,
int button,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawFrameButton(dc, x, y, button, flags); }
#if wxUSE_COMBOBOX
virtual void GetComboBitmaps(wxBitmap *bmpNormal,
wxBitmap *bmpFocus,
wxBitmap *bmpPressed,
wxBitmap *bmpDisabled) wxOVERRIDE
{ m_renderer->GetComboBitmaps(bmpNormal, bmpFocus,
bmpPressed, bmpDisabled); }
#endif // wxUSE_COMBOBOX
virtual void AdjustSize(wxSize *size, const wxWindow *window) wxOVERRIDE
{ m_renderer->AdjustSize(size, window); }
virtual wxRect GetBorderDimensions(wxBorder border) const wxOVERRIDE
{ return m_renderer->GetBorderDimensions(border); }
virtual bool AreScrollbarsInsideBorder() const wxOVERRIDE
{ return m_renderer->AreScrollbarsInsideBorder(); }
#if wxUSE_SCROLLBAR
virtual wxSize GetScrollbarArrowSize() const wxOVERRIDE
{ return m_renderer->GetScrollbarArrowSize(); }
#endif // wxUSE_SCROLLBAR
virtual wxCoord GetListboxItemHeight(wxCoord fontHeight) wxOVERRIDE
{ return m_renderer->GetListboxItemHeight(fontHeight); }
virtual wxSize GetCheckBitmapSize() const wxOVERRIDE
{ return m_renderer->GetCheckBitmapSize(); }
virtual wxSize GetRadioBitmapSize() const wxOVERRIDE
{ return m_renderer->GetRadioBitmapSize(); }
virtual wxCoord GetCheckItemMargin() const wxOVERRIDE
{ return m_renderer->GetCheckItemMargin(); }
#if wxUSE_TOOLBAR
virtual wxSize GetToolBarButtonSize(wxCoord *separator) const wxOVERRIDE
{ return m_renderer->GetToolBarButtonSize(separator); }
virtual wxSize GetToolBarMargin() const wxOVERRIDE
{ return m_renderer->GetToolBarMargin(); }
#endif // wxUSE_TOOLBAR
#if wxUSE_TEXTCTRL
virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
const wxRect& rect) const wxOVERRIDE
{ return m_renderer->GetTextTotalArea(text, rect); }
virtual wxRect GetTextClientArea(const wxTextCtrl *text,
const wxRect& rect,
wxCoord *extraSpaceBeyond) const wxOVERRIDE
{ return m_renderer->GetTextClientArea(text, rect, extraSpaceBeyond); }
#endif // wxUSE_TEXTCTRL
#if wxUSE_NOTEBOOK
virtual wxSize GetTabIndent() const wxOVERRIDE { return m_renderer->GetTabIndent(); }
virtual wxSize GetTabPadding() const wxOVERRIDE { return m_renderer->GetTabPadding(); }
#endif // wxUSE_NOTEBOOK
#if wxUSE_SLIDER
virtual wxCoord GetSliderDim() const wxOVERRIDE
{ return m_renderer->GetSliderDim(); }
virtual wxCoord GetSliderTickLen() const wxOVERRIDE
{ return m_renderer->GetSliderTickLen(); }
virtual wxRect GetSliderShaftRect(const wxRect& rect,
int lenThumb,
wxOrientation orient,
long style = 0) const wxOVERRIDE
{ return m_renderer->GetSliderShaftRect(rect, lenThumb, orient, style); }
virtual wxSize GetSliderThumbSize(const wxRect& rect,
int lenThumb,
wxOrientation orient) const wxOVERRIDE
{ return m_renderer->GetSliderThumbSize(rect, lenThumb, orient); }
#endif // wxUSE_SLIDER
virtual wxSize GetProgressBarStep() const wxOVERRIDE
{ return m_renderer->GetProgressBarStep(); }
#if wxUSE_MENUS
virtual wxSize GetMenuBarItemSize(const wxSize& sizeText) const wxOVERRIDE
{ return m_renderer->GetMenuBarItemSize(sizeText); }
virtual wxMenuGeometryInfo *GetMenuGeometry(wxWindow *win,
const wxMenu& menu) const wxOVERRIDE
{ return m_renderer->GetMenuGeometry(win, menu); }
#endif // wxUSE_MENUS
#if wxUSE_STATUSBAR
virtual wxSize GetStatusBarBorders() const wxOVERRIDE
{ return m_renderer->GetStatusBarBorders(); }
virtual wxCoord GetStatusBarBorderBetweenFields() const wxOVERRIDE
{ return m_renderer->GetStatusBarBorderBetweenFields(); }
virtual wxSize GetStatusBarFieldMargins() const wxOVERRIDE
{ return m_renderer->GetStatusBarFieldMargins(); }
#endif // wxUSE_STATUSBAR
virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const wxOVERRIDE
{ return m_renderer->GetFrameClientArea(rect, flags); }
virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const wxOVERRIDE
{ return m_renderer->GetFrameTotalSize(clientSize, flags); }
virtual wxSize GetFrameMinSize(int flags) const wxOVERRIDE
{ return m_renderer->GetFrameMinSize(flags); }
virtual wxSize GetFrameIconSize() const wxOVERRIDE
{ return m_renderer->GetFrameIconSize(); }
virtual int HitTestFrame(const wxRect& rect,
const wxPoint& pt,
int flags) const wxOVERRIDE
{ return m_renderer->HitTestFrame(rect, pt, flags); }
virtual int DrawHeaderButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0,
wxHeaderSortIconType sortIcon = wxHDR_SORT_ICON_NONE,
wxHeaderButtonParams* params = NULL) wxOVERRIDE
{ return m_renderer->DrawHeaderButton(win, dc, rect, flags, sortIcon, params); }
virtual void DrawTreeItemButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags = 0) wxOVERRIDE
{ m_renderer->DrawTreeItemButton(win, dc, rect, flags); }
protected:
wxRenderer *m_renderer;
};
// ----------------------------------------------------------------------------
// wxControlRenderer: wraps the wxRenderer functions in a form easy to use from
// OnPaint()
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxControlRenderer
{
public:
// create a renderer for this dc with this "fundamental" renderer
wxControlRenderer(wxWindow *control, wxDC& dc, wxRenderer *renderer);
// operations
void DrawLabel();
void DrawButtonLabel(const wxBitmap& bitmap = wxNullBitmap,
wxCoord marginX = 0, wxCoord marginY = 0);
#if wxUSE_LISTBOX
void DrawItems(const wxListBox *listbox,
size_t itemFirst, size_t itemLast);
#endif // wxUSE_LISTBOX
#if wxUSE_CHECKLISTBOX
void DrawCheckItems(const wxCheckListBox *listbox,
size_t itemFirst, size_t itemLast);
#endif // wxUSE_CHECKLISTBOX
void DrawButtonBorder();
// the line must be either horizontal or vertical
void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
void DrawFrame();
void DrawBitmap(const wxBitmap& bitmap);
void DrawBackgroundBitmap();
void DrawScrollbar(const wxScrollBar *scrollbar, int thumbPosOld);
#if wxUSE_GAUGE
void DrawProgressBar(const wxGauge *gauge);
#endif // wxUSE_GAUGE
// accessors
wxWindow *GetWindow() const { return m_window; }
wxRenderer *GetRenderer() const { return m_renderer; }
wxDC& GetDC() { return m_dc; }
const wxRect& GetRect() const { return m_rect; }
wxRect& GetRect() { return m_rect; }
// static helpers
static void DrawBitmap(wxDC &dc,
const wxBitmap& bitmap,
const wxRect& rect,
int alignment = wxALIGN_CENTRE |
wxALIGN_CENTRE_VERTICAL,
wxStretch stretch = wxSTRETCH_NOT);
private:
#if wxUSE_LISTBOX
// common part of DrawItems() and DrawCheckItems()
void DoDrawItems(const wxListBox *listbox,
size_t itemFirst, size_t itemLast,
bool isCheckLbox = false);
#endif // wxUSE_LISTBOX
wxWindow *m_window;
wxRenderer *m_renderer;
wxDC& m_dc;
wxRect m_rect;
};
#endif // _WX_UNIV_RENDERER_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/statbmp.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/statbmp.h
// Purpose: wxStaticBitmap class for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 25.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_STATBMP_H_
#define _WX_UNIV_STATBMP_H_
#include "wx/bitmap.h"
// ----------------------------------------------------------------------------
// wxStaticBitmap
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
public:
wxStaticBitmap()
{
}
wxStaticBitmap(wxWindow *parent,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0)
{
Create(parent, wxID_ANY, label, pos, size, style);
}
wxStaticBitmap(wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual void SetBitmap(const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetIcon(const wxIcon& icon) wxOVERRIDE;
virtual wxBitmap GetBitmap() const wxOVERRIDE { return m_bitmap; }
wxIcon GetIcon() const wxOVERRIDE;
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
protected:
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
private:
// the bitmap which we show
wxBitmap m_bitmap;
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
};
#endif // _WX_UNIV_STATBMP_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/slider.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/slider.h
// Purpose: wxSlider control for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 09.02.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_SLIDER_H_
#define _WX_UNIV_SLIDER_H_
#include "wx/univ/scrthumb.h"
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
// our actions are the same as scrollbars
#define wxACTION_SLIDER_START wxT("start") // to the beginning
#define wxACTION_SLIDER_END wxT("end") // to the end
#define wxACTION_SLIDER_LINE_UP wxT("lineup") // one line up/left
#define wxACTION_SLIDER_PAGE_UP wxT("pageup") // one page up/left
#define wxACTION_SLIDER_LINE_DOWN wxT("linedown") // one line down/right
#define wxACTION_SLIDER_PAGE_DOWN wxT("pagedown") // one page down/right
#define wxACTION_SLIDER_PAGE_CHANGE wxT("pagechange")// change page by numArg
#define wxACTION_SLIDER_THUMB_DRAG wxT("thumbdrag")
#define wxACTION_SLIDER_THUMB_MOVE wxT("thumbmove")
#define wxACTION_SLIDER_THUMB_RELEASE wxT("thumbrelease")
// ----------------------------------------------------------------------------
// wxSlider
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSlider : public wxSliderBase,
public wxControlWithThumb
{
public:
// ctors and such
wxSlider();
wxSlider(wxWindow *parent,
wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
// implement base class pure virtuals
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int value) wxOVERRIDE;
virtual void SetRange(int minValue, int maxValue) wxOVERRIDE;
virtual int GetMin() const wxOVERRIDE;
virtual int GetMax() const wxOVERRIDE;
virtual void SetLineSize(int lineSize) wxOVERRIDE;
virtual void SetPageSize(int pageSize) wxOVERRIDE;
virtual int GetLineSize() const wxOVERRIDE;
virtual int GetPageSize() const wxOVERRIDE;
virtual void SetThumbLength(int lenPixels) wxOVERRIDE;
virtual int GetThumbLength() const wxOVERRIDE;
virtual int GetTickFreq() const wxOVERRIDE { return m_tickFreq; }
// wxUniv-specific methods
// -----------------------
// is this a vertical slider?
bool IsVert() const { return (GetWindowStyle() & wxSL_VERTICAL) != 0; }
// get the slider orientation
wxOrientation GetOrientation() const
{ return IsVert() ? wxVERTICAL : wxHORIZONTAL; }
// do we have labels?
bool HasLabels() const
{ return ((GetWindowStyle() & wxSL_LABELS) != 0) &&
((GetWindowStyle() & (wxSL_TOP|wxSL_BOTTOM|wxSL_LEFT|wxSL_RIGHT)) != 0); }
// do we have ticks?
bool HasTicks() const
{ return ((GetWindowStyle() & wxSL_TICKS) != 0) &&
((GetWindowStyle() & (wxSL_TOP|wxSL_BOTTOM|wxSL_LEFT|wxSL_RIGHT|wxSL_BOTH)) != 0); }
// implement wxControlWithThumb interface
virtual wxWindow *GetWindow() wxOVERRIDE { return this; }
virtual bool IsVertical() const wxOVERRIDE { return IsVert(); }
virtual wxScrollThumb::Shaft HitTest(const wxPoint& pt) const wxOVERRIDE;
virtual wxCoord ThumbPosToPixel() const wxOVERRIDE;
virtual int PixelToThumbPos(wxCoord x) const wxOVERRIDE;
virtual void SetShaftPartState(wxScrollThumb::Shaft shaftPart,
int flag,
bool set = true) wxOVERRIDE;
virtual void OnThumbDragStart(int pos) wxOVERRIDE;
virtual void OnThumbDrag(int pos) wxOVERRIDE;
virtual void OnThumbDragEnd(int pos) wxOVERRIDE;
virtual void OnPageScrollStart() wxOVERRIDE;
virtual bool OnPageScroll(int pageInc) wxOVERRIDE;
// for wxStdSliderInputHandler
wxScrollThumb& GetThumb() { return m_thumb; }
virtual bool PerformAction(const wxControlAction& action,
long numArg = 0,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
protected:
enum
{
INVALID_THUMB_VALUE = -0xffff
};
// Platform-specific implementation of SetTickFreq
virtual void DoSetTickFreq(int freq) wxOVERRIDE;
// overridden base class virtuals
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// event handlers
void OnSize(wxSizeEvent& event);
// common part of all ctors
void Init();
// normalize the value to fit in the range
int NormalizeValue(int value) const;
// change the value by the given increment, return true if really changed
bool ChangeValueBy(int inc);
// change the value to the given one
bool ChangeValueTo(int value);
// is the value inside the range?
bool IsInRange(int value) { return (value >= m_min) && (value <= m_max); }
// format the value for printing as label
virtual wxString FormatValue(int value) const;
// calculate max label size
wxSize CalcLabelSize() const;
// calculate m_rectLabel/Slider
void CalcGeometry();
// get the thumb size
wxSize GetThumbSize() const;
// get the shaft rect (uses m_rectSlider which is supposed to be calculated)
wxRect GetShaftRect() const;
// calc the current thumb position using the shaft rect (if the pointer is
// NULL, we calculate it here too)
void CalcThumbRect(const wxRect *rectShaft,
wxRect *rectThumbOut,
wxRect *rectLabelOut,
int value = INVALID_THUMB_VALUE) const;
// return the slider rect calculating it if needed
const wxRect& GetSliderRect() const;
// refresh the current thumb position
void RefreshThumb();
private:
// get the default thumb size (without using m_thumbSize)
wxSize GetDefaultThumbSize() const;
// the object which manages our thumb
wxScrollThumb m_thumb;
// the slider range and value
int m_min,
m_max,
m_value;
// the tick frequence (default is 1)
int m_tickFreq;
// the line and page increments (logical units)
int m_lineSize,
m_pageSize;
// the size of the thumb (in pixels)
int m_thumbSize;
// the part of the client area reserved for the label, the ticks and the
// part for the slider itself
wxRect m_rectLabel,
m_rectTicks,
m_rectSlider;
// the state of the thumb (wxCONTROL_XXX constants sum)
int m_thumbFlags;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxSlider);
};
#endif // _WX_UNIV_SLIDER_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/menuitem.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/menuitem.h
// Purpose: wxMenuItem class for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 05.05.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_MENUITEM_H_
#define _WX_UNIV_MENUITEM_H_
// ----------------------------------------------------------------------------
// wxMenuItem implements wxMenuItemBase
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuItem : public wxMenuItemBase
{
public:
// ctor & dtor
wxMenuItem(wxMenu *parentMenu = NULL,
int id = wxID_SEPARATOR,
const wxString& name = wxEmptyString,
const wxString& help = wxEmptyString,
wxItemKind kind = wxITEM_NORMAL,
wxMenu *subMenu = NULL);
virtual ~wxMenuItem();
// override base class virtuals to update the item appearance on screen
virtual void SetItemLabel(const wxString& text) wxOVERRIDE;
virtual void SetCheckable(bool checkable) wxOVERRIDE;
virtual void Enable(bool enable = true) wxOVERRIDE;
virtual void Check(bool check = true) wxOVERRIDE;
// we add some extra functions which are also available under MSW from
// wxOwnerDrawn class - they will be moved to wxMenuItemBase later
// hopefully
void SetBitmaps(const wxBitmap& bmpChecked,
const wxBitmap& bmpUnchecked = wxNullBitmap);
void SetBitmap(const wxBitmap& bmp) { SetBitmaps(bmp); }
const wxBitmap& GetBitmap(bool checked = true) const
{ return checked ? m_bmpChecked : m_bmpUnchecked; }
void SetDisabledBitmap( const wxBitmap& bmpDisabled )
{ m_bmpDisabled = bmpDisabled; }
const wxBitmap& GetDisabledBitmap() const
{ return m_bmpDisabled; }
// mark item as belonging to the given radio group
void SetAsRadioGroupStart();
void SetRadioGroupStart(int start);
void SetRadioGroupEnd(int end);
int GetRadioGroupStart();
int GetRadioGroupEnd();
// wxUniv-specific methods for implementation only starting from here
// get the accel index of our label or -1 if none
int GetAccelIndex() const { return m_indexAccel; }
// get the accel string (displayed to the right of the label)
const wxString& GetAccelString() const { return m_strAccel; }
// set/get the y coord and the height of this item: note that it must be
// set first and retrieved later, the item doesn't calculate it itself
void SetGeometry(wxCoord y, wxCoord height)
{
m_posY = y;
m_height = height;
}
wxCoord GetPosition() const
{
wxASSERT_MSG( m_posY != wxDefaultCoord, wxT("must call SetHeight first!") );
return m_posY;
}
wxCoord GetHeight() const
{
wxASSERT_MSG( m_height != wxDefaultCoord, wxT("must call SetHeight first!") );
return m_height;
}
protected:
// notify the menu about the change in this item
inline void NotifyMenu();
// set the accel index and string from text
void UpdateAccelInfo();
// the bitmaps (may be invalid, then they're not used)
wxBitmap m_bmpChecked,
m_bmpUnchecked,
m_bmpDisabled;
// the positions of the first and last items of the radio group this item
// belongs to or -1: start is the radio group start and is valid for all
// but first radio group items (m_isRadioGroupStart == false), end is valid
// only for the first one
union
{
int start;
int end;
} m_radioGroup;
// does this item start a radio group?
bool m_isRadioGroupStart;
// the position of the accelerator in our label, -1 if none
int m_indexAccel;
// the accel string (i.e. "Ctrl-Q" or "Alt-F1")
wxString m_strAccel;
// the position and height of the displayed item
wxCoord m_posY,
m_height;
private:
wxDECLARE_DYNAMIC_CLASS(wxMenuItem);
};
#endif // _WX_UNIV_MENUITEM_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/inpcons.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/inpcons.h
// Purpose: wxInputConsumer: mix-in class for input handling
// Author: Vadim Zeitlin
// Modified by:
// Created: 14.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_INPCONS_H_
#define _WX_UNIV_INPCONS_H_
class WXDLLIMPEXP_FWD_CORE wxInputHandler;
class WXDLLIMPEXP_FWD_CORE wxWindow;
#include "wx/object.h"
#include "wx/event.h"
// ----------------------------------------------------------------------------
// wxControlAction: the action is currently just a string which identifies it,
// later it might become an atom (i.e. an opaque handler to string).
// ----------------------------------------------------------------------------
typedef wxString wxControlAction;
// the list of actions which apply to all controls (other actions are defined
// in the controls headers)
#define wxACTION_NONE wxT("") // no action to perform
// ----------------------------------------------------------------------------
// wxInputConsumer: mix-in class for handling wxControlActions (used by
// wxControl and wxTopLevelWindow).
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxInputConsumer
{
public:
wxInputConsumer() { m_inputHandler = NULL; }
virtual ~wxInputConsumer() { }
// get the input handler
wxInputHandler *GetInputHandler() const { return m_inputHandler; }
// perform a control-dependent action: an action may have an optional
// numeric and another (also optional) string argument whose interpretation
// depends on the action
//
// NB: we might use ellipsis in PerformAction() declaration but this
// wouldn't be more efficient than always passing 2 unused parameters
// but would be more difficult. Another solution would be to have
// several overloaded versions but this will expose the problem of
// virtual function hiding we don't have here.
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1l,
const wxString& strArg = wxEmptyString);
// get the window to work with (usually the class wxInputConsumer was mixed into)
virtual wxWindow *GetInputWindow() const = 0;
// this function must be implemented in any classes process input (i.e. not
// static controls) to create the standard input handler for the concrete
// class deriving from this mix-in
//
// the parameter is the default input handler which should receive all
// unprocessed input (i.e. typically handlerDef is passed to
// wxStdInputHandler ctor) or it may be NULL
//
// the returned pointer will not be deleted by caller so it must either
// point to a static object or be deleted on program termination
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef);
protected:
// event handlers
void OnMouse(wxMouseEvent& event);
void OnKeyDown(wxKeyEvent& event);
void OnKeyUp(wxKeyEvent& event);
void OnFocus(wxFocusEvent& event);
void OnActivate(wxActivateEvent& event);
// create input handler by name, fall back to GetStdInputHandler() if
// the current theme doesn't define any specific handler of this type
void CreateInputHandler(const wxString& inphandler);
private:
// the input processor (we never delete it)
wxInputHandler *m_inputHandler;
};
// ----------------------------------------------------------------------------
// macros which must be used by the classes derived from wxInputConsumer mix-in
// ----------------------------------------------------------------------------
// declare the methods to be forwarded
#define WX_DECLARE_INPUT_CONSUMER() \
private: \
void OnMouse(wxMouseEvent& event); \
void OnKeyDown(wxKeyEvent& event); \
void OnKeyUp(wxKeyEvent& event); \
void OnFocus(wxFocusEvent& event); \
public: /* because of docview :-( */ \
void OnActivate(wxActivateEvent& event); \
private:
// implement the event table entries for wxControlContainer
#define WX_EVENT_TABLE_INPUT_CONSUMER(classname) \
EVT_KEY_DOWN(classname::OnKeyDown) \
EVT_KEY_UP(classname::OnKeyUp) \
EVT_MOUSE_EVENTS(classname::OnMouse) \
EVT_SET_FOCUS(classname::OnFocus) \
EVT_KILL_FOCUS(classname::OnFocus) \
EVT_ACTIVATE(classname::OnActivate)
// Forward event handlers to wxInputConsumer
//
// (We can't use them directly, because wxIC has virtual methods, which forces
// the compiler to include (at least) two vtables into wxControl, one for the
// wxWindow-wxControlBase-wxControl branch and one for the wxIC mix-in.
// Consequently, the "this" pointer has different value when in wxControl's
// and wxIC's method, even though the instance stays same. This doesn't matter
// so far as member pointers aren't used, but that's not wxControl's case.
// When we add an event table entry (= use a member pointer) pointing to
// wxIC's OnXXX method, GCC compiles code that executes wxIC::OnXXX with the
// version of "this" that belongs to wxControl, not wxIC! In our particular
// case, the effect is that m_handler is NULL (probably same memory
// area as the_other_vtable's_this->m_refObj) and input handling doesn't work.)
#define WX_FORWARD_TO_INPUT_CONSUMER(classname) \
void classname::OnMouse(wxMouseEvent& event) \
{ \
wxInputConsumer::OnMouse(event); \
} \
void classname::OnKeyDown(wxKeyEvent& event) \
{ \
wxInputConsumer::OnKeyDown(event); \
} \
void classname::OnKeyUp(wxKeyEvent& event) \
{ \
wxInputConsumer::OnKeyUp(event); \
} \
void classname::OnFocus(wxFocusEvent& event) \
{ \
wxInputConsumer::OnFocus(event); \
} \
void classname::OnActivate(wxActivateEvent& event) \
{ \
wxInputConsumer::OnActivate(event); \
}
#endif // _WX_UNIV_INPCONS_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/panel.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/panel.h
// Purpose: wxUniversal-specific wxPanel class.
// Author: Vadim Zeitlin
// Created: 2011-03-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_PANEL_H_
#define _WX_UNIV_PANEL_H_
// ----------------------------------------------------------------------------
// wxPanel
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPanel : public wxPanelBase
{
public:
wxPanel() { }
wxPanel(wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, winid, pos, size, style, name);
}
virtual bool IsCanvasWindow() const { return true; }
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR(
wxPanel(wxWindow *parent,
int x, int y, int width, int height,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, wxID_ANY, wxPoint(x, y), wxSize(width, height), style, name);
}
)
#endif // WXWIN_COMPATIBILITY_2_8
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxPanel);
};
#endif // _WX_UNIV_PANEL_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/toolbar.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/toolbar.h
// Purpose: wxToolBar declaration
// Author: Robert Roebling
// Modified by:
// Created: 10.09.00
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_TOOLBAR_H_
#define _WX_UNIV_TOOLBAR_H_
#include "wx/button.h" // for wxStdButtonInputHandler
class WXDLLIMPEXP_FWD_CORE wxToolBarTool;
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
#define wxACTION_TOOLBAR_TOGGLE wxACTION_BUTTON_TOGGLE
#define wxACTION_TOOLBAR_PRESS wxACTION_BUTTON_PRESS
#define wxACTION_TOOLBAR_RELEASE wxACTION_BUTTON_RELEASE
#define wxACTION_TOOLBAR_CLICK wxACTION_BUTTON_CLICK
#define wxACTION_TOOLBAR_ENTER wxT("enter") // highlight the tool
#define wxACTION_TOOLBAR_LEAVE wxT("leave") // unhighlight the tool
// ----------------------------------------------------------------------------
// wxToolBar
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
// construction/destruction
wxToolBar() { Init(); }
wxToolBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxToolBarNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
bool Create( wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxToolBarNameStr );
virtual ~wxToolBar();
virtual bool Realize() wxOVERRIDE;
virtual void SetWindowStyleFlag( long style ) wxOVERRIDE;
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual void SetToolShortHelp(int id, const wxString& helpString) wxOVERRIDE;
virtual void SetMargins(int x, int y) wxOVERRIDE;
void SetMargins(const wxSize& size)
{ SetMargins((int) size.x, (int) size.y); }
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
protected:
// common part of all ctors
void Init();
// implement base class pure virtuals
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) wxOVERRIDE;
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled,
wxItemKind kind,
wxObject *clientData,
const wxString& shortHelp,
const wxString& longHelp) wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label) wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
// get the bounding rect for the given tool
wxRect GetToolRect(wxToolBarToolBase *tool) const;
// redraw the given tool
void RefreshTool(wxToolBarToolBase *tool);
// (re)calculate the tool positions, should only be called if it is
// necessary to do it, i.e. m_needsLayout == true
void DoLayout();
// get the rect limits depending on the orientation: top/bottom for a
// vertical toolbar, left/right for a horizontal one
void GetRectLimits(const wxRect& rect, wxCoord *start, wxCoord *end) const;
private:
// have we calculated the positions of our tools?
bool m_needsLayout;
// the width of a separator
wxCoord m_widthSeparator;
// the total size of all toolbar elements
wxCoord m_maxWidth,
m_maxHeight;
private:
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
};
#endif // _WX_UNIV_TOOLBAR_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/gauge.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/gauge.h
// Purpose: wxUniversal wxGauge declaration
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.02.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_GAUGE_H_
#define _WX_UNIV_GAUGE_H_
// ----------------------------------------------------------------------------
// wxGauge: a progress bar
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGauge : public wxGaugeBase
{
public:
wxGauge() { Init(); }
wxGauge(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr)
{
Init();
(void)Create(parent, id, range, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr);
// implement base class virtuals
virtual void SetRange(int range) wxOVERRIDE;
virtual void SetValue(int pos) wxOVERRIDE;
// wxUniv-specific methods
// is it a smooth progress bar or a discrete one?
bool IsSmooth() const { return (GetWindowStyle() & wxGA_SMOOTH) != 0; }
// is it a vertica; progress bar or a horizontal one?
bool IsVertical() const { return (GetWindowStyle() & wxGA_VERTICAL) != 0; }
protected:
// common part of all ctors
void Init();
// return the def border for a progress bar
virtual wxBorder GetDefaultBorder() const wxOVERRIDE;
// return the default size
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// draw the control
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxGauge);
};
#endif // _WX_UNIV_GAUGE_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/menu.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/menu.h
// Purpose: wxMenu and wxMenuBar classes for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 05.05.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_MENU_H_
#define _WX_UNIV_MENU_H_
#if wxUSE_ACCEL
#include "wx/accel.h"
#endif // wxUSE_ACCEL
#include "wx/dynarray.h"
// fwd declarations
class WXDLLIMPEXP_FWD_CORE wxMenuInfo;
WX_DECLARE_EXPORTED_OBJARRAY(wxMenuInfo, wxMenuInfoArray);
class WXDLLIMPEXP_FWD_CORE wxMenuGeometryInfo;
class WXDLLIMPEXP_FWD_CORE wxPopupMenuWindow;
class WXDLLIMPEXP_FWD_CORE wxRenderer;
// ----------------------------------------------------------------------------
// wxMenu
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenu : public wxMenuBase
{
public:
// ctors and dtor
wxMenu(const wxString& title, long style = 0)
: wxMenuBase(title, style) { Init(); }
wxMenu(long style = 0) : wxMenuBase(style) { Init(); }
virtual ~wxMenu();
// called by wxMenuItem when an item of this menu changes
void RefreshItem(wxMenuItem *item);
// does the menu have any items?
bool IsEmpty() const { return !GetMenuItems().GetFirst(); }
// show this menu at the given position (in screen coords) and optionally
// select its first item
void Popup(const wxPoint& pos, const wxSize& size,
bool selectFirst = true);
// dismiss the menu
void Dismiss();
// override the base class methods to connect/disconnect event handlers
virtual void Attach(wxMenuBarBase *menubar) wxOVERRIDE;
virtual void Detach() wxOVERRIDE;
// implementation only from here
// do as if this item were clicked, return true if the resulting event was
// processed, false otherwise
bool ClickItem(wxMenuItem *item);
// process the key event, return true if done
bool ProcessKeyDown(int key);
#if wxUSE_ACCEL
// find the item for the given accel and generate an event if found
bool ProcessAccelEvent(const wxKeyEvent& event);
#endif // wxUSE_ACCEL
protected:
// implement base class virtuals
virtual wxMenuItem* DoAppend(wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoInsert(size_t pos, wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoRemove(wxMenuItem *item) wxOVERRIDE;
// common part of DoAppend and DoInsert
void OnItemAdded(wxMenuItem *item);
// called by wxPopupMenuWindow when the window is hidden
void OnDismiss(bool dismissParent);
// return true if the menu is currently shown on screen
bool IsShown() const;
// get the menu geometry info
const wxMenuGeometryInfo& GetGeometryInfo() const;
// forget old menu geometry info
void InvalidateGeometryInfo();
// return either the menubar or the invoking window, normally never NULL
wxWindow *GetRootWindow() const;
// get the renderer we use for drawing: either the one of the menu bar or
// the one of the window if we're a popup menu
wxRenderer *GetRenderer() const;
#if wxUSE_ACCEL
// add/remove accel for the given menu item
void AddAccelFor(wxMenuItem *item);
void RemoveAccelFor(wxMenuItem *item);
#endif // wxUSE_ACCEL
private:
// common part of all ctors
void Init();
// terminate the current radio group, if any
void EndRadioGroup();
// the exact menu geometry is defined by a struct derived from this one
// which is opaque and defined by the renderer
wxMenuGeometryInfo *m_geometry;
// the menu shown on screen or NULL if not currently shown
wxPopupMenuWindow *m_popupMenu;
#if wxUSE_ACCEL
// the accel table for this menu
wxAcceleratorTable m_accelTable;
#endif // wxUSE_ACCEL
// the position of the first item in the current radio group or -1
int m_startRadioGroup;
// it calls out OnDismiss()
friend class wxPopupMenuWindow;
wxDECLARE_DYNAMIC_CLASS(wxMenu);
};
// ----------------------------------------------------------------------------
// wxMenuBar
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuBar : public wxMenuBarBase
{
public:
// ctors and dtor
wxMenuBar(long WXUNUSED(style) = 0) { Init(); }
wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style = 0);
virtual ~wxMenuBar();
// implement base class virtuals
virtual bool Append( wxMenu *menu, const wxString &title ) wxOVERRIDE;
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Remove(size_t pos) wxOVERRIDE;
virtual void EnableTop(size_t pos, bool enable) wxOVERRIDE;
virtual bool IsEnabledTop(size_t pos) const wxOVERRIDE;
virtual void SetMenuLabel(size_t pos, const wxString& label) wxOVERRIDE;
virtual wxString GetMenuLabel(size_t pos) const wxOVERRIDE;
virtual void Attach(wxFrame *frame) wxOVERRIDE;
virtual void Detach() wxOVERRIDE;
// get the next item for the givan accel letter (used by wxFrame), return
// -1 if none
//
// if unique is not NULL, filled with true if there is only one item with
// this accel, false if two or more
int FindNextItemForAccel(int idxStart,
int keycode,
bool *unique = NULL) const;
// called by wxFrame to set focus to or open the given menu
void SelectMenu(size_t pos);
void PopupMenu(size_t pos);
#if wxUSE_ACCEL
// find the item for the given accel and generate an event if found
bool ProcessAccelEvent(const wxKeyEvent& event);
#endif // wxUSE_ACCEL
// called by wxMenu when it is dismissed
void OnDismissMenu(bool dismissMenuBar = false);
protected:
// common part of all ctors
void Init();
// event handlers
void OnLeftDown(wxMouseEvent& event);
void OnMouseMove(wxMouseEvent& event);
void OnKeyDown(wxKeyEvent& event);
void OnKillFocus(wxFocusEvent& event);
// process the mouse move event, return true if we did, false to continue
// processing as usual
//
// the coordinates are client coordinates of menubar, convert if necessary
bool ProcessMouseEvent(const wxPoint& pt);
// called when the menu bar loses mouse capture - it is not hidden unlike
// menus, but it doesn't have modal status any longer
void OnDismiss();
// draw the menubar
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
// menubar geometry
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// has the menubar been created already?
bool IsCreated() const { return m_frameLast != NULL; }
// "fast" version of GetMenuCount()
size_t GetCount() const { return m_menuInfos.GetCount(); }
// get the (total) width of the specified menu
wxCoord GetItemWidth(size_t pos) const;
// get the rect of the item
wxRect GetItemRect(size_t pos) const;
// get the menu from the given point or -1 if none
int GetMenuFromPoint(const wxPoint& pos) const;
// refresh the given item
void RefreshItem(size_t pos);
// refresh all items after this one (including it)
void RefreshAllItemsAfter(size_t pos);
// hide the currently shown menu and show this one
void DoSelectMenu(size_t pos);
// popup the currently selected menu
void PopupCurrentMenu(bool selectFirst = true);
// hide the currently selected menu
void DismissMenu();
// do we show a menu currently?
bool IsShowingMenu() const { return m_menuShown != 0; }
// we don't want to have focus except while selecting from menu
void GiveAwayFocus();
// Release the mouse capture if we have it
bool ReleaseMouseCapture();
// the array containing extra menu info we need
wxMenuInfoArray m_menuInfos;
// the current item (only used when menubar has focus)
int m_current;
private:
// the last frame to which we were attached, NULL initially
wxFrame *m_frameLast;
// the currently shown menu or NULL
wxMenu *m_menuShown;
// should be showing the menu? this is subtly different from m_menuShown !=
// NULL as the menu which should be shown may be disabled in which case we
// don't show it - but will do as soon as the focus shifts to another menu
bool m_shouldShowMenu;
// it calls out ProcessMouseEvent()
friend class wxPopupMenuWindow;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxMenuBar);
};
#endif // _WX_UNIV_MENU_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/checkbox.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/checkbox.h
// Purpose: wxCheckBox declaration
// Author: Vadim Zeitlin
// Modified by:
// Created: 07.09.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_CHECKBOX_H_
#define _WX_UNIV_CHECKBOX_H_
#include "wx/button.h" // for wxStdButtonInputHandler
// ----------------------------------------------------------------------------
// the actions supported by wxCheckBox
// ----------------------------------------------------------------------------
#define wxACTION_CHECKBOX_CHECK wxT("check") // SetValue(true)
#define wxACTION_CHECKBOX_CLEAR wxT("clear") // SetValue(false)
#define wxACTION_CHECKBOX_TOGGLE wxT("toggle") // toggle the check state
// additionally it accepts wxACTION_BUTTON_PRESS and RELEASE
// ----------------------------------------------------------------------------
// wxCheckBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxCheckBox : public wxCheckBoxBase
{
public:
// checkbox constants
enum State
{
State_Normal,
State_Pressed,
State_Disabled,
State_Current,
State_Max
};
enum Status
{
Status_Checked,
Status_Unchecked,
Status_3rdState,
Status_Max
};
// constructors
wxCheckBox() { Init(); }
wxCheckBox(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
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 = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
// implement the checkbox interface
virtual void SetValue(bool value) wxOVERRIDE;
virtual bool GetValue() const wxOVERRIDE;
// set/get the bitmaps to use for the checkbox indicator
void SetBitmap(const wxBitmap& bmp, State state, Status status);
virtual wxBitmap GetBitmap(State state, Status status) const;
// wxCheckBox actions
void Toggle();
virtual void Press();
virtual void Release();
virtual void ChangeValue(bool value);
// overridden base class virtuals
virtual bool IsPressed() const wxOVERRIDE { return m_isPressed; }
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
virtual bool CanBeHighlighted() const wxOVERRIDE { return true; }
virtual wxInputHandler *CreateStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return CreateStdInputHandler(handlerDef);
}
protected:
virtual void DoSet3StateValue(wxCheckBoxState WXUNUSED(state)) wxOVERRIDE;
virtual wxCheckBoxState DoGet3StateValue() const wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// get the size of the bitmap using either the current one or the default
// one (query renderer then)
virtual wxSize GetBitmapSize() const;
// common part of all ctors
void Init();
// send command event notifying about the checkbox state change
virtual void SendEvent();
// called when the checkbox becomes checked - radio button hook
virtual void OnCheck();
// get the state corresponding to the flags (combination of wxCONTROL_XXX)
wxCheckBox::State GetState(int flags) const;
// directly access the bitmaps array without trying to find a valid bitmap
// to use as GetBitmap() does
wxBitmap DoGetBitmap(State state, Status status) const
{ return m_bitmaps[state][status]; }
// get the current status
Status GetStatus() const { return m_status; }
private:
// the current check status
Status m_status;
// the bitmaps to use for the different states
wxBitmap m_bitmaps[State_Max][Status_Max];
// is the checkbox currently pressed?
bool m_isPressed;
wxDECLARE_DYNAMIC_CLASS(wxCheckBox);
};
#endif // _WX_UNIV_CHECKBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/bmpbuttn.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/bmpbuttn.h
// Purpose: wxBitmapButton class for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 25.08.00
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_BMPBUTTN_H_
#define _WX_UNIV_BMPBUTTN_H_
class WXDLLIMPEXP_CORE wxBitmapButton : public wxBitmapButtonBase
{
public:
wxBitmapButton() { }
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetMargins(int x, int y) wxOVERRIDE
{
SetBitmapMargins(x, y);
wxBitmapButtonBase::SetMargins(x, y);
}
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool SetCurrent(bool doit = true) wxOVERRIDE;
virtual void Press() wxOVERRIDE;
virtual void Release() wxOVERRIDE;
protected:
void OnSetFocus(wxFocusEvent& event);
void OnKillFocus(wxFocusEvent& event);
// called when one of the bitmap is changed by user
virtual void OnSetBitmap() wxOVERRIDE;
// set bitmap to the given one if it's ok or to the normal bitmap and
// return true if the bitmap really changed
bool ChangeBitmap(const wxBitmap& bmp);
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxBitmapButton);
};
#endif // _WX_UNIV_BMPBUTTN_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/custombgwin.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/custombgwin.h
// Purpose: wxUniv implementation of wxCustomBackgroundWindow.
// Author: Vadim Zeitlin
// Created: 2011-10-10
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_CUSTOMBGWIN_H_
#define _WX_UNIV_CUSTOMBGWIN_H_
// ----------------------------------------------------------------------------
// wxCustomBackgroundWindow
// ----------------------------------------------------------------------------
template <class W>
class wxCustomBackgroundWindow : public W,
public wxCustomBackgroundWindowBase
{
public:
typedef W BaseWindowClass;
wxCustomBackgroundWindow() { }
protected:
virtual void DoSetBackgroundBitmap(const wxBitmap& bmp) wxOVERRIDE
{
// We have support for background bitmap even at the base class level.
BaseWindowClass::SetBackground(bmp, wxALIGN_NOT, wxTILE);
}
wxDECLARE_NO_COPY_TEMPLATE_CLASS(wxCustomBackgroundWindow, W);
};
#endif // _WX_UNIV_CUSTOMBGWIN_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/colschem.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/colschem.h
// Purpose: wxColourScheme class provides the colours to use for drawing
// Author: Vadim Zeitlin
// Modified by:
// Created: 19.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_COLSCHEM_H_
#define _WX_UNIV_COLSCHEM_H_
class WXDLLIMPEXP_FWD_CORE wxWindow;
#include "wx/colour.h"
#include "wx/checkbox.h"
// ----------------------------------------------------------------------------
// wxColourScheme
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxColourScheme
{
public:
// the standard colours
enum StdColour
{
// the background colour for a window
WINDOW,
// the different background and text colours for the control
CONTROL,
CONTROL_PRESSED,
CONTROL_CURRENT,
// the label text for the normal and the disabled state
CONTROL_TEXT,
CONTROL_TEXT_DISABLED,
CONTROL_TEXT_DISABLED_SHADOW,
// the scrollbar background colour for the normal and pressed states
SCROLLBAR,
SCROLLBAR_PRESSED,
// the background and text colour for the highlighted item
HIGHLIGHT,
HIGHLIGHT_TEXT,
// these colours are used for drawing the shadows of 3D objects
SHADOW_DARK,
SHADOW_HIGHLIGHT,
SHADOW_IN,
SHADOW_OUT,
// the titlebar background colours for the normal and focused states
TITLEBAR,
TITLEBAR_ACTIVE,
// the titlebar text colours
TITLEBAR_TEXT,
TITLEBAR_ACTIVE_TEXT,
// the default gauge fill colour
GAUGE,
// desktop background colour (only used by framebuffer ports)
DESKTOP,
// wxFrame's background colour
FRAME,
MAX
};
// get a standard colour
virtual wxColour Get(StdColour col) const = 0;
// get the background colour for the given window
virtual wxColour GetBackground(wxWindow *win) const = 0;
// virtual dtor for any base class
virtual ~wxColourScheme() {}
};
// some people just can't spell it correctly :-)
typedef wxColourScheme wxColorScheme;
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// retrieve the default colour from the theme or the given scheme
#define wxSCHEME_COLOUR(scheme, what) scheme->Get(wxColorScheme::what)
#define wxTHEME_COLOUR(what) \
wxSCHEME_COLOUR(wxTheme::Get()->GetColourScheme(), what)
// get the background colour for the window in the current theme
#define wxTHEME_BG_COLOUR(win) \
wxTheme::Get()->GetColourScheme()->GetBackground(win)
#endif // _WX_UNIV_COLSCHEM_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/scrolbar.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/scrolbar.h
// Purpose: wxScrollBar for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_SCROLBAR_H_
#define _WX_UNIV_SCROLBAR_H_
class WXDLLIMPEXP_FWD_CORE wxScrollTimer;
#include "wx/univ/scrarrow.h"
#include "wx/renderer.h"
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
// scroll the bar
#define wxACTION_SCROLL_START wxT("start") // to the beginning
#define wxACTION_SCROLL_END wxT("end") // to the end
#define wxACTION_SCROLL_LINE_UP wxT("lineup") // one line up/left
#define wxACTION_SCROLL_PAGE_UP wxT("pageup") // one page up/left
#define wxACTION_SCROLL_LINE_DOWN wxT("linedown") // one line down/right
#define wxACTION_SCROLL_PAGE_DOWN wxT("pagedown") // one page down/right
// the scrollbar thumb may be dragged
#define wxACTION_SCROLL_THUMB_DRAG wxT("thumbdrag")
#define wxACTION_SCROLL_THUMB_MOVE wxT("thumbmove")
#define wxACTION_SCROLL_THUMB_RELEASE wxT("thumbrelease")
// ----------------------------------------------------------------------------
// wxScrollBar
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxScrollBar : public wxScrollBarBase,
public wxControlWithArrows
{
public:
// scrollbar elements: they correspond to wxHT_SCROLLBAR_XXX constants but
// start from 0 which allows to use them as array indices
enum Element
{
Element_Arrow_Line_1,
Element_Arrow_Line_2,
Element_Arrow_Page_1,
Element_Arrow_Page_2,
Element_Thumb,
Element_Bar_1,
Element_Bar_2,
Element_Max
};
wxScrollBar();
wxScrollBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr);
virtual ~wxScrollBar();
// implement base class pure virtuals
virtual int GetThumbPosition() const wxOVERRIDE;
virtual int GetThumbSize() const wxOVERRIDE;
virtual int GetPageSize() const wxOVERRIDE;
virtual int GetRange() const wxOVERRIDE;
virtual void SetThumbPosition(int thumbPos) wxOVERRIDE;
virtual void SetScrollbar(int position, int thumbSize,
int range, int pageSize,
bool refresh = true) wxOVERRIDE;
// wxScrollBar actions
void ScrollToStart();
void ScrollToEnd();
bool ScrollLines(int nLines) wxOVERRIDE;
bool ScrollPages(int nPages) wxOVERRIDE;
virtual bool PerformAction(const wxControlAction& action,
long numArg = 0,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
// scrollbars around a normal window should not receive the focus
virtual bool AcceptsFocus() const wxOVERRIDE;
// wxScrollBar sub elements state (combination of wxCONTROL_XXX)
void SetState(Element which, int flags);
int GetState(Element which) const;
// implement wxControlWithArrows methods
virtual wxRenderer *GetRenderer() const wxOVERRIDE { return m_renderer; }
virtual wxWindow *GetWindow() wxOVERRIDE { return this; }
virtual bool IsVertical() const wxOVERRIDE { return wxScrollBarBase::IsVertical(); }
virtual int GetArrowState(wxScrollArrows::Arrow arrow) const wxOVERRIDE;
virtual void SetArrowFlag(wxScrollArrows::Arrow arrow, int flag, bool set) wxOVERRIDE;
virtual bool OnArrow(wxScrollArrows::Arrow arrow) wxOVERRIDE;
virtual wxScrollArrows::Arrow HitTestArrow(const wxPoint& pt) const wxOVERRIDE;
// for wxControlRenderer::DrawScrollbar() only
const wxScrollArrows& GetArrows() const { return m_arrows; }
// returns one of wxHT_SCROLLBAR_XXX constants
wxHitTest HitTestBar(const wxPoint& pt) const;
// idle processing
virtual void OnInternalIdle() wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// forces update of thumb's visual appearence (does nothing if m_dirty=false)
void UpdateThumb();
// SetThumbPosition() helper
void DoSetThumb(int thumbPos);
// common part of all ctors
void Init();
// is this scrollbar attached to a window or a standalone control?
bool IsStandalone() const;
// scrollbar geometry methods:
// gets the bounding box for a scrollbar element for the given (by default
// - current) thumb position
wxRect GetScrollbarRect(wxScrollBar::Element elem, int thumbPos = -1) const;
// returns the size of the scrollbar shaft excluding the arrows
wxCoord GetScrollbarSize() const;
// translate the scrollbar position (in logical units) into physical
// coordinate (in pixels) and the other way round
wxCoord ScrollbarToPixel(int thumbPos = -1);
int PixelToScrollbar(wxCoord coord);
// return the starting and ending positions, in pixels, of the thumb of a
// scrollbar with the given logical position, thumb size and range and the
// given physical length
static void GetScrollBarThumbSize(wxCoord length,
int thumbPos,
int thumbSize,
int range,
wxCoord *thumbStart,
wxCoord *thumbEnd);
private:
// total range of the scrollbar in logical units
int m_range;
// the current and previous (after last refresh - this is used for
// repainting optimisation) size of the thumb in logical units (from 0 to
// m_range) and its position (from 0 to m_range - m_thumbSize)
int m_thumbSize,
m_thumbPos,
m_thumbPosOld;
// the page size, i.e. the number of lines by which to scroll when page
// up/down action is performed
int m_pageSize;
// the state of the sub elements
int m_elementsState[Element_Max];
// the dirty flag: if set, scrollbar must be updated
bool m_dirty;
// the object handling the arrows
wxScrollArrows m_arrows;
friend class WXDLLIMPEXP_FWD_CORE wxControlRenderer; // for geometry methods
friend class wxStdScrollBarInputHandler; // for geometry methods
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxScrollBar);
};
// ----------------------------------------------------------------------------
// Standard scrollbar input handler which can be used as a base class
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStdScrollBarInputHandler : public wxStdInputHandler
{
public:
// constructor takes a renderer (used for scrollbar hit testing) and the
// base handler to which all unhandled events are forwarded
wxStdScrollBarInputHandler(wxRenderer *renderer,
wxInputHandler *inphand);
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed) wxOVERRIDE;
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event) wxOVERRIDE;
virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event) wxOVERRIDE;
virtual ~wxStdScrollBarInputHandler();
// this method is called by wxScrollBarTimer only and may be overridden
//
// return true to continue scrolling, false to stop the timer
virtual bool OnScrollTimer(wxScrollBar *scrollbar,
const wxControlAction& action);
protected:
// return true if the mouse button can be used to activate scrollbar, false
// if not (any button under GTK+ unlike left button only which is default)
virtual bool IsAllowedButton(int button) const
{ return button == wxMOUSE_BTN_LEFT; }
// set or clear the specified flag on the scrollbar element corresponding
// to m_htLast
void SetElementState(wxScrollBar *scrollbar, int flag, bool doIt);
// [un]highlight the scrollbar element corresponding to m_htLast
virtual void Highlight(wxScrollBar *scrollbar, bool doIt)
{ SetElementState(scrollbar, wxCONTROL_CURRENT, doIt); }
// [un]press the scrollbar element corresponding to m_htLast
virtual void Press(wxScrollBar *scrollbar, bool doIt)
{ SetElementState(scrollbar, wxCONTROL_PRESSED, doIt); }
// stop scrolling because we reached the end point
void StopScrolling(wxScrollBar *scrollbar);
// get the mouse coordinates in the scrollbar direction from the event
wxCoord GetMouseCoord(const wxScrollBar *scrollbar,
const wxMouseEvent& event) const;
// generate a "thumb move" action for this mouse event
void HandleThumbMove(wxScrollBar *scrollbar, const wxMouseEvent& event);
// the window (scrollbar) which has capture or NULL and the flag telling if
// the mouse is inside the element which captured it or not
wxWindow *m_winCapture;
bool m_winHasMouse;
int m_btnCapture; // the mouse button which has captured mouse
// the position where we started scrolling by page
wxPoint m_ptStartScrolling;
// one of wxHT_SCROLLBAR_XXX value: where has the mouse been last time?
wxHitTest m_htLast;
// the renderer (we use it only for hit testing)
wxRenderer *m_renderer;
// the offset of the top/left of the scrollbar relative to the mouse to
// keep during the thumb drag
int m_ofsMouse;
// the timer for generating scroll events when the mouse stays pressed on
// a scrollbar
wxScrollTimer *m_timerScroll;
};
#endif // _WX_UNIV_SCROLBAR_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/choice.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/choice.h
// Purpose: the universal choice
// Author: Vadim Zeitlin
// Modified by:
// Created: 30.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_CHOICE_H_
#define _WX_UNIV_CHOICE_H_
#include "wx/combobox.h"
// VS: This is only a *temporary* implementation, real wxChoice should not
// derive from wxComboBox and may have different l&f
class WXDLLIMPEXP_CORE wxChoice : public wxComboBox
{
public:
wxChoice() {}
wxChoice(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxChoice(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
private:
void OnComboBox(wxCommandEvent &event);
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxChoice);
};
#endif // _WX_UNIV_CHOICE_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/scrthumb.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/scrthumb.h
// Purpose: wxScrollThumb class
// Author: Vadim Zeitlin
// Modified by:
// Created: 12.02.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_SCRTHUMB_H_
#define _WX_UNIV_SCRTHUMB_H_
// ----------------------------------------------------------------------------
// wxScrollThumb is not a control but just a class containing the common
// functionality of scroll thumb such as used by scrollbars, sliders and maybe
// other (user) controls
//
// This class is similar to wxScrollThumb.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxControlWithThumb;
class WXDLLIMPEXP_FWD_CORE wxMouseEvent;
class WXDLLIMPEXP_FWD_CORE wxRect;
class WXDLLIMPEXP_FWD_CORE wxScrollTimer;
#include "wx/timer.h"
// ----------------------------------------------------------------------------
// wxScrollThumb: an abstraction of scrollbar thumb
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxScrollThumb
{
public:
enum Shaft
{
Shaft_None = -1,
Shaft_Above, // or to the left of the thumb
Shaft_Below, // or to the right of the thumb
Shaft_Thumb, // on the thumb
Shaft_Max
};
// ctor requires a back pointer to wxControlWithThumb
wxScrollThumb(wxControlWithThumb *control);
// process a mouse click: will capture the mouse if the button was pressed
// on either the thumb (start dragging it then) or the shaft (start
// scrolling)
bool HandleMouse(const wxMouseEvent& event) const;
// process a mouse move
bool HandleMouseMove(const wxMouseEvent& event) const;
// dtor
~wxScrollThumb();
private:
// do we have the mouse capture?
bool HasCapture() const { return m_captureData != NULL; }
// get the coord of this event in the direction we're interested in (y for
// vertical shaft or x for horizontal ones)
wxCoord GetMouseCoord(const wxMouseEvent& event) const;
// get the position of the thumb corresponding to the current mouse
// position (can only be called while we're dragging the thumb!)
int GetThumbPos(const wxMouseEvent& event) const;
// the main control
wxControlWithThumb *m_control;
// the part of it where the mouse currently is
Shaft m_shaftPart;
// the data for the mouse capture
struct WXDLLIMPEXP_FWD_CORE wxScrollThumbCaptureData *m_captureData;
};
// ----------------------------------------------------------------------------
// wxControlWithThumb: interface implemented by controls using wxScrollThumb
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxControlWithThumb
{
public:
virtual ~wxControlWithThumb() {}
// simple accessors
// ----------------
// get the controls window (used for mouse capturing)
virtual wxWindow *GetWindow() = 0;
// get the orientation of the shaft (vertical or horizontal)
virtual bool IsVertical() const = 0;
// geometry functions
// ------------------
// hit testing: return part of the shaft the point is in (or Shaft_None)
virtual wxScrollThumb::Shaft HitTest(const wxPoint& pt) const = 0;
// get the current position in pixels of the thumb
virtual wxCoord ThumbPosToPixel() const = 0;
// transform from pixel offset to the thumb logical position
virtual int PixelToThumbPos(wxCoord x) const = 0;
// callbacks
// ---------
// set or clear the specified flag in the arrow state: this function is
// responsible for refreshing the control
virtual void SetShaftPartState(wxScrollThumb::Shaft shaftPart,
int flag,
bool set = true) = 0;
// called when the user starts dragging the thumb
virtual void OnThumbDragStart(int pos) = 0;
// called while the user drags the thumb
virtual void OnThumbDrag(int pos) = 0;
// called when the user stops dragging the thumb
virtual void OnThumbDragEnd(int pos) = 0;
// called before starting to call OnPageScroll() - gives the control the
// possibility to remember its current state
virtual void OnPageScrollStart() = 0;
// called while the user keeps the mouse pressed above/below the thumb,
// return true to continue scrollign and false to stop it (e.g. because the
// scrollbar has reached the top/bottom)
virtual bool OnPageScroll(int pageInc) = 0;
};
#endif // _WX_UNIV_SCRTHUMB_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/dialog.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/dialog.h
// Purpose: wxDialog class
// Author: Vaclav Slavik
// Created: 2001/09/16
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_DIALOG_H_
#define _WX_UNIV_DIALOG_H_
extern WXDLLIMPEXP_DATA_CORE(const char) wxDialogNameStr[];
class WXDLLIMPEXP_FWD_CORE wxWindowDisabler;
class WXDLLIMPEXP_FWD_CORE wxEventLoop;
// Dialog boxes
class WXDLLIMPEXP_CORE wxDialog : public wxDialogBase
{
public:
wxDialog() { Init(); }
// Constructor with no modal flag - the new convention.
wxDialog(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxDialogNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxDialogNameStr);
virtual ~wxDialog();
// is the dialog in modal state right now?
virtual bool IsModal() const wxOVERRIDE;
// For now, same as Show(true) but returns return code
virtual int ShowModal() wxOVERRIDE;
// may be called to terminate the dialog with the given return code
virtual void EndModal(int retCode) wxOVERRIDE;
// returns true if we're in a modal loop
bool IsModalShowing() const;
virtual bool Show(bool show = true) wxOVERRIDE;
// implementation only from now on
// -------------------------------
// event handlers
void OnCloseWindow(wxCloseEvent& event);
void OnOK(wxCommandEvent& event);
void OnApply(wxCommandEvent& event);
void OnCancel(wxCommandEvent& event);
protected:
// common part of all ctors
void Init();
private:
// while we are showing a modal dialog we disable the other windows using
// this object
wxWindowDisabler *m_windowDisabler;
// modal dialog runs its own event loop
wxEventLoop *m_eventLoop;
// is modal right now?
bool m_isShowingModal;
wxDECLARE_DYNAMIC_CLASS(wxDialog);
wxDECLARE_EVENT_TABLE();
};
#endif
// _WX_UNIV_DIALOG_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/tglbtn.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/tglbtn.h
// Purpose: wxToggleButton for wxUniversal
// Author: Vadim Zeitlin
// Modified by: David Bjorkevik
// Created: 16.05.06
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_TGLBTN_H_
#define _WX_UNIV_TGLBTN_H_
// ----------------------------------------------------------------------------
// wxToggleButton: a push button
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxToggleButton: public wxToggleButtonBase
{
public:
wxToggleButton();
wxToggleButton(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
// Create the control
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& lbl = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
virtual bool IsPressed() const wxOVERRIDE { return m_isPressed || m_value; }
// wxToggleButton actions
virtual void Toggle() wxOVERRIDE;
virtual void Click() wxOVERRIDE;
// Get/set the value
void SetValue(bool state);
bool GetValue() const { return m_value; }
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// the current value
bool m_value;
private:
// common part of all ctors
void Init();
wxDECLARE_DYNAMIC_CLASS(wxToggleButton);
};
#endif // _WX_UNIV_TGLBTN_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/combobox.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/combobox.h
// Purpose: the universal combobox
// Author: Vadim Zeitlin
// Modified by:
// Created: 30.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_COMBOBOX_H_
#define _WX_UNIV_COMBOBOX_H_
#include "wx/combo.h"
class WXDLLIMPEXP_FWD_CORE wxListBox;
// ----------------------------------------------------------------------------
// NB: some actions supported by this control are in wx/generic/combo.h
// ----------------------------------------------------------------------------
// choose the next/prev/specified (by numArg) item
#define wxACTION_COMBOBOX_SELECT_NEXT wxT("next")
#define wxACTION_COMBOBOX_SELECT_PREV wxT("prev")
#define wxACTION_COMBOBOX_SELECT wxT("select")
// ----------------------------------------------------------------------------
// wxComboBox: a combination of text control and a listbox
// ----------------------------------------------------------------------------
// NB: Normally we'd like wxComboBox to inherit from wxComboBoxBase, but here
// we can't really do that since both wxComboBoxBase and wxComboCtrl inherit
// from wxTextCtrl.
class WXDLLIMPEXP_CORE wxComboBox :
public wxWindowWithItems<wxComboCtrl, wxItemContainer>
{
public:
// ctors and such
wxComboBox() { Init(); }
wxComboBox(wxWindow *parent,
wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0,
const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
Init();
(void)Create(parent, id, value, pos, size, n, choices,
style, validator, name);
}
wxComboBox(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0,
const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
virtual ~wxComboBox();
// the wxUniversal-specific methods
// --------------------------------
// implement the combobox interface
// wxTextCtrl methods
virtual wxString GetValue() const wxOVERRIDE { return DoGetValue(); }
virtual void SetValue(const wxString& value) wxOVERRIDE;
virtual void WriteText(const wxString& value) wxOVERRIDE;
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
virtual void SetInsertionPoint(long pos) wxOVERRIDE;
virtual void SetInsertionPointEnd() wxOVERRIDE;
virtual long GetInsertionPoint() const wxOVERRIDE;
virtual wxTextPos GetLastPosition() const wxOVERRIDE;
virtual void Replace(long from, long to, const wxString& value) wxOVERRIDE;
virtual void Remove(long from, long to) wxOVERRIDE;
virtual void SetSelection(long from, long to) wxOVERRIDE;
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual void SetEditable(bool editable) wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
virtual void SelectAll() wxOVERRIDE;
virtual bool CanCopy() const wxOVERRIDE;
virtual bool CanCut() const wxOVERRIDE;
virtual bool CanPaste() const wxOVERRIDE;
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
// override these methods to disambiguate between two base classes versions
virtual void Clear() wxOVERRIDE
{
wxItemContainer::Clear();
}
// See wxComboBoxBase discussion of IsEmpty().
bool IsListEmpty() const { return wxItemContainer::IsEmpty(); }
bool IsTextEmpty() const { return wxTextEntry::IsEmpty(); }
// wxControlWithItems methods
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& s) wxOVERRIDE;
virtual int FindString(const wxString& s, bool bCase = false) const wxOVERRIDE;
virtual void SetSelection(int n) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual wxString GetStringSelection() const wxOVERRIDE;
// we have our own input handler and our own actions
// (but wxComboCtrl already handled Popup/Dismiss)
/*
virtual bool PerformAction(const wxControlAction& action,
long numArg = 0l,
const wxString& strArg = wxEmptyString);
*/
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
// we delegate our client data handling to wxListBox which we use for the
// items, so override this and other methods dealing with the client data
virtual wxClientDataType GetClientDataType() const wxOVERRIDE;
virtual void SetClientDataType(wxClientDataType clientDataItemsType) wxOVERRIDE;
protected:
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
// common part of all ctors
void Init();
// get the associated listbox
wxListBox *GetLBox() const { return m_lbox; }
private:
// implement wxTextEntry pure virtual method
virtual wxWindow *GetEditableWindow() wxOVERRIDE { return this; }
// the popup listbox
wxListBox *m_lbox;
//wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxComboBox);
};
#endif // _WX_UNIV_COMBOBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/setup_inc.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/setup_inc.h
// Purpose: wxUniversal-specific setup.h options (this file is not used
// directly, it is injected by build/update-setup-h in the
// generated include/wx/univ/setup0.h)
// Author: Vadim Zeitlin
// Created: 2008-02-03
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/theme.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/theme.h
// Purpose: wxTheme class manages all configurable aspects of the
// application including the look (wxRenderer), feel
// (wxInputHandler) and the colours (wxColourScheme)
// Author: Vadim Zeitlin
// Modified by:
// Created: 06.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_THEME_H_
#define _WX_UNIV_THEME_H_
#include "wx/string.h"
// ----------------------------------------------------------------------------
// wxTheme
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxArtProvider;
class WXDLLIMPEXP_FWD_CORE wxColourScheme;
class WXDLLIMPEXP_FWD_CORE wxInputConsumer;
class WXDLLIMPEXP_FWD_CORE wxInputHandler;
class WXDLLIMPEXP_FWD_CORE wxRenderer;
struct WXDLLIMPEXP_FWD_CORE wxThemeInfo;
class WXDLLIMPEXP_CORE wxTheme
{
public:
// static methods
// --------------
// create the default theme
static bool CreateDefault();
// create the theme by name (will return NULL if not found)
static wxTheme *Create(const wxString& name);
// change the current scheme
static wxTheme *Set(wxTheme *theme);
// get the current theme (never NULL)
static wxTheme *Get() { return ms_theme; }
// the theme methods
// -----------------
// get the renderer implementing all the control-drawing operations in
// this theme
virtual wxRenderer *GetRenderer() = 0;
// get the art provider to be used together with this theme
virtual wxArtProvider *GetArtProvider() = 0;
// get the input handler of the given type, forward to the standard one
virtual wxInputHandler *GetInputHandler(const wxString& handlerType,
wxInputConsumer *consumer) = 0;
// get the colour scheme for the control with this name
virtual wxColourScheme *GetColourScheme() = 0;
// implementation only from now on
// -------------------------------
virtual ~wxTheme();
private:
// the list of descriptions of all known themes
static wxThemeInfo *ms_allThemes;
// the current theme
static wxTheme *ms_theme;
friend struct wxThemeInfo;
};
// ----------------------------------------------------------------------------
// wxDelegateTheme: it is impossible to inherit from any of standard
// themes as their declarations are in private code, but you can use this
// class to override only some of their functions - all the other ones
// will be left to the original theme
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDelegateTheme : public wxTheme
{
public:
wxDelegateTheme(const wxString& theme);
virtual ~wxDelegateTheme();
virtual wxRenderer *GetRenderer();
virtual wxArtProvider *GetArtProvider();
virtual wxInputHandler *GetInputHandler(const wxString& control,
wxInputConsumer *consumer);
virtual wxColourScheme *GetColourScheme();
protected:
// gets or creates theme and sets m_theme to point to it,
// returns true on success
bool GetOrCreateTheme();
wxString m_themeName;
wxTheme *m_theme;
};
// ----------------------------------------------------------------------------
// dynamic theme creation helpers
// ----------------------------------------------------------------------------
struct WXDLLIMPEXP_CORE wxThemeInfo
{
typedef wxTheme *(*Constructor)();
// theme name and (user readable) description
wxString name, desc;
// the function to create a theme object
Constructor ctor;
// next node in the linked list or NULL
wxThemeInfo *next;
// constructor for the struct itself
wxThemeInfo(Constructor ctor, const wxString& name, const wxString& desc);
};
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// to use a standard theme insert this macro into one of the application files:
// without it, an over optimizing linker may discard the object module
// containing the theme implementation entirely
#define WX_USE_THEME(themename) \
/* this indirection makes it possible to pass macro as the argument */ \
WX_USE_THEME_IMPL(themename)
#define WX_USE_THEME_IMPL(themename) \
extern WXDLLIMPEXP_DATA_CORE(bool) wxThemeUse##themename; \
static struct wxThemeUserFor##themename \
{ \
wxThemeUserFor##themename() { wxThemeUse##themename = true; } \
} wxThemeDoUse##themename
// to declare a new theme, this macro must be used in the class declaration
#define WX_DECLARE_THEME(themename) \
private: \
static wxThemeInfo ms_info##themename; \
public: \
const wxThemeInfo *GetThemeInfo() const \
{ return &ms_info##themename; }
// and this one must be inserted in the source file
#define WX_IMPLEMENT_THEME(classname, themename, themedesc) \
WXDLLIMPEXP_DATA_CORE(bool) wxThemeUse##themename = true; \
wxTheme *wxCtorFor##themename() { return new classname; } \
wxThemeInfo classname::ms_info##themename(wxCtorFor##themename, \
wxT( #themename ), themedesc)
// ----------------------------------------------------------------------------
// determine default theme
// ----------------------------------------------------------------------------
#if wxUSE_ALL_THEMES
#undef wxUSE_THEME_WIN32
#define wxUSE_THEME_WIN32 1
#undef wxUSE_THEME_GTK
#define wxUSE_THEME_GTK 1
#undef wxUSE_THEME_MONO
#define wxUSE_THEME_MONO 1
#undef wxUSE_THEME_METAL
#define wxUSE_THEME_METAL 1
#endif // wxUSE_ALL_THEMES
// determine the default theme to use:
#if defined(__WXGTK__) && wxUSE_THEME_GTK
#define wxUNIV_DEFAULT_THEME gtk
#elif defined(__WXDFB__) && wxUSE_THEME_MONO
// use mono theme for DirectFB port because it cannot correctly
// render neither win32 nor gtk themes yet:
#define wxUNIV_DEFAULT_THEME mono
#endif
// if no theme was picked, get any theme compiled in (sorted by
// quality/completeness of the theme):
#ifndef wxUNIV_DEFAULT_THEME
#if wxUSE_THEME_GTK
#define wxUNIV_DEFAULT_THEME gtk
#elif wxUSE_THEME_WIN32
#define wxUNIV_DEFAULT_THEME win32
#elif wxUSE_THEME_MONO
#define wxUNIV_DEFAULT_THEME mono
#endif
// If nothing matches, no themes are compiled and the app must provide
// some theme itself
// (note that wxUSE_THEME_METAL depends on win32 theme, so we don't have to
// try it)
//
#endif // !wxUNIV_DEFAULT_THEME
#endif // _WX_UNIV_THEME_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/window.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/window.h
// Purpose: wxWindow class which is the base class for all
// wxUniv port controls, it supports the customization of the
// window drawing and input processing.
// Author: Vadim Zeitlin
// Modified by:
// Created: 06.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_WINDOW_H_
#define _WX_UNIV_WINDOW_H_
#include "wx/bitmap.h" // for m_bitmapBg
class WXDLLIMPEXP_FWD_CORE wxControlRenderer;
class WXDLLIMPEXP_FWD_CORE wxEventLoop;
#if wxUSE_MENUS
class WXDLLIMPEXP_FWD_CORE wxMenu;
class WXDLLIMPEXP_FWD_CORE wxMenuBar;
#endif // wxUSE_MENUS
class WXDLLIMPEXP_FWD_CORE wxRenderer;
#if wxUSE_SCROLLBAR
class WXDLLIMPEXP_FWD_CORE wxScrollBar;
#endif // wxUSE_SCROLLBAR
#ifdef __WXX11__
#define wxUSE_TWO_WINDOWS 1
#else
#define wxUSE_TWO_WINDOWS 0
#endif
// ----------------------------------------------------------------------------
// wxWindow
// ----------------------------------------------------------------------------
#if defined(__WXMSW__)
#define wxWindowNative wxWindowMSW
#elif defined(__WXGTK__)
#define wxWindowNative wxWindowGTK
#elif defined(__WXX11__)
#define wxWindowNative wxWindowX11
#elif defined(__WXMAC__)
#define wxWindowNative wxWindowMac
#endif
class WXDLLIMPEXP_CORE wxWindow : public wxWindowNative
{
public:
// ctors and create functions
// ---------------------------
wxWindow() { Init(); }
wxWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
: wxWindowNative(parent, id, pos, size, style | wxCLIP_CHILDREN, name)
{ Init(); }
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
virtual ~wxWindow();
// background pixmap support
// -------------------------
virtual void SetBackground(const wxBitmap& bitmap,
int alignment = wxALIGN_CENTRE,
wxStretch stretch = wxSTRETCH_NOT);
const wxBitmap& GetBackgroundBitmap(int *alignment = NULL,
wxStretch *stretch = NULL) const;
// scrollbars: we (re)implement it ourselves using our own scrollbars
// instead of the native ones
// ------------------------------------------------------------------
virtual void SetScrollbar(int orient,
int pos,
int page,
int range,
bool refresh = true ) wxOVERRIDE;
virtual void SetScrollPos(int orient, int pos, bool refresh = true) wxOVERRIDE;
virtual int GetScrollPos(int orient) const wxOVERRIDE;
virtual int GetScrollThumb(int orient) const wxOVERRIDE;
virtual int GetScrollRange(int orient) const wxOVERRIDE;
virtual void ScrollWindow(int dx, int dy,
const wxRect* rect = NULL) wxOVERRIDE;
// take into account the borders here
virtual wxPoint GetClientAreaOrigin() const wxOVERRIDE;
// popup menu support
// ------------------
// NB: all menu related functions are implemented in menu.cpp
#if wxUSE_MENUS
// this is wxUniv-specific private method to be used only by wxMenu
void DismissPopupMenu();
#endif // wxUSE_MENUS
// miscellaneous other methods
// ---------------------------
// get the state information
virtual bool IsFocused() const;
virtual bool IsCurrent() const;
virtual bool IsPressed() const;
virtual bool IsDefault() const;
// return all state flags at once (combination of wxCONTROL_XXX values)
int GetStateFlags() const;
// set the "highlighted" flag and return true if it changed
virtual bool SetCurrent(bool doit = true);
#if wxUSE_SCROLLBAR
// get the scrollbar (may be NULL) for the given orientation
wxScrollBar *GetScrollbar(int orient) const
{
return orient & wxVERTICAL ? m_scrollbarVert : m_scrollbarHorz;
}
#endif // wxUSE_SCROLLBAR
// methods used by wxColourScheme to choose the colours for this window
// --------------------------------------------------------------------
// return true if this is a panel/canvas window which contains other
// controls only
virtual bool IsCanvasWindow() const { return false; }
// return true if this control can be highlighted when the mouse is over
// it (the theme decides itself whether it is really highlighted or not)
virtual bool CanBeHighlighted() const { return false; }
// return true if we should use the colours/fonts returned by the
// corresponding GetXXX() methods instead of the default ones
bool UseFgCol() const { return m_hasFgCol; }
bool UseFont() const { return m_hasFont; }
// return true if this window serves as a container for the other windows
// only and doesn't get any input itself
virtual bool IsStaticBox() const { return false; }
// returns the (low level) renderer to use for drawing the control by
// querying the current theme
wxRenderer *GetRenderer() const { return m_renderer; }
// scrolling helper: like ScrollWindow() except that it doesn't refresh the
// uncovered window areas but returns the rectangle to update (don't call
// this with both dx and dy non zero)
wxRect ScrollNoRefresh(int dx, int dy, const wxRect *rect = NULL);
// after scrollbars are added or removed they must be refreshed by calling
// this function
void RefreshScrollbars();
// erase part of the control
virtual void EraseBackground(wxDC& dc, const wxRect& rect);
// overridden base class methods
// -----------------------------
// the rect coordinates are, for us, in client coords, but if no rect is
// specified, the entire window is refreshed
virtual void Refresh(bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL) wxOVERRIDE;
// we refresh the window when it is dis/enabled
virtual bool Enable(bool enable = true) wxOVERRIDE;
// should we use the standard control colours or not?
virtual bool ShouldInheritColours() const wxOVERRIDE { return false; }
virtual bool IsClientAreaChild(const wxWindow *child) const wxOVERRIDE
{
#if wxUSE_SCROLLBAR
if ( child == (wxWindow*)m_scrollbarHorz ||
child == (wxWindow*)m_scrollbarVert )
return false;
#endif
return wxWindowNative::IsClientAreaChild(child);
}
protected:
// common part of all ctors
void Init();
#if wxUSE_MENUS
virtual bool DoPopupMenu(wxMenu *menu, int x, int y) wxOVERRIDE;
#endif // wxUSE_MENUS
// we deal with the scrollbars in these functions
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const wxOVERRIDE;
// event handlers
void OnSize(wxSizeEvent& event);
void OnNcPaint(wxNcPaintEvent& event);
void OnPaint(wxPaintEvent& event);
void OnErase(wxEraseEvent& event);
#if wxUSE_ACCEL || wxUSE_MENUS
void OnKeyDown(wxKeyEvent& event);
#endif // wxUSE_ACCEL
#if wxUSE_MENUS
void OnChar(wxKeyEvent& event);
void OnKeyUp(wxKeyEvent& event);
#endif // wxUSE_MENUS
// draw the control background, return true if done
virtual bool DoDrawBackground(wxDC& dc);
// draw the controls border
virtual void DoDrawBorder(wxDC& dc, const wxRect& rect);
// draw the controls contents
virtual void DoDraw(wxControlRenderer *renderer);
// override the base class method to return the size of the window borders
virtual wxSize DoGetBorderSize() const wxOVERRIDE;
// adjust the size of the window to take into account its borders
wxSize AdjustSize(const wxSize& size) const;
// put the scrollbars along the edges of the window
void PositionScrollbars();
#if wxUSE_MENUS
// return the menubar of the parent frame or NULL
wxMenuBar *GetParentFrameMenuBar() const;
#endif // wxUSE_MENUS
// the renderer we use
wxRenderer *m_renderer;
// background bitmap info
wxBitmap m_bitmapBg;
int m_alignBgBitmap;
wxStretch m_stretchBgBitmap;
// old size
wxSize m_oldSize;
// is the mouse currently inside the window?
bool m_isCurrent:1;
#ifdef __WXMSW__
public:
// override MSWWindowProc() to process WM_NCHITTEST
WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
#endif // __WXMSW__
private:
#if wxUSE_SCROLLBAR
// the window scrollbars
wxScrollBar *m_scrollbarHorz,
*m_scrollbarVert;
#endif // wxUSE_SCROLLBAR
#if wxUSE_MENUS
// the current modal event loop for the popup menu we show or NULL
static wxEventLoop *ms_evtLoopPopup;
// the last window over which Alt was pressed (used by OnKeyUp)
static wxWindow *ms_winLastAltPress;
#endif // wxUSE_MENUS
wxDECLARE_DYNAMIC_CLASS(wxWindow);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_UNIV_WINDOW_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/inphand.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/inphand.h
// Purpose: wxInputHandler class maps the keyboard and mouse events to the
// actions which then are performed by the control
// Author: Vadim Zeitlin
// Modified by:
// Created: 18.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_INPHAND_H_
#define _WX_UNIV_INPHAND_H_
#include "wx/univ/inpcons.h" // for wxControlAction(s)
// ----------------------------------------------------------------------------
// types of the standard input handlers which can be passed to
// wxTheme::GetInputHandler()
// ----------------------------------------------------------------------------
#define wxINP_HANDLER_DEFAULT wxT("")
#define wxINP_HANDLER_BUTTON wxT("button")
#define wxINP_HANDLER_CHECKBOX wxT("checkbox")
#define wxINP_HANDLER_CHECKLISTBOX wxT("checklistbox")
#define wxINP_HANDLER_COMBOBOX wxT("combobox")
#define wxINP_HANDLER_LISTBOX wxT("listbox")
#define wxINP_HANDLER_NOTEBOOK wxT("notebook")
#define wxINP_HANDLER_RADIOBTN wxT("radiobtn")
#define wxINP_HANDLER_SCROLLBAR wxT("scrollbar")
#define wxINP_HANDLER_SLIDER wxT("slider")
#define wxINP_HANDLER_SPINBTN wxT("spinbtn")
#define wxINP_HANDLER_STATUSBAR wxT("statusbar")
#define wxINP_HANDLER_TEXTCTRL wxT("textctrl")
#define wxINP_HANDLER_TOOLBAR wxT("toolbar")
#define wxINP_HANDLER_TOPLEVEL wxT("toplevel")
// ----------------------------------------------------------------------------
// wxInputHandler: maps the events to the actions
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxInputHandler : public wxObject
{
public:
// map a keyboard event to one or more actions (pressed == true if the key
// was pressed, false if released), returns true if something was done
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed) = 0;
// map a mouse (click) event to one or more actions
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event) = 0;
// handle mouse movement (or enter/leave) event: it is separated from
// HandleMouse() for convenience as many controls don't care about mouse
// movements at all
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event);
// do something with focus set/kill event: this is different from
// HandleMouseMove() as the mouse maybe over the control without it having
// focus
//
// return true to refresh the control, false otherwise
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
// react to the app getting/losing activation
//
// return true to refresh the control, false otherwise
virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
// virtual dtor for any base class
virtual ~wxInputHandler();
};
// ----------------------------------------------------------------------------
// wxStdInputHandler is just a base class for all other "standard" handlers
// and also provides the way to chain input handlers together
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStdInputHandler : public wxInputHandler
{
public:
wxStdInputHandler(wxInputHandler *handler) : m_handler(handler) { }
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed) wxOVERRIDE
{
return m_handler ? m_handler->HandleKey(consumer, event, pressed)
: false;
}
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event) wxOVERRIDE
{
return m_handler ? m_handler->HandleMouse(consumer, event) : false;
}
virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event) wxOVERRIDE
{
return m_handler ? m_handler->HandleMouseMove(consumer, event) : false;
}
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event) wxOVERRIDE
{
return m_handler ? m_handler->HandleFocus(consumer, event) : false;
}
private:
wxInputHandler *m_handler;
};
#endif // _WX_UNIV_INPHAND_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/notebook.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/notebook.h
// Purpose: universal version of wxNotebook
// Author: Vadim Zeitlin
// Modified by:
// Created: 01.02.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_NOTEBOOK_H_
#define _WX_UNIV_NOTEBOOK_H_
#include "wx/arrstr.h"
class WXDLLIMPEXP_FWD_CORE wxSpinButton;
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
// change the page: to the next/previous/given one
#define wxACTION_NOTEBOOK_NEXT wxT("nexttab")
#define wxACTION_NOTEBOOK_PREV wxT("prevtab")
#define wxACTION_NOTEBOOK_GOTO wxT("gototab")
// ----------------------------------------------------------------------------
// wxNotebook
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNotebook : public wxNotebookBase
{
public:
// ctors and such
// --------------
wxNotebook() { Init(); }
wxNotebook(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr)
{
Init();
(void)Create(parent, id, pos, size, style, name);
}
// quasi ctor
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
// dtor
virtual ~wxNotebook();
// implement wxNotebookBase pure virtuals
// --------------------------------------
virtual int SetSelection(size_t nPage) wxOVERRIDE { return DoSetSelection(nPage, SetSelection_SendEvent); }
// changes selected page without sending events
int ChangeSelection(size_t nPage) wxOVERRIDE { return DoSetSelection(nPage); }
virtual bool SetPageText(size_t nPage, const wxString& strText) wxOVERRIDE;
virtual wxString GetPageText(size_t nPage) const wxOVERRIDE;
virtual int GetPageImage(size_t nPage) const wxOVERRIDE;
virtual bool SetPageImage(size_t nPage, int nImage) wxOVERRIDE;
virtual void SetPageSize(const wxSize& size) wxOVERRIDE;
virtual void SetPadding(const wxSize& padding) wxOVERRIDE;
virtual void SetTabSize(const wxSize& sz) wxOVERRIDE;
virtual wxSize CalcSizeFromPage(const wxSize& sizePage) const wxOVERRIDE;
virtual bool DeleteAllPages() wxOVERRIDE;
virtual bool InsertPage(size_t nPage,
wxNotebookPage *pPage,
const wxString& strText,
bool bSelect = false,
int imageId = NO_IMAGE) wxOVERRIDE;
// style tests
// -----------
// return true if all tabs have the same width
bool FixedSizeTabs() const { return HasFlag(wxNB_FIXEDWIDTH); }
// return wxTOP/wxBOTTOM/wxRIGHT/wxLEFT
wxDirection GetTabOrientation() const;
// return true if the notebook has tabs at the sidesand not at the top (or
// bottom) as usual
bool IsVertical() const;
// hit testing
// -----------
virtual int HitTest(const wxPoint& pt, long *flags = NULL) const wxOVERRIDE;
// input handling
// --------------
virtual bool PerformAction(const wxControlAction& action,
long numArg = 0l,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
// refresh the currently selected tab
void RefreshCurrent();
protected:
virtual wxNotebookPage *DoRemovePage(size_t nPage) wxOVERRIDE;
// drawing
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
void DoDrawTab(wxDC& dc, const wxRect& rect, size_t n);
// resizing
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
int DoSetSelection(size_t nPage, int flags = 0) wxOVERRIDE;
// common part of all ctors
void Init();
// resize the tab to fit its title (and icon if any)
void ResizeTab(int page);
// recalculate the geometry of the notebook completely
void Relayout();
// is the spin button currently shown?
bool HasSpinBtn() const;
// calculate last (fully) visible tab: updates m_lastVisible
void CalcLastVisibleTab();
// show or hide the spin control for tabs scrolling depending on whether it
// is needed or not
void UpdateSpinBtn();
// position the spin button
void PositionSpinBtn();
// refresh the given tab only
void RefreshTab(int page, bool forceSelected = false);
// refresh all tabs
void RefreshAllTabs();
// get the tab rect (inefficient, don't use this in a loop)
wxRect GetTabRect(int page) const;
// get the rectangle containing all tabs
wxRect GetAllTabsRect() const;
// get the part occupied by the tabs - slightly smaller than
// GetAllTabsRect() because the tabs may be indented from it
wxRect GetTabsPart() const;
// calculate the tab size (without padding)
wxSize CalcTabSize(int page) const;
// get the (cached) size of a tab
void GetTabSize(int page, wxCoord *w, wxCoord *h) const;
// get the (cached) width of the tab
wxCoord GetTabWidth(int page) const
{ return FixedSizeTabs() ? m_widthMax : m_widths[page]; }
// return true if the tab has an associated image
bool HasImage(int page) const
{ return HasImageList() && m_images[page] != -1; }
// get the part of the notebook reserved for the pages (slightly larger
// than GetPageRect() as we draw a border and leave marginin between)
wxRect GetPagePart() const;
// get the page rect in our client coords
wxRect GetPageRect() const wxOVERRIDE;
// get our client size from the page size
wxSize GetSizeForPage(const wxSize& size) const;
// scroll the tabs so that the first page shown becomes the given one
void ScrollTo(size_t page);
// scroll the tabs so that the first page shown becomes the given one
void ScrollLastTo(size_t page);
// the pages titles
wxArrayString m_titles;
// the spin button to change the pages
wxSpinButton *m_spinbtn;
// the offset of the first page shown (may be changed with m_spinbtn)
wxCoord m_offset;
// the first and last currently visible tabs: the name is not completely
// accurate as m_lastVisible is, in fact, the first tab which is *not*
// visible: so the visible tabs are those with indexes such that
// m_firstVisible <= n < m_lastVisible
size_t m_firstVisible,
m_lastVisible;
// the last fully visible item, usually just m_lastVisible - 1 but may be
// different from it
size_t m_lastFullyVisible;
// the height of tabs in a normal notebook or the width of tabs in a
// notebook with tabs on a side
wxCoord m_heightTab;
// the biggest height (or width) of a notebook tab (used only if
// FixedSizeTabs()) or -1 if not calculated yet
wxCoord m_widthMax;
// the cached widths (or heights) of tabs
wxArrayInt m_widths;
// the icon indices
wxArrayInt m_images;
// the accel indexes for labels
wxArrayInt m_accels;
// the padding
wxSize m_sizePad;
wxDECLARE_DYNAMIC_CLASS(wxNotebook);
};
#endif // _WX_UNIV_NOTEBOOK_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/statline.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/statline.h
// Purpose: wxStaticLine class for wxUniversal
// Author: Vadim Zeitlin
// Created: 28.06.99
// Copyright: (c) 1999 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_STATLINE_H_
#define _WX_UNIV_STATLINE_H_
class WXDLLIMPEXP_CORE wxStaticLine : public wxStaticLineBase
{
public:
// constructors and pseudo-constructors
wxStaticLine() { }
wxStaticLine(wxWindow *parent,
const wxPoint &pos,
wxCoord length,
long style = wxLI_HORIZONTAL)
{
Create(parent, wxID_ANY, pos,
style & wxLI_VERTICAL ? wxSize(wxDefaultCoord, length)
: wxSize(length, wxDefaultCoord),
style);
}
wxStaticLine(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxLI_HORIZONTAL,
const wxString &name = wxStaticLineNameStr )
{
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxLI_HORIZONTAL,
const wxString &name = wxStaticLineNameStr );
protected:
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxStaticLine);
};
#endif // _WX_UNIV_STATLINE_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/stdrend.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/stdrend.h
// Purpose: wxStdRenderer class declaration
// Author: Vadim Zeitlin
// Created: 2006-09-18
// Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_STDREND_H_
#define _WX_UNIV_STDREND_H_
#include "wx/univ/renderer.h"
#include "wx/pen.h"
class WXDLLIMPEXP_FWD_CORE wxColourScheme;
// ----------------------------------------------------------------------------
// wxStdRenderer: implements as much of wxRenderer API as possible generically
// ----------------------------------------------------------------------------
class wxStdRenderer : public wxRenderer
{
public:
// the renderer will use the given scheme, whose lifetime must be at least
// as long as of this object itself, to choose the colours for drawing
wxStdRenderer(const wxColourScheme *scheme);
virtual void DrawBackground(wxDC& dc,
const wxColour& col,
const wxRect& rect,
int flags = 0,
wxWindow *window = NULL) wxOVERRIDE;
virtual void DrawButtonSurface(wxDC& dc,
const wxColour& col,
const wxRect& rect,
int flags) wxOVERRIDE;
virtual void DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags = 0) wxOVERRIDE;
virtual void DrawLabel(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0,
int alignment = wxALIGN_LEFT | wxALIGN_TOP,
int indexAccel = -1,
wxRect *rectBounds = NULL) wxOVERRIDE;
virtual void DrawButtonLabel(wxDC& dc,
const wxString& label,
const wxBitmap& image,
const wxRect& rect,
int flags = 0,
int alignment = wxALIGN_LEFT | wxALIGN_TOP,
int indexAccel = -1,
wxRect *rectBounds = NULL) wxOVERRIDE;
virtual void DrawBorder(wxDC& dc,
wxBorder border,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) wxOVERRIDE;
virtual void DrawTextBorder(wxDC& dc,
wxBorder border,
const wxRect& rect,
int flags = 0,
wxRect *rectIn = NULL) wxOVERRIDE;
virtual void DrawHorizontalLine(wxDC& dc,
wxCoord y, wxCoord x1, wxCoord x2) wxOVERRIDE;
virtual void DrawVerticalLine(wxDC& dc,
wxCoord x, wxCoord y1, wxCoord y2) wxOVERRIDE;
virtual void DrawFrame(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0,
int alignment = wxALIGN_LEFT,
int indexAccel = -1) wxOVERRIDE;
virtual void DrawItem(wxDC& dc,
const wxString& label,
const wxRect& rect,
int flags = 0) wxOVERRIDE;
virtual void DrawCheckItem(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0) wxOVERRIDE;
virtual void DrawCheckButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
wxAlignment align = wxALIGN_LEFT,
int indexAccel = -1) wxOVERRIDE;
virtual void DrawRadioButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags = 0,
wxAlignment align = wxALIGN_LEFT,
int indexAccel = -1) wxOVERRIDE;
virtual void DrawScrollbarArrow(wxDC& dc,
wxDirection dir,
const wxRect& rect,
int flags = 0) wxOVERRIDE;
virtual void DrawScrollCorner(wxDC& dc,
const wxRect& rect) wxOVERRIDE;
#if wxUSE_TEXTCTRL
virtual void DrawTextLine(wxDC& dc,
const wxString& text,
const wxRect& rect,
int selStart = -1,
int selEnd = -1,
int flags = 0) wxOVERRIDE;
virtual void DrawLineWrapMark(wxDC& dc, const wxRect& rect) wxOVERRIDE;
virtual wxRect GetTextTotalArea(const wxTextCtrl *text,
const wxRect& rect) const wxOVERRIDE;
virtual wxRect GetTextClientArea(const wxTextCtrl *text,
const wxRect& rect,
wxCoord *extraSpaceBeyond) const wxOVERRIDE;
#endif // wxUSE_TEXTCTRL
virtual wxRect GetBorderDimensions(wxBorder border) const wxOVERRIDE;
virtual bool AreScrollbarsInsideBorder() const wxOVERRIDE;
virtual void AdjustSize(wxSize *size, const wxWindow *window) wxOVERRIDE;
virtual wxCoord GetListboxItemHeight(wxCoord fontHeight) wxOVERRIDE;
#if wxUSE_STATUSBAR
virtual void DrawStatusField(wxDC& dc,
const wxRect& rect,
const wxString& label,
int flags = 0, int style = 0) wxOVERRIDE;
virtual wxSize GetStatusBarBorders() const wxOVERRIDE;
virtual wxCoord GetStatusBarBorderBetweenFields() const wxOVERRIDE;
virtual wxSize GetStatusBarFieldMargins() const wxOVERRIDE;
#endif // wxUSE_STATUSBAR
virtual wxCoord GetCheckItemMargin() const wxOVERRIDE { return 0; }
virtual void DrawFrameTitleBar(wxDC& dc,
const wxRect& rect,
const wxString& title,
const wxIcon& icon,
int flags,
int specialButton = 0,
int specialButtonFlag = 0) wxOVERRIDE;
virtual void DrawFrameBorder(wxDC& dc,
const wxRect& rect,
int flags) wxOVERRIDE;
virtual void DrawFrameBackground(wxDC& dc,
const wxRect& rect,
int flags) wxOVERRIDE;
virtual void DrawFrameTitle(wxDC& dc,
const wxRect& rect,
const wxString& title,
int flags) wxOVERRIDE;
virtual void DrawFrameIcon(wxDC& dc,
const wxRect& rect,
const wxIcon& icon,
int flags) wxOVERRIDE;
virtual void DrawFrameButton(wxDC& dc,
wxCoord x, wxCoord y,
int button,
int flags = 0) wxOVERRIDE;
virtual wxRect GetFrameClientArea(const wxRect& rect, int flags) const wxOVERRIDE;
virtual wxSize GetFrameTotalSize(const wxSize& clientSize, int flags) const wxOVERRIDE;
virtual wxSize GetFrameMinSize(int flags) const wxOVERRIDE;
virtual wxSize GetFrameIconSize() const wxOVERRIDE;
virtual int HitTestFrame(const wxRect& rect,
const wxPoint& pt,
int flags = 0) const wxOVERRIDE;
protected:
// various constants
enum ArrowDirection
{
Arrow_Left,
Arrow_Right,
Arrow_Up,
Arrow_Down,
Arrow_Max
};
enum ArrowStyle
{
Arrow_Normal,
Arrow_Disabled,
Arrow_Pressed,
Arrow_Inverted,
Arrow_InvertedDisabled,
Arrow_StateMax
};
enum FrameButtonType
{
FrameButton_Close,
FrameButton_Minimize,
FrameButton_Maximize,
FrameButton_Restore,
FrameButton_Help,
FrameButton_Max
};
enum IndicatorType
{
IndicatorType_Check,
IndicatorType_Radio,
IndicatorType_MaxCtrl,
IndicatorType_Menu = IndicatorType_MaxCtrl,
IndicatorType_Max
};
enum IndicatorState
{
IndicatorState_Normal,
IndicatorState_Pressed, // this one is for check/radioboxes
IndicatorState_Disabled,
IndicatorState_MaxCtrl,
// the rest of the states are valid for menu items only
IndicatorState_Selected = IndicatorState_Pressed,
IndicatorState_SelectedDisabled = IndicatorState_MaxCtrl,
IndicatorState_MaxMenu
};
enum IndicatorStatus
{
IndicatorStatus_Checked,
IndicatorStatus_Unchecked,
IndicatorStatus_Undetermined,
IndicatorStatus_Max
};
// translate the appropriate bits in flags to the above enum elements
static void GetIndicatorsFromFlags(int flags,
IndicatorState& state,
IndicatorStatus& status);
// translate wxDirection to ArrowDirection
static ArrowDirection GetArrowDirection(wxDirection dir);
// fill the rectangle with a brush of given colour (must be valid)
void DrawSolidRect(wxDC& dc, const wxColour& col, const wxRect& rect);
// all the functions in this section adjust the rect parameter to
// correspond to the interiour of the drawn area
// draw complete rectangle
void DrawRect(wxDC& dc, wxRect *rect, const wxPen& pen);
// draw the rectange using the first pen for the left and top sides
// and the second one for the bottom and right ones
void DrawShadedRect(wxDC& dc, wxRect *rect,
const wxPen& pen1, const wxPen& pen2);
// border drawing routines, may be overridden in the derived class
virtual void DrawRaisedBorder(wxDC& dc, wxRect *rect);
virtual void DrawSunkenBorder(wxDC& dc, wxRect *rect);
virtual void DrawAntiSunkenBorder(wxDC& dc, wxRect *rect);
virtual void DrawBoxBorder(wxDC& dc, wxRect *rect);
virtual void DrawStaticBorder(wxDC& dc, wxRect *rect);
virtual void DrawExtraBorder(wxDC& dc, wxRect *rect);
// draw the frame with non-empty label inside the given rectText
virtual void DrawFrameWithLabel(wxDC& dc,
const wxString& label,
const wxRect& rectFrame,
const wxRect& rectText,
int flags,
int alignment,
int indexAccel);
// draw the (static box) frame without the part corresponding to rectLabel
void DrawFrameWithoutLabel(wxDC& dc,
const wxRect& rectFrame,
const wxRect& rectLabel);
// draw the bitmap for a check item (which is by default the same as check
// box one but may be different)
virtual void DrawCheckItemBitmap(wxDC& dc,
const wxBitmap& bitmap,
const wxRect& rect,
int flags);
// common routine for drawing check and radio buttons
void DrawCheckOrRadioButton(wxDC& dc,
const wxString& label,
const wxBitmap& bitmap,
const wxRect& rect,
int flags,
wxAlignment align,
int indexAccel);
// return the check/radio bitmap for the given flags
virtual wxBitmap GetRadioBitmap(int flags) = 0;
virtual wxBitmap GetCheckBitmap(int flags) = 0;
// return the frame icon bitmap
virtual wxBitmap GetFrameButtonBitmap(FrameButtonType type) = 0;
// get the width of either normal or resizable frame border depending on
// whether flags contains wxTOPLEVEL_RESIZEABLE bit
//
// notice that these methods only make sense with standard border drawing
// code which uses the borders of the same width on all sides, this is why
// they are only present here and not in wxRenderer itself
virtual int GetFrameBorderWidth(int flags) const;
#if wxUSE_TEXTCTRL
// return the width of the border around the text area in the text control
virtual int GetTextBorderWidth(const wxTextCtrl *text) const;
#endif // wxUSE_TEXTCTRL
// GDI objects we often use
wxPen m_penBlack,
m_penDarkGrey,
m_penLightGrey,
m_penHighlight;
wxFont m_titlebarFont;
// the colours we use, they never change currently so we don't have to ever
// update m_penXXX objects above
const wxColourScheme * const m_scheme;
wxDECLARE_NO_COPY_CLASS(wxStdRenderer);
};
#endif // _WX_UNIV_STDREND_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/frame.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/frame.h
// Purpose: wxFrame class for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 19.05.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_FRAME_H_
#define _WX_UNIV_FRAME_H_
// ----------------------------------------------------------------------------
// wxFrame
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFrame : public wxFrameBase
{
public:
wxFrame() {}
wxFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual wxPoint GetClientAreaOrigin() const wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
#if wxUSE_STATUSBAR
virtual wxStatusBar* CreateStatusBar(int number = 1,
long style = wxSTB_DEFAULT_STYLE,
wxWindowID id = 0,
const wxString& name = wxStatusLineNameStr) wxOVERRIDE;
#endif // wxUSE_STATUSBAR
#if wxUSE_TOOLBAR
// create main toolbar bycalling OnCreateToolBar()
virtual wxToolBar* CreateToolBar(long style = -1,
wxWindowID id = wxID_ANY,
const wxString& name = wxToolBarNameStr) wxOVERRIDE;
#endif // wxUSE_TOOLBAR
virtual wxSize GetMinSize() const wxOVERRIDE;
protected:
void OnSize(wxSizeEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
#if wxUSE_MENUS
// override to update menu bar position when the frame size changes
virtual void PositionMenuBar() wxOVERRIDE;
virtual void DetachMenuBar() wxOVERRIDE;
virtual void AttachMenuBar(wxMenuBar *menubar) wxOVERRIDE;
#endif // wxUSE_MENUS
#if wxUSE_STATUSBAR
// override to update statusbar position when the frame size changes
virtual void PositionStatusBar() wxOVERRIDE;
#endif // wxUSE_MENUS
protected:
#if wxUSE_TOOLBAR
virtual void PositionToolBar() wxOVERRIDE;
#endif // wxUSE_TOOLBAR
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxFrame);
};
#endif // _WX_UNIV_FRAME_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/statbox.h
|
//////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/statbox.h
// Purpose: wxStaticBox declaration
// Author: Vadim Zeitlin
// Modified by:
// Created: 15.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_STATBOX_H_
#define _WX_UNIV_STATBOX_H_
class WXDLLIMPEXP_CORE wxStaticBox : public wxStaticBoxBase
{
public:
wxStaticBox() { }
wxStaticBox(wxWindow *parent,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize)
{
Create(parent, wxID_ANY, label, pos, size);
}
wxStaticBox(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
// the origin of the static box is inside the border and under the label:
// take account of this
virtual wxPoint GetBoxAreaOrigin() const;
// returning true from here ensures that we act as a container window for
// our children
virtual bool IsStaticBox() const wxOVERRIDE { return true; }
protected:
// draw the control
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
// get the size of the border
wxRect GetBorderGeometry() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxStaticBox);
};
#endif // _WX_UNIV_STATBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/scrtimer.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/scrtimer.h
// Purpose: wxScrollTimer: small helper class for wxScrollArrow/Thumb
// Author: Vadim Zeitlin
// Modified by:
// Created: 18.02.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_SCRTIMER_H
#define _WX_UNIV_SCRTIMER_H
// NB: this class is implemented in scrolbar.cpp
#include "wx/defs.h"
#if wxUSE_TIMER
#include "wx/timer.h"
// ----------------------------------------------------------------------------
// wxScrollTimer: the timer used when the arrow or scrollbar shaft is kept
// pressed
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxScrollTimer : public wxTimer
{
public:
// default ctor
wxScrollTimer();
// start generating the events
void StartAutoScroll();
// the base class method
virtual void Notify() wxOVERRIDE;
protected:
// to implement in derived classes: perform the scroll action and return
// true to continue scrolling or false to stop
virtual bool DoNotify() = 0;
// should we skip the next timer event?
bool m_skipNext;
};
#endif // wxUSE_TIMER
#endif // _WX_UNIV_SCRTIMER_H
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/control.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/control.h
// Purpose: universal wxControl: adds handling of mnemonics
// Author: Vadim Zeitlin
// Modified by:
// Created: 14.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_CONTROL_H_
#define _WX_UNIV_CONTROL_H_
class WXDLLIMPEXP_FWD_CORE wxControlRenderer;
class WXDLLIMPEXP_FWD_CORE wxInputHandler;
class WXDLLIMPEXP_FWD_CORE wxRenderer;
// we must include it as most/all control classes derive their handlers from
// it
#include "wx/univ/inphand.h"
#include "wx/univ/inpcons.h"
// ----------------------------------------------------------------------------
// wxControlAction: the action is currently just a string which identifies it,
// later it might become an atom (i.e. an opaque handler to string).
// ----------------------------------------------------------------------------
typedef wxString wxControlAction;
// the list of actions which apply to all controls (other actions are defined
// in the controls headers)
#define wxACTION_NONE wxT("") // no action to perform
// ----------------------------------------------------------------------------
// wxControl: the base class for all GUI controls
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxControl : public wxControlBase, public wxInputConsumer
{
public:
wxControl() { Init(); }
wxControl(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr)
{
Init();
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr);
// this function will filter out '&' characters and will put the
// accelerator char (the one immediately after '&') into m_chAccel
virtual void SetLabel(const wxString& label) wxOVERRIDE;
// return the current label
virtual wxString GetLabel() const wxOVERRIDE { return wxControlBase::GetLabel(); }
// wxUniversal-specific methods
// return the index of the accel char in the label or -1 if none
int GetAccelIndex() const { return m_indexAccel; }
// return the accel char itself or 0 if none
wxChar GetAccelChar() const
{
return m_indexAccel == -1 ? wxT('\0') : (wxChar)m_label[m_indexAccel];
}
virtual wxWindow *GetInputWindow() const wxOVERRIDE { return (wxWindow*)this; }
protected:
// common part of all ctors
void Init();
// set m_label and m_indexAccel and refresh the control to show the new
// label (but, unlike SetLabel(), don't call the base class SetLabel() thus
// avoiding to change wxControlBase::m_labelOrig)
void UnivDoSetLabel(const wxString& label);
private:
// label and accel info
wxString m_label;
int m_indexAccel;
wxDECLARE_DYNAMIC_CLASS(wxControl);
wxDECLARE_EVENT_TABLE();
WX_DECLARE_INPUT_CONSUMER()
};
#endif // _WX_UNIV_CONTROL_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/chkconf.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/chkconf.h
// Purpose: wxUniversal-specific configuration options checks
// Author: Vadim Zeitlin
// Created: 2006-09-28 (extracted from wx/chkconf.h)
// Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_CHKCONF_H_
#define _WX_UNIV_CHKCONF_H_
#if wxUSE_OWNER_DRAWN
/*
It is not clear if owner-drawn code makes much sense for wxUniv in the
first place but in any case it doesn't link currently (at least under
wxMSW but probably elsewhere too) as there is no wxUniv-specific
wxOwnerDrawnBase implementation so disable it for now.
*/
#undef wxUSE_OWNER_DRAWN
#define wxUSE_OWNER_DRAWN 0
#endif /* wxUSE_OWNER_DRAWN */
#if (wxUSE_COMBOBOX || wxUSE_MENUS) && !wxUSE_POPUPWIN
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_POPUPWIN must be defined to use comboboxes/menus"
# else
# undef wxUSE_POPUPWIN
# define wxUSE_POPUPWIN 1
# endif
#endif
#if wxUSE_COMBOBOX
# if !wxUSE_LISTBOX
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxComboBox requires wxListBox in wxUniversal"
# else
# undef wxUSE_LISTBOX
# define wxUSE_LISTBOX 1
# endif
# endif
#endif /* wxUSE_COMBOBOX */
#if wxUSE_RADIOBTN
# if !wxUSE_CHECKBOX
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_RADIOBTN requires wxUSE_CHECKBOX in wxUniversal"
# else
# undef wxUSE_CHECKBOX
# define wxUSE_CHECKBOX 1
# endif
# endif
#endif /* wxUSE_RADIOBTN */
#if wxUSE_TEXTCTRL
# if !wxUSE_CARET
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxTextCtrl requires wxCaret in wxUniversal"
# else
# undef wxUSE_CARET
# define wxUSE_CARET 1
# endif
# endif /* wxUSE_CARET */
# if !wxUSE_SCROLLBAR
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxTextCtrl requires wxScrollBar in wxUniversal"
# else
# undef wxUSE_SCROLLBAR
# define wxUSE_SCROLLBAR 1
# endif
# endif /* wxUSE_SCROLLBAR */
#endif /* wxUSE_TEXTCTRL */
/* Themes checks */
#ifndef wxUSE_ALL_THEMES
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_ALL_THEMES must be defined"
# else
# define wxUSE_ALL_THEMES 1
# endif
#endif /* wxUSE_ALL_THEMES */
#ifndef wxUSE_THEME_GTK
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_THEME_GTK must be defined"
# else
# define wxUSE_THEME_GTK 1
# endif
#endif /* wxUSE_THEME_GTK */
#ifndef wxUSE_THEME_METAL
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_THEME_METAL must be defined"
# else
# define wxUSE_THEME_METAL 1
# endif
#endif /* wxUSE_THEME_METAL */
#ifndef wxUSE_THEME_MONO
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_THEME_MONO must be defined"
# else
# define wxUSE_THEME_MONO 1
# endif
#endif /* wxUSE_THEME_MONO */
#ifndef wxUSE_THEME_WIN32
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_THEME_WIN32 must be defined"
# else
# define wxUSE_THEME_WIN32 1
# endif
#endif /* wxUSE_THEME_WIN32 */
#if !wxUSE_ALL_THEMES && wxUSE_THEME_METAL && !wxUSE_THEME_WIN32
# ifdef wxABORT_ON_CONFIG_ERROR
# error "Metal theme requires Win32 one"
# else
# undef wxUSE_THEME_WIN32
# define wxUSE_THEME_WIN32 1
# endif
#endif /* wxUSE_THEME_METAL && !wxUSE_THEME_WIN32 */
#endif /* _WX_UNIV_CHKCONF_H_ */
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/button.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/button.h
// Purpose: wxButton for wxUniversal
// Author: Vadim Zeitlin
// Modified by:
// Created: 15.08.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_BUTTON_H_
#define _WX_UNIV_BUTTON_H_
#include "wx/bitmap.h"
// ----------------------------------------------------------------------------
// the actions supported by this control
// ----------------------------------------------------------------------------
//checkbox.cpp needed it, so not move it to anybutton.h
#define wxACTION_BUTTON_TOGGLE wxT("toggle") // press/release the button
#define wxACTION_BUTTON_PRESS wxT("press") // press the button
#define wxACTION_BUTTON_RELEASE wxT("release") // release the button
#define wxACTION_BUTTON_CLICK wxT("click") // generate button click event
// ----------------------------------------------------------------------------
// wxButton: a push button
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxButton : public wxButtonBase
{
public:
wxButton() { Init(); }
wxButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Init();
Create(parent, id, bitmap, label, pos, size, style, validator, name);
}
wxButton(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Init();
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
return Create(parent, id, wxNullBitmap, label,
pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual ~wxButton();
virtual wxWindow *SetDefault() wxOVERRIDE;
virtual bool IsPressed() const wxOVERRIDE { return m_isPressed; }
virtual bool IsDefault() const wxOVERRIDE { return m_isDefault; }
// wxButton actions
virtual void Click() wxOVERRIDE;
virtual bool CanBeHighlighted() const wxOVERRIDE { return true; }
protected:
virtual void DoSetBitmap(const wxBitmap& bitmap, State which) wxOVERRIDE;
virtual wxBitmap DoGetBitmap(State which) const wxOVERRIDE;
virtual void DoSetBitmapMargins(wxCoord x, wxCoord y) wxOVERRIDE;
// common part of all ctors
void Init();
private:
wxDECLARE_DYNAMIC_CLASS(wxButton);
};
#endif // _WX_UNIV_BUTTON_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/univ/textctrl.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/textctrl.h
// Purpose: wxTextCtrl class
// Author: Vadim Zeitlin
// Modified by:
// Created: 15.09.00
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_TEXTCTRL_H_
#define _WX_UNIV_TEXTCTRL_H_
class WXDLLIMPEXP_FWD_CORE wxCaret;
class WXDLLIMPEXP_FWD_CORE wxTextCtrlCommandProcessor;
#include "wx/scrolwin.h" // for wxScrollHelper
#include "wx/univ/inphand.h"
// ----------------------------------------------------------------------------
// wxTextCtrl actions
// ----------------------------------------------------------------------------
// cursor movement and also selection and delete operations
#define wxACTION_TEXT_GOTO wxT("goto") // to pos in numArg
#define wxACTION_TEXT_FIRST wxT("first") // go to pos 0
#define wxACTION_TEXT_LAST wxT("last") // go to last pos
#define wxACTION_TEXT_HOME wxT("home")
#define wxACTION_TEXT_END wxT("end")
#define wxACTION_TEXT_LEFT wxT("left")
#define wxACTION_TEXT_RIGHT wxT("right")
#define wxACTION_TEXT_UP wxT("up")
#define wxACTION_TEXT_DOWN wxT("down")
#define wxACTION_TEXT_WORD_LEFT wxT("wordleft")
#define wxACTION_TEXT_WORD_RIGHT wxT("wordright")
#define wxACTION_TEXT_PAGE_UP wxT("pageup")
#define wxACTION_TEXT_PAGE_DOWN wxT("pagedown")
// clipboard operations
#define wxACTION_TEXT_COPY wxT("copy")
#define wxACTION_TEXT_CUT wxT("cut")
#define wxACTION_TEXT_PASTE wxT("paste")
// insert text at the cursor position: the text is in strArg of PerformAction
#define wxACTION_TEXT_INSERT wxT("insert")
// if the action starts with either of these prefixes and the rest of the
// string is one of the movement commands, it means to select/delete text from
// the current cursor position to the new one
#define wxACTION_TEXT_PREFIX_SEL wxT("sel")
#define wxACTION_TEXT_PREFIX_DEL wxT("del")
// mouse selection
#define wxACTION_TEXT_ANCHOR_SEL wxT("anchorsel")
#define wxACTION_TEXT_EXTEND_SEL wxT("extendsel")
#define wxACTION_TEXT_SEL_WORD wxT("wordsel")
#define wxACTION_TEXT_SEL_LINE wxT("linesel")
// undo or redo
#define wxACTION_TEXT_UNDO wxT("undo")
#define wxACTION_TEXT_REDO wxT("redo")
// ----------------------------------------------------------------------------
// wxTextCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTextCtrl : public wxTextCtrlBase,
public wxScrollHelper
{
public:
// creation
// --------
wxTextCtrl() : wxScrollHelper(this) { Init(); }
wxTextCtrl(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 = wxTextCtrlNameStr)
: wxScrollHelper(this)
{
Init();
Create(parent, id, value, pos, size, style, validator, name);
}
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 = wxTextCtrlNameStr);
virtual ~wxTextCtrl();
// implement base class pure virtuals
// ----------------------------------
virtual int GetLineLength(wxTextCoord lineNo) const wxOVERRIDE;
virtual wxString GetLineText(wxTextCoord lineNo) const wxOVERRIDE;
virtual int GetNumberOfLines() const wxOVERRIDE;
virtual bool IsModified() const wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
virtual void SetMaxLength(unsigned long len) wxOVERRIDE;
// If the return values from and to are the same, there is no selection.
virtual void GetSelection(wxTextPos* from, wxTextPos* to) const wxOVERRIDE;
// operations
// ----------
// editing
virtual void Clear() wxOVERRIDE;
virtual void Replace(wxTextPos from, wxTextPos to, const wxString& value) wxOVERRIDE;
virtual void Remove(wxTextPos from, wxTextPos to) wxOVERRIDE;
// sets/clears the dirty flag
virtual void MarkDirty() wxOVERRIDE;
virtual void DiscardEdits() 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;
// 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 (logical, i.e. unwrapped) column and line.
virtual wxTextPos XYToPosition(wxTextCoord x, wxTextCoord y) const wxOVERRIDE;
virtual bool PositionToXY(wxTextPos pos,
wxTextCoord *x, wxTextCoord *y) const wxOVERRIDE;
// wxUniv-specific: find a screen position (in client coordinates) of the
// given text position or of the caret
bool PositionToLogicalXY(wxTextPos pos, wxCoord *x, wxCoord *y) const;
bool PositionToDeviceXY(wxTextPos pos, wxCoord *x, wxCoord *y) const;
wxPoint GetCaretPosition() const;
virtual void ShowPosition(wxTextPos pos) wxOVERRIDE;
// Clipboard operations
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() 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(wxTextPos pos) wxOVERRIDE;
virtual void SetInsertionPointEnd() wxOVERRIDE;
virtual wxTextPos GetInsertionPoint() const wxOVERRIDE;
virtual wxTextPos GetLastPosition() const wxOVERRIDE;
virtual void SetSelection(wxTextPos from, wxTextPos to) wxOVERRIDE;
virtual void SetEditable(bool editable) wxOVERRIDE;
// wxUniv-specific methods
// -----------------------
// caret stuff
virtual void ShowCaret(bool show = true);
void HideCaret() { ShowCaret(false); }
void CreateCaret(); // for the current font size
// helpers for cursor movement
wxTextPos GetWordStart() const;
wxTextPos GetWordEnd() const;
// selection helpers
bool HasSelection() const
{ return m_selStart != -1 && m_selEnd > m_selStart; }
void ClearSelection();
void RemoveSelection();
wxString GetSelectionText() const;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const wxOVERRIDE;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
wxTextCoord *col,
wxTextCoord *row) const wxOVERRIDE;
// find the character at this position in the given line, return value as
// for HitTest()
//
// NB: x is the logical coord (client and unscrolled)
wxTextCtrlHitTestResult HitTestLine(const wxString& line,
wxCoord x,
wxTextCoord *colOut) const;
// bring the given position into view
void ShowHorzPosition(wxCoord pos);
// scroll the window horizontally so that the first character shown is in
// position pos
void ScrollText(wxTextCoord col);
// adjust the DC for horz text control scrolling too
virtual void DoPrepareDC(wxDC& dc) wxOVERRIDE;
// implementation only from now on
// -------------------------------
// override this to take into account our scrollbar-less scrolling
virtual void CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const;
virtual void CalcScrolledPosition(int x, int y, int *xx, int *yy) const;
// perform an action
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1,
const wxString& strArg = wxEmptyString) wxOVERRIDE;
static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);
virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef) wxOVERRIDE
{
return GetStdInputHandler(handlerDef);
}
// override these methods to handle the caret
virtual bool SetFont(const wxFont &font) wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
// more readable flag testing methods
bool IsPassword() const { return HasFlag(wxTE_PASSWORD); }
bool WrapLines() const { return m_wrapLines; }
// only for wxStdTextCtrlInputHandler
void RefreshSelection();
// override wxScrollHelper method to prevent (auto)scrolling beyond the end
// of line
virtual bool SendAutoScrollEvents(wxScrollWinEvent& event) const wxOVERRIDE;
// idle processing
virtual void OnInternalIdle() wxOVERRIDE;
protected:
// ensure we have correct default border
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_SUNKEN; }
// override base class methods
virtual void DoDrawBorder(wxDC& dc, const wxRect& rect) wxOVERRIDE;
virtual void DoDraw(wxControlRenderer *renderer) wxOVERRIDE;
// calc the size from the text extent
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// implements Set/ChangeValue()
virtual void DoSetValue(const wxString& value, int flags = 0) wxOVERRIDE;
virtual wxString DoGetValue() const wxOVERRIDE;
// common part of all ctors
void Init();
// drawing
// -------
// draw the text in the given rectangle
void DoDrawTextInRect(wxDC& dc, const wxRect& rectUpdate);
// draw the line wrap marks in this rect
void DoDrawLineWrapMarks(wxDC& dc, const wxRect& rectUpdate);
// line/row geometry calculations
// ------------------------------
// get the extent (width) of the text
wxCoord GetTextWidth(const wxString& text) const;
// get the logical text width (accounting for scrolling)
wxCoord GetTotalWidth() const;
// get total number of rows (different from number of lines if the lines
// can be wrapped)
wxTextCoord GetRowCount() const;
// find the number of rows in this line (only if WrapLines())
wxTextCoord GetRowsPerLine(wxTextCoord line) const;
// get the starting row of the given line
wxTextCoord GetFirstRowOfLine(wxTextCoord line) const;
// get the row following this line
wxTextCoord GetRowAfterLine(wxTextCoord line) const;
// refresh functions
// -----------------
// the text area is the part of the window in which the text can be
// displayed, i.e. part of it inside the margins and the real text area is
// the area in which the text *is* currently displayed: for example, in the
// multiline control case the text area can have extra space at the bottom
// which is not tall enough for another line and which is then not included
// into the real text area
wxRect GetRealTextArea() const;
// refresh the text in the given (in logical coords) rect
void RefreshTextRect(const wxRect& rect, bool textOnly = true);
// refresh the line wrap marks for the given range of lines (inclusive)
void RefreshLineWrapMarks(wxTextCoord rowFirst, wxTextCoord rowLast);
// refresh the text in the given range (in logical coords) of this line, if
// width is 0, refresh to the end of line
void RefreshPixelRange(wxTextCoord line, wxCoord start, wxCoord width);
// refresh the text in the given range (in text coords) in this line
void RefreshColRange(wxTextCoord line, wxTextPos start, size_t count);
// refresh the text from in the given line range (inclusive)
void RefreshLineRange(wxTextCoord lineFirst, wxTextCoord lineLast);
// refresh the text in the given range which can span multiple lines
// (this method accepts arguments in any order)
void RefreshTextRange(wxTextPos start, wxTextPos end);
// get the text to show: either the text itself or the text replaced with
// starts for wxTE_PASSWORD control
wxString GetTextToShow(const wxString& text) const;
// find the row in this line where the given position (counted from the
// start of line) is
wxTextCoord GetRowInLine(wxTextCoord line,
wxTextCoord col,
wxTextCoord *colRowStart = NULL) const;
// find the number of characters of a line before it wraps
// (and optionally also the real width of the line)
size_t GetPartOfWrappedLine(const wxChar* text,
wxCoord *widthReal = NULL) const;
// get the start and end of the selection for this line: if the line is
// outside the selection, both will be -1 and false will be returned
bool GetSelectedPartOfLine(wxTextCoord line,
wxTextPos *start, wxTextPos *end) const;
// update the text rect: the zone inside our client rect (its coords are
// client coords) which contains the text
void UpdateTextRect();
// calculate the last visible position
void UpdateLastVisible();
// move caret to the given position unconditionally
// (SetInsertionPoint() does nothing if the position didn't change)
void DoSetInsertionPoint(wxTextPos pos);
// move caret to the new position without updating the display (for
// internal use only)
void MoveInsertionPoint(wxTextPos pos);
// set the caret to its initial (default) position
void InitInsertionPoint();
// get the width of the longest line in pixels
wxCoord GetMaxWidth() const;
// force recalculation of the max line width
void RecalcMaxWidth();
// update the max width after the given line was modified
void UpdateMaxWidth(wxTextCoord line);
// hit testing
// -----------
// HitTest2() is more efficient than 2 consecutive HitTest()s with the same
// line (i.e. y) and it also returns the offset of the starting position in
// pixels
//
// as the last hack, this function accepts either logical or device (by
// default) coords depending on devCoords flag
wxTextCtrlHitTestResult HitTest2(wxCoord y,
wxCoord x1,
wxCoord x2,
wxTextCoord *row,
wxTextCoord *colStart,
wxTextCoord *colEnd,
wxTextCoord *colRowStart,
bool devCoords = true) const;
// HitTest() version which takes the logical text coordinates and not the
// device ones
wxTextCtrlHitTestResult HitTestLogical(const wxPoint& pos,
wxTextCoord *col,
wxTextCoord *row) const;
// get the line and the row in this line corresponding to the given row,
// return true if ok and false if row is out of range
//
// NB: this function can only be called for controls which wrap lines
bool GetLineAndRow(wxTextCoord row,
wxTextCoord *line,
wxTextCoord *rowInLine) const;
// get the height of one line (the same for all lines)
wxCoord GetLineHeight() const
{
// this one should be already precalculated
wxASSERT_MSG( m_heightLine != -1, wxT("should have line height") );
return m_heightLine;
}
// get the average char width
wxCoord GetAverageWidth() const { return m_widthAvg; }
// recalc the line height and char width (to call when the font changes)
void RecalcFontMetrics();
// vertical scrolling helpers
// --------------------------
// all these functions are for multi line controls only
// get the number of visible lines
size_t GetLinesPerPage() const;
// return the position above the cursor or INVALID_POS_VALUE
wxTextPos GetPositionAbove();
// return the position below the cursor or INVALID_POS_VALUE
wxTextPos GetPositionBelow();
// event handlers
// --------------
void OnChar(wxKeyEvent& event);
void OnSize(wxSizeEvent& event);
// return the struct containing control-type dependent data
struct wxTextSingleLineData& SData() { return *m_data.sdata; }
struct wxTextMultiLineData& MData() { return *m_data.mdata; }
struct wxTextWrappedData& WData() { return *m_data.wdata; }
const wxTextSingleLineData& SData() const { return *m_data.sdata; }
const wxTextMultiLineData& MData() const { return *m_data.mdata; }
const wxTextWrappedData& WData() const { return *m_data.wdata; }
// clipboard operations (unlike the versions without Do prefix, they have a
// return code)
bool DoCut();
bool DoPaste();
private:
// all these methods are for multiline text controls only
// update the scrollbars (only called from OnIdle)
void UpdateScrollbars();
// get read only access to the lines of multiline control
inline const wxArrayString& GetLines() const;
inline size_t GetLineCount() const;
// replace a line (returns true if the number of rows in thel ine changed)
bool ReplaceLine(wxTextCoord line, const wxString& text);
// remove a line
void RemoveLine(wxTextCoord line);
// insert a line at this position
void InsertLine(wxTextCoord line, const wxString& text);
// calculate geometry of this line
void LayoutLine(wxTextCoord line, class wxWrappedLineData& lineData) const;
// calculate geometry of all lines until the given one
void LayoutLines(wxTextCoord lineLast) const;
// the initially specified control size
wxSize m_sizeInitial;
// the global control text
wxString m_value;
// current position
wxTextPos m_curPos;
wxTextCoord m_curCol,
m_curRow;
// last position (only used by GetLastPosition())
wxTextPos m_posLast;
// max text line length
unsigned long m_maxLength;
// selection
wxTextPos m_selAnchor,
m_selStart,
m_selEnd;
// flags
bool m_isModified:1,
m_isEditable:1,
m_hasCaret:1,
m_wrapLines:1; // can't be changed after creation
// the rectangle (in client coordinates) to draw text inside
wxRect m_rectText;
// the height of one line (cached value of GetCharHeight)
wxCoord m_heightLine;
// and the average char width (cached value of GetCharWidth)
wxCoord m_widthAvg;
// we have some data which depends on the kind of control (single or multi
// line)
union
{
wxTextSingleLineData *sdata;
wxTextMultiLineData *mdata;
wxTextWrappedData *wdata;
void *data;
} m_data;
// the object to which we delegate our undo/redo implementation
wxTextCtrlCommandProcessor *m_cmdProcessor;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxTextCtrl);
friend class wxWrappedLineData;
};
#endif // _WX_UNIV_TEXTCTRL_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dcclient.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dcclient.h
// Purpose: wxClientDCImpl, wxPaintDCImpl and wxWindowDCImpl classes
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCCLIENT_H_
#define _WX_DCCLIENT_H_
#include "wx/motif/dc.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
//-----------------------------------------------------------------------------
// wxWindowDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDCImpl : public wxMotifDCImpl
{
public:
wxWindowDCImpl(wxDC *owner);
wxWindowDCImpl(wxDC *owner, wxWindow *win);
virtual ~wxWindowDCImpl();
// TODO this function is Motif-only for now - should it go into base class?
void Clear(const wxRect& rect);
// implement base class pure virtuals
// ----------------------------------
virtual void Clear();
virtual void SetFont(const wxFont& font);
virtual void SetPen(const wxPen& pen);
virtual void SetBrush(const wxBrush& brush);
virtual void SetBackground(const wxBrush& brush);
virtual void SetBackgroundMode(int mode);
virtual void SetPalette(const wxPalette& palette);
virtual void SetLogicalFunction( wxRasterOperationMode function );
virtual void SetTextForeground(const wxColour& colour);
virtual void SetTextBackground(const wxColour& colour);
virtual wxCoord GetCharHeight() const;
virtual wxCoord GetCharWidth() const;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *x, wxCoord *y,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
const wxFont *theFont = NULL) const;
virtual bool CanDrawBitmap() const;
virtual bool CanGetTextExtent() const;
virtual int GetDepth() const;
virtual wxSize GetPPI() const;
virtual void DestroyClippingRegion();
// Helper function for setting clipping
void SetDCClipping(WXRegion region);
// implementation from now on
// --------------------------
WXGC GetGC() const { return m_gc; }
WXGC GetBackingGC() const { return m_gcBacking; }
WXDisplay* GetDisplay() const { return m_display; }
bool GetAutoSetting() const { return (m_autoSetting != 0); } // See comment in dcclient.cpp
void SetAutoSetting(bool flag) { m_autoSetting = flag; }
protected:
// note that this function will call colour.SetPixel,
// and will do one of curCol = colour, curCol = wxWHITE, curCol = wxBLACK
// roundToWhite has an effect for monochrome display only
// if roundToWhite == true then the colour will be set to white unless
// it is RGB 0x000000;if roundToWhite == true the colour wull be set to
// black unless it id RGB 0xffffff
WXPixel CalculatePixel(wxColour& colour, wxColour& curCol,
bool roundToWhite) const;
// sets the foreground pixel taking into account the
// currently selected logical operation
void SetForegroundPixelWithLogicalFunction(WXPixel pixel);
virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
wxFloodFillStyle style = wxFLOOD_SURFACE);
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const;
virtual void DoDrawPoint(wxCoord x, wxCoord y);
virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
virtual void DoDrawArc(wxCoord x1, wxCoord y1,
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc);
virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
double sa, double ea);
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
wxCoord width, wxCoord height,
double radius);
virtual void DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoCrossHair(wxCoord x, wxCoord y);
virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y);
virtual void DoDrawRotatedText(const wxString &text, wxCoord x, wxCoord y, double angle);
virtual bool DoBlit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
wxDC *source, wxCoord xsrc, wxCoord ysrc,
wxRasterOperationMode rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = -1, wxCoord ysrcMask = -1);
virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoSetDeviceClippingRegion(const wxRegion& region);
virtual void DoDrawLines(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset);
virtual void DoDrawPolygon(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
void DoGetSize( int *width, int *height ) const;
// common part of constructors
void Init();
WXGC m_gc;
WXGC m_gcBacking;
WXDisplay* m_display;
wxWindow* m_window;
// Pixmap for drawing on
WXPixmap m_pixmap;
// Last clipping region set on th GC, this is the combination
// of paint clipping region and all user-defined clipping regions
WXRegion m_clipRegion;
// Not sure if we'll need all of these
WXPixel m_backgroundPixel;
wxColour m_currentColour;
int m_currentPenWidth ;
int m_currentPenJoin ;
int m_currentPenCap ;
int m_currentPenDashCount ;
wxX11Dash* m_currentPenDash ;
wxBitmap m_currentStipple ;
int m_currentStyle ;
int m_currentFill ;
int m_autoSetting ; // See comment in dcclient.cpp
wxDECLARE_DYNAMIC_CLASS(wxWindowDCImpl);
};
class WXDLLIMPEXP_CORE wxPaintDCImpl: public wxWindowDCImpl
{
public:
wxPaintDCImpl(wxDC *owner) : wxWindowDCImpl(owner) { }
wxPaintDCImpl(wxDC *owner, wxWindow* win);
virtual ~wxPaintDCImpl();
wxDECLARE_DYNAMIC_CLASS(wxPaintDCImpl);
};
class WXDLLIMPEXP_CORE wxClientDCImpl: public wxWindowDCImpl
{
public:
wxClientDCImpl(wxDC *owner) : wxWindowDCImpl(owner) { }
wxClientDCImpl(wxDC *owner, wxWindow* win)
: wxWindowDCImpl(owner, win) { }
wxDECLARE_DYNAMIC_CLASS(wxClientDCImpl);
};
#endif // _WX_DCCLIENT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/setup.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/setup.h
// Purpose: Configuration for the library
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
/* --- start common options --- */
// ----------------------------------------------------------------------------
// global settings
// ----------------------------------------------------------------------------
// define this to 0 when building wxBase library - this can also be done from
// makefile/project file overriding the value here
#ifndef wxUSE_GUI
#define wxUSE_GUI 1
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// compatibility settings
// ----------------------------------------------------------------------------
// This setting determines the compatibility with 2.8 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_2_8 0
// This setting determines the compatibility with 3.0 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_3_0 1
// MSW-only: Set to 0 for accurate dialog units, else 1 for old behaviour when
// default system font is used for wxWindow::GetCharWidth/Height() instead of
// the current font.
//
// Default is 0
//
// Recommended setting: 0
#define wxDIALOG_UNIT_COMPATIBILITY 0
// Provide unsafe implicit conversions in wxString to "const char*" or
// "std::string" (depending on wxUSE_STD_STRING_CONV_IN_WXSTRING value).
//
// Default is 1 but only for compatibility reasons, it is recommended to set
// this to 0 because converting wxString to a narrow (non-Unicode) string may
// fail unless a locale using UTF-8 encoding is used, which is never the case
// under MSW, for example, hence such conversions can result in silent data
// loss.
//
// Recommended setting: 0
#define wxUSE_UNSAFE_WXSTRING_CONV 1
// If set to 1, enables "reproducible builds", i.e. build output should be
// exactly the same if the same build is redone again. As using __DATE__ and
// __TIME__ macros clearly makes the build irreproducible, setting this option
// to 1 disables their use in the library code.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_REPRODUCIBLE_BUILD 0
// ----------------------------------------------------------------------------
// debugging settings
// ----------------------------------------------------------------------------
// wxDEBUG_LEVEL will be defined as 1 in wx/debug.h so normally there is no
// need to define it here. You may do it for two reasons: either completely
// disable/compile out the asserts in release version (then do it inside #ifdef
// NDEBUG) or, on the contrary, enable more asserts, including the usually
// disabled ones, in the debug build (then do it inside #ifndef NDEBUG)
//
// #ifdef NDEBUG
// #define wxDEBUG_LEVEL 0
// #else
// #define wxDEBUG_LEVEL 2
// #endif
// wxHandleFatalExceptions() may be used to catch the program faults at run
// time and, instead of terminating the program with a usual GPF message box,
// call the user-defined wxApp::OnFatalException() function. If you set
// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
//
// This setting is for Win32 only and can only be enabled if your compiler
// supports Win32 structured exception handling (currently only VC++ does)
//
// Default is 1
//
// Recommended setting: 1 if your compiler supports it.
#define wxUSE_ON_FATAL_EXCEPTION 1
// Set this to 1 to be able to generate a human-readable (unlike
// machine-readable minidump created by wxCrashReport::Generate()) stack back
// trace when your program crashes using wxStackWalker
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_STACKWALKER 1
// Set this to 1 to compile in wxDebugReport class which allows you to create
// and optionally upload to your web site a debug report consisting of back
// trace of the crash (if wxUSE_STACKWALKER == 1) and other information.
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, it is compiled into a separate library so there
// is no overhead if you don't use it
#define wxUSE_DEBUGREPORT 1
// Generic comment about debugging settings: they are very useful if you don't
// use any other memory leak detection tools such as Purify/BoundsChecker, but
// are probably redundant otherwise. Also, Visual C++ CRT has the same features
// as wxWidgets memory debugging subsystem built in since version 5.0 and you
// may prefer to use it instead of built in memory debugging code because it is
// faster and more fool proof.
//
// Using VC++ CRT memory debugging is enabled by default in debug build (_DEBUG
// is defined) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
// and if __NO_VC_CRTDBG__ is not defined.
// The rest of the options in this section are obsolete and not supported,
// enable them at your own risk.
// If 1, enables wxDebugContext, for writing error messages to file, etc. If
// __WXDEBUG__ is not defined, will still use the normal memory operators.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_CONTEXT 0
// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
// __WXDEBUG__ is also defined.
//
// WARNING: this code may not work with all architectures, especially if
// alignment is an issue. This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 1 if you are not using a memory debugging tool, else 0
#define wxUSE_MEMORY_TRACING 0
// In debug mode, cause new and delete to be redefined globally.
// If this causes problems (e.g. link errors which is a common problem
// especially if you use another library which also redefines the global new
// and delete), set this to 0.
// This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
// this causes problems (e.g. link errors), set this to 0. You may need to set
// this to 0 if using templates (at least for VC++). This switch is currently
// ignored for MinGW/Cygwin.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_NEW_ALWAYS 0
// ----------------------------------------------------------------------------
// Unicode support
// ----------------------------------------------------------------------------
// These settings are obsolete: the library is always built in Unicode mode
// now, only set wxUSE_UNICODE to 0 to compile legacy code in ANSI mode if
// absolutely necessary -- updating it is strongly recommended as the ANSI mode
// will disappear completely in future wxWidgets releases.
#ifndef wxUSE_UNICODE
#define wxUSE_UNICODE 1
#endif
// wxUSE_WCHAR_T is required by wxWidgets now, don't change.
#define wxUSE_WCHAR_T 1
// ----------------------------------------------------------------------------
// global features
// ----------------------------------------------------------------------------
// Compile library in exception-safe mode? If set to 1, the library will try to
// behave correctly in presence of exceptions (even though it still will not
// use the exceptions itself) and notify the user code about any unhandled
// exceptions. If set to 0, propagation of the exceptions through the library
// code will lead to undefined behaviour -- but the code itself will be
// slightly smaller and faster.
//
// Note that like wxUSE_THREADS this option is automatically set to 0 if
// wxNO_EXCEPTIONS is defined.
//
// Default is 1
//
// Recommended setting: depends on whether you intend to use C++ exceptions
// in your own code (1 if you do, 0 if you don't)
#define wxUSE_EXCEPTIONS 1
// Set wxUSE_EXTENDED_RTTI to 1 to use extended RTTI
//
// Default is 0
//
// Recommended setting: 0 (this is still work in progress...)
#define wxUSE_EXTENDED_RTTI 0
// Support for message/error logging. This includes wxLogXXX() functions and
// wxLog and derived classes. Don't set this to 0 unless you really know what
// you are doing.
//
// Default is 1
//
// Recommended setting: 1 (always)
#define wxUSE_LOG 1
// Recommended setting: 1
#define wxUSE_LOGWINDOW 1
// Recommended setting: 1
#define wxUSE_LOGGUI 1
// Recommended setting: 1
#define wxUSE_LOG_DIALOG 1
// Support for command line parsing using wxCmdLineParser class.
//
// Default is 1
//
// Recommended setting: 1 (can be set to 0 if you don't use the cmd line)
#define wxUSE_CMDLINE_PARSER 1
// Support for multithreaded applications: if 1, compile in thread classes
// (thread.h) and make the library a bit more thread safe. Although thread
// support is quite stable by now, you may still consider recompiling the
// library without it if you have no use for it - this will result in a
// somewhat smaller and faster operation.
//
// Notice that if wxNO_THREADS is defined, wxUSE_THREADS is automatically reset
// to 0 in wx/chkconf.h, so, for example, if you set USE_THREADS to 0 in
// build/msw/config.* file this value will have no effect.
//
// Default is 1
//
// Recommended setting: 0 unless you do plan to develop MT applications
#define wxUSE_THREADS 1
// If enabled, compiles wxWidgets streams classes
//
// wx stream classes are used for image IO, process IO redirection, network
// protocols implementation and much more and so disabling this results in a
// lot of other functionality being lost.
//
// Default is 1
//
// Recommended setting: 1 as setting it to 0 disables many other things
#define wxUSE_STREAMS 1
// Support for positional parameters (e.g. %1$d, %2$s ...) in wxVsnprintf.
// Note that if the system's implementation does not support positional
// parameters, setting this to 1 forces the use of the wxWidgets implementation
// of wxVsnprintf. The standard vsnprintf() supports positional parameters on
// many Unix systems but usually doesn't under Windows.
//
// Positional parameters are very useful when translating a program since using
// them in formatting strings allow translators to correctly reorder the
// translated sentences.
//
// Default is 1
//
// Recommended setting: 1 if you want to support multiple languages
#define wxUSE_PRINTF_POS_PARAMS 1
// Enable the use of compiler-specific thread local storage keyword, if any.
// This is used for wxTLS_XXX() macros implementation and normally should use
// the compiler-provided support as it's simpler and more efficient, but is
// disabled under Windows in wx/msw/chkconf.h as it can't be used if wxWidgets
// is used in a dynamically loaded Win32 DLL (i.e. using LoadLibrary()) under
// XP as this triggers a bug in compiler TLS support that results in crashes
// when any TLS variables are used.
//
// If you're absolutely sure that your build of wxWidgets is never going to be
// used in such situation, either because it's not going to be linked from any
// kind of plugin or because you only target Vista or later systems, you can
// set this to 2 to force the use of compiler TLS even under MSW.
//
// Default is 1 meaning that compiler TLS is used only if it's 100% safe.
//
// Recommended setting: 2 if you want to have maximal performance and don't
// care about the scenario described above.
#define wxUSE_COMPILER_TLS 1
// ----------------------------------------------------------------------------
// Interoperability with the standard library.
// ----------------------------------------------------------------------------
// Set wxUSE_STL to 1 to enable maximal interoperability with the standard
// library, even at the cost of backwards compatibility.
//
// Default is 0
//
// Recommended setting: 0 as the options below already provide a relatively
// good level of interoperability and changing this option arguably isn't worth
// diverging from the official builds of the library.
#define wxUSE_STL 0
// This is not a real option but is used as the default value for
// wxUSE_STD_IOSTREAM, wxUSE_STD_STRING and wxUSE_STD_CONTAINERS_COMPATIBLY.
//
// Set it to 0 if you want to disable the use of all standard classes
// completely for some reason.
#define wxUSE_STD_DEFAULT 1
// Use standard C++ containers where it can be done without breaking backwards
// compatibility.
//
// This provides better interoperability with the standard library, e.g. with
// this option on it's possible to insert std::vector<> into many wxWidgets
// containers directly.
//
// Default is 1.
//
// Recommended setting is 1 unless you want to avoid all dependencies on the
// standard library.
#define wxUSE_STD_CONTAINERS_COMPATIBLY wxUSE_STD_DEFAULT
// Use standard C++ containers to implement wxVector<>, wxStack<>, wxDList<>
// and wxHashXXX<> classes. If disabled, wxWidgets own (mostly compatible but
// usually more limited) implementations are used which allows to avoid the
// dependency on the C++ run-time library.
//
// Default is 0 for compatibility reasons.
//
// Recommended setting: 1 unless compatibility with the official wxWidgets
// build and/or the existing code is a concern.
#define wxUSE_STD_CONTAINERS 0
// Use standard C++ streams if 1 instead of wx streams in some places. If
// disabled, wx streams are used everywhere and wxWidgets doesn't depend on the
// standard streams library.
//
// Notice that enabling this does not replace wx streams with std streams
// everywhere, in a lot of places wx streams are used no matter what.
//
// Default is 1 if compiler supports it.
//
// Recommended setting: 1 if you use the standard streams anyhow and so
// dependency on the standard streams library is not a
// problem
#define wxUSE_STD_IOSTREAM wxUSE_STD_DEFAULT
// Enable minimal interoperability with the standard C++ string class if 1.
// "Minimal" means that wxString can be constructed from std::string or
// std::wstring but can't be implicitly converted to them. You need to enable
// the option below for the latter.
//
// Default is 1 for most compilers.
//
// Recommended setting: 1 unless you want to ensure your program doesn't use
// the standard C++ library at all.
#define wxUSE_STD_STRING wxUSE_STD_DEFAULT
// Make wxString as much interchangeable with std::[w]string as possible, in
// particular allow implicit conversion of wxString to either of these classes.
// This comes at a price (or a benefit, depending on your point of view) of not
// allowing implicit conversion to "const char *" and "const wchar_t *".
//
// Because a lot of existing code relies on these conversions, this option is
// disabled by default but can be enabled for your build if you don't care
// about compatibility.
//
// Default is 0 if wxUSE_STL has its default value or 1 if it is enabled.
//
// Recommended setting: 0 to remain compatible with the official builds of
// wxWidgets.
#define wxUSE_STD_STRING_CONV_IN_WXSTRING wxUSE_STL
// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
// them. Set this option to 1 to use <iostream.h>, 0 to use <iostream>.
//
// Note that newer compilers (including VC++ 7.1 and later) don't support
// wxUSE_IOSTREAMH == 1 and so <iostream> will be used anyhow.
//
// Default is 0.
//
// Recommended setting: 0, only set to 1 if you use a really old compiler
#define wxUSE_IOSTREAMH 0
// ----------------------------------------------------------------------------
// non GUI features selection
// ----------------------------------------------------------------------------
// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
// integer which is implemented in terms of native 64 bit integers if any or
// uses emulation otherwise.
//
// This class is required by wxDateTime and so you should enable it if you want
// to use wxDateTime. For most modern platforms, it will use the native 64 bit
// integers in which case (almost) all of its functions are inline and it
// almost does not take any space, so there should be no reason to switch it
// off.
//
// Recommended setting: 1
#define wxUSE_LONGLONG 1
// Set wxUSE_BASE64 to 1, to compile in Base64 support. This is required for
// storing binary data in wxConfig on most platforms.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_BASE64 1
// Set this to 1 to be able to use wxEventLoop even in console applications
// (i.e. using base library only, without GUI). This is mostly useful for
// processing socket events but is also necessary to use timers in console
// applications
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_CONSOLE_EVENTLOOP 1
// Set wxUSE_(F)FILE to 1 to compile wx(F)File classes. wxFile uses low level
// POSIX functions for file access, wxFFile uses ANSI C stdio.h functions.
//
// Default is 1
//
// Recommended setting: 1 (wxFile is highly recommended as it is required by
// i18n code, wxFileConfig and others)
#define wxUSE_FILE 1
#define wxUSE_FFILE 1
// Use wxFSVolume class providing access to the configured/active mount points
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_FSVOLUME 1
// Use wxSecretStore class for storing passwords using OS-specific facilities.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_SECRETSTORE 1
// Use wxStandardPaths class which allows to retrieve some standard locations
// in the file system
//
// Default is 1
//
// Recommended setting: 1 (may be disabled to save space, but not much)
#define wxUSE_STDPATHS 1
// use wxTextBuffer class: required by wxTextFile
#define wxUSE_TEXTBUFFER 1
// use wxTextFile class: requires wxFile and wxTextBuffer, required by
// wxFileConfig
#define wxUSE_TEXTFILE 1
// i18n support: _() macro, wxLocale class. Requires wxTextFile.
#define wxUSE_INTL 1
// Provide wxFoo_l() functions similar to standard foo() functions but taking
// an extra locale parameter.
//
// Notice that this is fully implemented only for the systems providing POSIX
// xlocale support or Microsoft Visual C++ >= 8 (which provides proprietary
// almost-equivalent of xlocale functions), otherwise wxFoo_l() functions will
// only work for the current user locale and "C" locale. You can use
// wxHAS_XLOCALE_SUPPORT to test whether the full support is available.
//
// Default is 1
//
// Recommended setting: 1 but may be disabled if you are writing programs
// running only in C locale anyhow
#define wxUSE_XLOCALE 1
// Set wxUSE_DATETIME to 1 to compile the wxDateTime and related classes which
// allow to manipulate dates, times and time intervals.
//
// Requires: wxUSE_LONGLONG
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_DATETIME 1
// Set wxUSE_TIMER to 1 to compile wxTimer class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_TIMER 1
// Use wxStopWatch clas.
//
// Default is 1
//
// Recommended setting: 1 (needed by wxSocket)
#define wxUSE_STOPWATCH 1
// Set wxUSE_FSWATCHER to 1 if you want to enable wxFileSystemWatcher
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FSWATCHER 1
// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
// which allow the application to store its settings in the persistent
// storage. Setting this to 1 will also enable on-demand creation of the
// global config object in wxApp.
//
// See also wxUSE_CONFIG_NATIVE below.
//
// Recommended setting: 1
#define wxUSE_CONFIG 1
// If wxUSE_CONFIG is 1, you may choose to use either the native config
// classes under Windows (using .INI files under Win16 and the registry under
// Win32) or the portable text file format used by the config classes under
// Unix.
//
// Default is 1 to use native classes. Note that you may still use
// wxFileConfig even if you set this to 1 - just the config object created by
// default for the applications needs will be a wxRegConfig or wxIniConfig and
// not wxFileConfig.
//
// Recommended setting: 1
#define wxUSE_CONFIG_NATIVE 1
// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
// to connect/disconnect from the network and be notified whenever the dial-up
// network connection is established/terminated. Requires wxUSE_DYNAMIC_LOADER.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DIALUP_MANAGER 1
// Compile in classes for run-time DLL loading and function calling.
// Required by wxUSE_DIALUP_MANAGER.
//
// This setting is for Win32 only
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DYNLIB_CLASS 1
// experimental, don't use for now
#define wxUSE_DYNAMIC_LOADER 1
// Set to 1 to use socket classes
#define wxUSE_SOCKETS 1
// Set to 1 to use ipv6 socket classes (requires wxUSE_SOCKETS)
//
// Notice that currently setting this option under Windows will result in
// programs which can only run on recent OS versions (with ws2_32.dll
// installed) which is why it is disabled by default.
//
// Default is 1.
//
// Recommended setting: 1 if you need IPv6 support
#define wxUSE_IPV6 0
// Set to 1 to enable virtual file systems (required by wxHTML)
#define wxUSE_FILESYSTEM 1
// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ZIP 1
// Set to 1 to enable virtual archive filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ARCHIVE 1
// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_INET 1
// wxArchive classes for accessing archives such as zip and tar
#define wxUSE_ARCHIVE_STREAMS 1
// Set to 1 to compile wxZipInput/OutputStream classes.
#define wxUSE_ZIPSTREAM 1
// Set to 1 to compile wxTarInput/OutputStream classes.
#define wxUSE_TARSTREAM 1
// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
// wxUSE_LIBPNG
#define wxUSE_ZLIB 1
// Set to 1 if liblzma is available to enable wxLZMA{Input,Output}Stream
// classes.
//
// Notice that if you enable this build option when not using configure or
// CMake, you need to ensure that liblzma headers and libraries are available
// (i.e. by building the library yourself or downloading its binaries) and can
// be found, either by copying them to one of the locations searched by the
// compiler/linker by default (e.g. any of the directories in the INCLUDE or
// LIB environment variables, respectively, when using MSVC) or modify the
// make- or project files to add references to these directories.
//
// Default is 0 under MSW, auto-detected by configure.
//
// Recommended setting: 1 if you need LZMA compression.
#define wxUSE_LIBLZMA 0
// If enabled, the code written by Apple will be used to write, in a portable
// way, float on the disk. See extended.c for the license which is different
// from wxWidgets one.
//
// Default is 1.
//
// Recommended setting: 1 unless you don't like the license terms (unlikely)
#define wxUSE_APPLE_IEEE 1
// Joystick support class
#define wxUSE_JOYSTICK 1
// wxFontEnumerator class
#define wxUSE_FONTENUM 1
// wxFontMapper class
#define wxUSE_FONTMAP 1
// wxMimeTypesManager class
#define wxUSE_MIMETYPE 1
// wxProtocol and related classes: if you want to use either of wxFTP, wxHTTP
// or wxURL you need to set this to 1.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_PROTOCOL 1
// The settings for the individual URL schemes
#define wxUSE_PROTOCOL_FILE 1
#define wxUSE_PROTOCOL_FTP 1
#define wxUSE_PROTOCOL_HTTP 1
// Define this to use wxURL class.
#define wxUSE_URL 1
// Define this to use native platform url and protocol support.
// Currently valid only for MS-Windows.
// Note: if you set this to 1, you can open ftp/http/gopher sites
// and obtain a valid input stream for these sites
// even when you set wxUSE_PROTOCOL_FTP/HTTP to 0.
// Doing so reduces the code size.
//
// This code is experimental and subject to change.
#define wxUSE_URL_NATIVE 0
// Support for wxVariant class used in several places throughout the library,
// notably in wxDataViewCtrl API.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size as much as
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
// Support for wxAny class, the successor for wxVariant.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size by a small amount,
// or your compiler cannot for some reason cope with complexity of templates used.
#define wxUSE_ANY 1
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
//
// Default is 0
//
// Recommended setting: 1 if your compiler supports it, if it doesn't please
// contribute us a makefile for src/regex for it
#define wxUSE_REGEX 1
// wxSystemOptions class
#define wxUSE_SYSTEM_OPTIONS 1
// wxSound class
#define wxUSE_SOUND 1
// Use wxMediaCtrl
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_MEDIACTRL 1
// Use wxWidget's XRC XML-based resource system. Recommended.
//
// Default is 1
//
// Recommended setting: 1 (requires wxUSE_XML)
#define wxUSE_XRC 1
// XML parsing classes. Note that their API will change in the future, so
// using wxXmlDocument and wxXmlNode in your app is not recommended.
//
// Default is the same as wxUSE_XRC, i.e. 1 by default.
//
// Recommended setting: 1 (required by XRC)
#define wxUSE_XML wxUSE_XRC
// Use wxWidget's AUI docking system
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_AUI 1
// Use wxWidget's Ribbon classes for interfaces
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_RIBBON 1
// Use wxPropertyGrid.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_PROPGRID 1
// Use wxStyledTextCtrl, a wxWidgets implementation of Scintilla.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STC 1
// Use wxWidget's web viewing classes
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_WEBVIEW 1
// Use the IE wxWebView backend
//
// Default is 1 on MSW
//
// Recommended setting: 1
#ifdef __WXMSW__
#define wxUSE_WEBVIEW_IE 1
#else
#define wxUSE_WEBVIEW_IE 0
#endif
// Use the WebKit wxWebView backend
//
// Default is 1 on GTK and OSX
//
// Recommended setting: 1
#if (defined(__WXGTK__) && !defined(__WXGTK3__)) || defined(__WXOSX__)
#define wxUSE_WEBVIEW_WEBKIT 1
#else
#define wxUSE_WEBVIEW_WEBKIT 0
#endif
// Use the WebKit2 wxWebView backend
//
// Default is 1 on GTK3
//
// Recommended setting: 1
#if defined(__WXGTK3__)
#define wxUSE_WEBVIEW_WEBKIT2 1
#else
#define wxUSE_WEBVIEW_WEBKIT2 0
#endif
// Enable wxGraphicsContext and related classes for a modern 2D drawing API.
//
// Default is 1 except if you're using a compiler without support for GDI+
// under MSW, i.e. gdiplus.h and related headers (MSVC and MinGW >= 4.8 are
// known to have them). For other compilers (e.g. older mingw32) you may need
// to install the headers (and just the headers) yourself. If you do, change
// the setting below manually.
//
// Recommended setting: 1 if supported by the compilation environment
// Notice that we can't use wxCHECK_VISUALC_VERSION() nor wxCHECK_GCC_VERSION()
// here as this file is included from wx/platform.h before they're defined.
#if defined(_MSC_VER) || \
(defined(__MINGW32__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 8))
#define wxUSE_GRAPHICS_CONTEXT 1
#else
// Disable support for other Windows compilers, enable it if your compiler
// comes with new enough SDK or you installed the headers manually.
//
// Notice that this will be set by configure under non-Windows platforms
// anyhow so the value there is not important.
#define wxUSE_GRAPHICS_CONTEXT 0
#endif
// Enable wxGraphicsContext implementation using Cairo library.
//
// This is not needed under Windows and detected automatically by configure
// under other systems, however you may set this to 1 manually if you installed
// Cairo under Windows yourself and prefer to use it instead the native GDI+
// implementation.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_CAIRO 0
// ----------------------------------------------------------------------------
// Individual GUI controls
// ----------------------------------------------------------------------------
// You must set wxUSE_CONTROLS to 1 if you are using any controls at all
// (without it, wxControl class is not compiled)
//
// Default is 1
//
// Recommended setting: 1 (don't change except for very special programs)
#define wxUSE_CONTROLS 1
// Support markup in control labels, i.e. provide wxControl::SetLabelMarkup().
// Currently markup is supported only by a few controls and only some ports but
// their number will increase with time.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you want to save on code size)
#define wxUSE_MARKUP 1
// wxPopupWindow class is a top level transient window. It is currently used
// to implement wxTipWindow
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you don't wxUSE_TIPWINDOW)
#define wxUSE_POPUPWIN 1
// wxTipWindow allows to implement the custom tooltips, it is used by the
// context help classes. Requires wxUSE_POPUPWIN.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0)
#define wxUSE_TIPWINDOW 1
// Each of the settings below corresponds to one wxWidgets control. They are
// all switched on by default but may be disabled if you are sure that your
// program (including any standard dialogs it can show!) doesn't need them and
// if you desperately want to save some space. If you use any of these you must
// set wxUSE_CONTROLS as well.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_ACTIVITYINDICATOR 1 // wxActivityIndicator
#define wxUSE_ANIMATIONCTRL 1 // wxAnimationCtrl
#define wxUSE_BANNERWINDOW 1 // wxBannerWindow
#define wxUSE_BUTTON 1 // wxButton
#define wxUSE_BMPBUTTON 1 // wxBitmapButton
#define wxUSE_CALENDARCTRL 1 // wxCalendarCtrl
#define wxUSE_CHECKBOX 1 // wxCheckBox
#define wxUSE_CHECKLISTBOX 1 // wxCheckListBox (requires wxUSE_OWNER_DRAWN)
#define wxUSE_CHOICE 1 // wxChoice
#define wxUSE_COLLPANE 1 // wxCollapsiblePane
#define wxUSE_COLOURPICKERCTRL 1 // wxColourPickerCtrl
#define wxUSE_COMBOBOX 1 // wxComboBox
#define wxUSE_COMMANDLINKBUTTON 1 // wxCommandLinkButton
#define wxUSE_DATAVIEWCTRL 1 // wxDataViewCtrl
#define wxUSE_DATEPICKCTRL 1 // wxDatePickerCtrl
#define wxUSE_DIRPICKERCTRL 1 // wxDirPickerCtrl
#define wxUSE_EDITABLELISTBOX 1 // wxEditableListBox
#define wxUSE_FILECTRL 1 // wxFileCtrl
#define wxUSE_FILEPICKERCTRL 1 // wxFilePickerCtrl
#define wxUSE_FONTPICKERCTRL 1 // wxFontPickerCtrl
#define wxUSE_GAUGE 1 // wxGauge
#define wxUSE_HEADERCTRL 1 // wxHeaderCtrl
#define wxUSE_HYPERLINKCTRL 1 // wxHyperlinkCtrl
#define wxUSE_LISTBOX 1 // wxListBox
#define wxUSE_LISTCTRL 1 // wxListCtrl
#define wxUSE_RADIOBOX 1 // wxRadioBox
#define wxUSE_RADIOBTN 1 // wxRadioButton
#define wxUSE_RICHMSGDLG 1 // wxRichMessageDialog
#define wxUSE_SCROLLBAR 1 // wxScrollBar
#define wxUSE_SEARCHCTRL 1 // wxSearchCtrl
#define wxUSE_SLIDER 1 // wxSlider
#define wxUSE_SPINBTN 1 // wxSpinButton
#define wxUSE_SPINCTRL 1 // wxSpinCtrl
#define wxUSE_STATBOX 1 // wxStaticBox
#define wxUSE_STATLINE 1 // wxStaticLine
#define wxUSE_STATTEXT 1 // wxStaticText
#define wxUSE_STATBMP 1 // wxStaticBitmap
#define wxUSE_TEXTCTRL 1 // wxTextCtrl
#define wxUSE_TIMEPICKCTRL 1 // wxTimePickerCtrl
#define wxUSE_TOGGLEBTN 1 // requires wxButton
#define wxUSE_TREECTRL 1 // wxTreeCtrl
#define wxUSE_TREELISTCTRL 1 // wxTreeListCtrl
// Use a status bar class? Depending on the value of wxUSE_NATIVE_STATUSBAR
// below either wxStatusBar95 or a generic wxStatusBar will be used.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STATUSBAR 1
// Two status bar implementations are available under Win32: the generic one
// or the wrapper around native control. For native look and feel the native
// version should be used.
//
// Default is 1 for the platforms where native status bar is supported.
//
// Recommended setting: 1 (there is no advantage in using the generic one)
#define wxUSE_NATIVE_STATUSBAR 1
// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
// classes at all. Otherwise, use the native toolbar class unless
// wxUSE_TOOLBAR_NATIVE is 0.
//
// Default is 1 for all settings.
//
// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE.
#define wxUSE_TOOLBAR 1
#define wxUSE_TOOLBAR_NATIVE 1
// wxNotebook is a control with several "tabs" located on one of its sides. It
// may be used to logically organise the data presented to the user instead of
// putting everything in one huge dialog. It replaces wxTabControl and related
// classes of wxWin 1.6x.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTEBOOK 1
// wxListbook control is similar to wxNotebook but uses wxListCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_LISTBOOK 1
// wxChoicebook control is similar to wxNotebook but uses wxChoice instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CHOICEBOOK 1
// wxTreebook control is similar to wxNotebook but uses wxTreeCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TREEBOOK 1
// wxToolbook control is similar to wxNotebook but uses wxToolBar instead of
// tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLBOOK 1
// wxTaskBarIcon is a small notification icon shown in the system toolbar or
// dock.
//
// Default is 1.
//
// Recommended setting: 1 (but can be set to 0 if you don't need it)
#define wxUSE_TASKBARICON 1
// wxGrid class
//
// Default is 1, set to 0 to cut down compilation time and binaries size if you
// don't use it.
//
// Recommended setting: 1
//
#define wxUSE_GRID 1
// wxMiniFrame class: a frame with narrow title bar
//
// Default is 1.
//
// Recommended setting: 1 (it doesn't cost almost anything)
#define wxUSE_MINIFRAME 1
// wxComboCtrl and related classes: combobox with custom popup window and
// not necessarily a listbox.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 except for wxUniv where it
// it used by wxComboBox
#define wxUSE_COMBOCTRL 1
// wxOwnerDrawnComboBox is a custom combobox allowing to paint the combobox
// items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0, except where it is
// needed as a base class for generic wxBitmapComboBox.
#define wxUSE_ODCOMBOBOX 1
// wxBitmapComboBox is a combobox that can have images in front of text items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0
#define wxUSE_BITMAPCOMBOBOX 1
// wxRearrangeCtrl is a wxCheckListBox with two buttons allowing to move items
// up and down in it. It is also used as part of wxRearrangeDialog.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 (currently used only by
// wxHeaderCtrl)
#define wxUSE_REARRANGECTRL 1
// wxAddRemoveCtrl is a composite control containing a control showing some
// items (e.g. wxListBox, wxListCtrl, wxTreeCtrl, wxDataViewCtrl, ...) and "+"/
// "-" buttons allowing to add and remove items to/from the control.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 if you don't need it (not
// used by the library itself).
#define wxUSE_ADDREMOVECTRL 1
// ----------------------------------------------------------------------------
// Miscellaneous GUI stuff
// ----------------------------------------------------------------------------
// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
#define wxUSE_ACCEL 1
// Use the standard art provider. The icons returned by this provider are
// embedded into the library as XPMs so disabling it reduces the library size
// somewhat but this should only be done if you use your own custom art
// provider returning the icons or never use any icons not provided by the
// native art provider (which might not be implemented at all for some
// platforms) or by the Tango icons provider (if it's not itself disabled
// below).
//
// Default is 1.
//
// Recommended setting: 1 unless you use your own custom art provider.
#define wxUSE_ARTPROVIDER_STD 1
// Use art provider providing Tango icons: this art provider has higher quality
// icons than the default ones using smaller size XPM icons without
// transparency but the embedded PNG icons add to the library size.
//
// Default is 1 under non-GTK ports. Under wxGTK the native art provider using
// the GTK+ stock icons replaces it so it is normally not necessary.
//
// Recommended setting: 1 but can be turned off to reduce the library size.
#define wxUSE_ARTPROVIDER_TANGO 1
// Hotkey support (currently Windows only)
#define wxUSE_HOTKEY 1
// Use wxCaret: a class implementing a "cursor" in a text control (called caret
// under Windows).
//
// Default is 1.
//
// Recommended setting: 1 (can be safely set to 0, not used by the library)
#define wxUSE_CARET 1
// Use wxDisplay class: it allows enumerating all displays on a system and
// their geometries as well as finding the display on which the given point or
// window lies.
//
// Default is 1.
//
// Recommended setting: 1 if you need it, can be safely set to 0 otherwise
#define wxUSE_DISPLAY 1
// Miscellaneous geometry code: needed for Canvas library
#define wxUSE_GEOMETRY 1
// Use wxImageList. This class is needed by wxNotebook, wxTreeCtrl and
// wxListCtrl.
//
// Default is 1.
//
// Recommended setting: 1 (set it to 0 if you don't use any of the controls
// enumerated above, then this class is mostly useless too)
#define wxUSE_IMAGLIST 1
// Use wxInfoBar class.
//
// Default is 1.
//
// Recommended setting: 1 (but can be disabled without problems as nothing
// depends on it)
#define wxUSE_INFOBAR 1
// Use wxMenu, wxMenuBar, wxMenuItem.
//
// Default is 1.
//
// Recommended setting: 1 (can't be disabled under MSW)
#define wxUSE_MENUS 1
// Use wxNotificationMessage.
//
// wxNotificationMessage allows to show non-intrusive messages to the user
// using balloons, banners, popups or whatever is the appropriate method for
// the current platform.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTIFICATION_MESSAGE 1
// wxPreferencesEditor provides a common API for different ways of presenting
// the standard "Preferences" or "Properties" dialog under different platforms
// (e.g. some use modal dialogs, some use modeless ones; some apply the changes
// immediately while others require an explicit "Apply" button).
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_PREFERENCES_EDITOR 1
// wxFont::AddPrivateFont() allows to use fonts not installed on the system by
// loading them from font files during run-time.
//
// Default is 1 except under Unix where it will be turned off by configure if
// the required libraries are not available or not new enough.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it and
// want to avoid extra dependencies under Linux, for example).
#define wxUSE_PRIVATE_FONTS 1
// wxRichToolTip is a customizable tooltip class which has more functionality
// than the stock (but native, unlike this class) wxToolTip.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely set to 0 if you don't need it)
#define wxUSE_RICHTOOLTIP 1
// Use wxSashWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SASH 1
// Use wxSplitterWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SPLITTER 1
// Use wxToolTip and wxWindow::Set/GetToolTip() methods.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLTIPS 1
// wxValidator class and related methods
#define wxUSE_VALIDATORS 1
// Use reference counted ID management: this means that wxWidgets will track
// the automatically allocated ids (those used when you use wxID_ANY when
// creating a window, menu or toolbar item &c) instead of just supposing that
// the program never runs out of them. This is mostly useful only under wxMSW
// where the total ids range is limited to SHRT_MIN..SHRT_MAX and where
// long-running programs can run into problems with ids reuse without this. On
// the other platforms, where the ids have the full int range, this shouldn't
// be necessary.
#ifdef __WXMSW__
#define wxUSE_AUTOID_MANAGEMENT 1
#else
#define wxUSE_AUTOID_MANAGEMENT 0
#endif
// ----------------------------------------------------------------------------
// common dialogs
// ----------------------------------------------------------------------------
// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
// file selector, printer dialog). Switching this off also switches off the
// printing architecture and interactive wxPrinterDC.
//
// Default is 1
//
// Recommended setting: 1 (unless it really doesn't work)
#define wxUSE_COMMON_DIALOGS 1
// wxBusyInfo displays window with message when app is busy. Works in same way
// as wxBusyCursor
#define wxUSE_BUSYINFO 1
// Use single/multiple choice dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_CHOICEDLG 1
// Use colour picker dialog
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_COLOURDLG 1
// wxDirDlg class for getting a directory name from user
#define wxUSE_DIRDLG 1
// TODO: setting to choose the generic or native one
// Use file open/save dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in many places in the library itself)
#define wxUSE_FILEDLG 1
// Use find/replace dialogs.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely set to 0)
#define wxUSE_FINDREPLDLG 1
// Use font picker dialog
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_FONTDLG 1
// Use wxMessageDialog and wxMessageBox.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_MSGDLG 1
// progress dialog class for lengthy operations
#define wxUSE_PROGRESSDLG 1
// Set to 0 to disable the use of the native progress dialog (currently only
// available under MSW and suffering from some bugs there, hence this option).
#define wxUSE_NATIVE_PROGRESSDLG 1
// support for startup tips (wxShowTip &c)
#define wxUSE_STARTUP_TIPS 1
// text entry dialog and wxGetTextFromUser function
#define wxUSE_TEXTDLG 1
// number entry dialog
#define wxUSE_NUMBERDLG 1
// splash screen class
#define wxUSE_SPLASH 1
// wizards
#define wxUSE_WIZARDDLG 1
// Compile in wxAboutBox() function showing the standard "About" dialog.
//
// Default is 1
//
// Recommended setting: 1 but can be set to 0 to save some space if you don't
// use this function
#define wxUSE_ABOUTDLG 1
// wxFileHistory class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FILE_HISTORY 1
// ----------------------------------------------------------------------------
// Metafiles support
// ----------------------------------------------------------------------------
// Windows supports the graphics format known as metafile which, though not
// portable, is widely used under Windows and so is supported by wxWidgets
// (under Windows only, of course). Both the so-called "Window MetaFiles" or
// WMFs, and "Enhanced MetaFiles" or EMFs are supported in wxWin and, by
// default, EMFs will be used. This may be changed by setting
// wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting wxUSE_ENH_METAFILE to 0.
// You may also set wxUSE_METAFILE to 0 to not compile in any metafile
// related classes at all.
//
// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
//
// Recommended setting: default or 0 for everything for portable programs.
#define wxUSE_METAFILE 1
#define wxUSE_ENH_METAFILE 1
#define wxUSE_WIN_METAFILES_ALWAYS 0
// ----------------------------------------------------------------------------
// Big GUI components
// ----------------------------------------------------------------------------
// Set to 0 to disable MDI support.
//
// Requires wxUSE_NOTEBOOK under platforms other than MSW.
//
// Default is 1.
//
// Recommended setting: 1, can be safely set to 0.
#define wxUSE_MDI 1
// Set to 0 to disable document/view architecture
#define wxUSE_DOC_VIEW_ARCHITECTURE 1
// Set to 0 to disable MDI document/view architecture
//
// Requires wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 1
// Set to 0 to disable print/preview architecture code
#define wxUSE_PRINTING_ARCHITECTURE 1
// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
// much more.
//
// Default is 1.
//
// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
// smaller library.
#define wxUSE_HTML 1
// Setting wxUSE_GLCANVAS to 1 enables OpenGL support. You need to have OpenGL
// headers and libraries to be able to compile the library with wxUSE_GLCANVAS
// set to 1 and, under Windows, also to add opengl32.lib and glu32.lib to the
// list of libraries used to link your application (although this is done
// implicitly for Microsoft Visual C++ users).
//
// Default is 1.
//
// Recommended setting: 1 if you intend to use OpenGL, can be safely set to 0
// otherwise.
#define wxUSE_GLCANVAS 1
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 if you want compile a
// smaller library.
#define wxUSE_RICHTEXT 1
// ----------------------------------------------------------------------------
// Data transfer
// ----------------------------------------------------------------------------
// Use wxClipboard class for clipboard copy/paste.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CLIPBOARD 1
// Use wxDataObject and related classes. Needed for clipboard and OLE drag and
// drop
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DATAOBJ 1
// Use wxDropTarget and wxDropSource classes for drag and drop (this is
// different from "built in" drag and drop in wxTreeCtrl which is always
// available). Requires wxUSE_DATAOBJ.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DRAG_AND_DROP 1
// Use wxAccessible for enhanced and customisable accessibility.
// Depends on wxUSE_OLE on MSW.
//
// Default is 1 on MSW, 0 elsewhere.
//
// Recommended setting (at present): 1 (MSW-only)
#ifdef __WXMSW__
#define wxUSE_ACCESSIBILITY 1
#else
#define wxUSE_ACCESSIBILITY 0
#endif
// ----------------------------------------------------------------------------
// miscellaneous settings
// ----------------------------------------------------------------------------
// wxSingleInstanceChecker class allows to verify at startup if another program
// instance is running.
//
// Default is 1
//
// Recommended setting: 1 (the class is tiny, disabling it won't save much
// space)
#define wxUSE_SNGLINST_CHECKER 1
#define wxUSE_DRAGIMAGE 1
#define wxUSE_IPC 1
// 0 for no interprocess comms
#define wxUSE_HELP 1
// 0 for no help facility
// Should we use MS HTML help for wxHelpController? If disabled, neither
// wxCHMHelpController nor wxBestHelpController are available.
//
// Default is 1 under MSW, 0 is always used for the other platforms.
//
// Recommended setting: 1, only set to 0 if you have trouble compiling
// wxCHMHelpController (could be a problem with really ancient compilers)
#define wxUSE_MS_HTML_HELP 1
// Use wxHTML-based help controller?
#define wxUSE_WXHTML_HELP 1
#define wxUSE_CONSTRAINTS 1
// 0 for no window layout constraint system
#define wxUSE_SPLINES 1
// 0 for no splines
#define wxUSE_MOUSEWHEEL 1
// Include mouse wheel support
// Compile wxUIActionSimulator class?
#define wxUSE_UIACTIONSIMULATOR 1
// ----------------------------------------------------------------------------
// wxDC classes for various output formats
// ----------------------------------------------------------------------------
// Set to 1 for PostScript device context.
#define wxUSE_POSTSCRIPT 0
// Set to 1 to use font metric files in GetTextExtent
#define wxUSE_AFM_FOR_POSTSCRIPT 1
// Set to 1 to compile in support for wxSVGFileDC, a wxDC subclass which allows
// to create files in SVG (Scalable Vector Graphics) format.
#define wxUSE_SVG 1
// Should wxDC provide SetTransformMatrix() and related methods?
//
// Default is 1 but can be set to 0 if this functionality is not used. Notice
// that currently wxMSW, wxGTK3 support this for wxDC and all platforms support
// this for wxGCDC so setting this to 0 doesn't change much if neither of these
// is used (although it will still save a few bytes probably).
//
// Recommended setting: 1.
#define wxUSE_DC_TRANSFORM_MATRIX 1
// ----------------------------------------------------------------------------
// image format support
// ----------------------------------------------------------------------------
// wxImage supports many different image formats which can be configured at
// compile-time. BMP is always supported, others are optional and can be safely
// disabled if you don't plan to use images in such format sometimes saving
// substantial amount of code in the final library.
//
// Some formats require an extra library which is included in wxWin sources
// which is mentioned if it is the case.
// Set to 1 for wxImage support (recommended).
#define wxUSE_IMAGE 1
// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
#define wxUSE_LIBPNG 1
// Set to 1 for JPEG format support (requires libjpeg)
#define wxUSE_LIBJPEG 1
// Set to 1 for TIFF format support (requires libtiff)
#define wxUSE_LIBTIFF 1
// Set to 1 for TGA format support (loading only)
#define wxUSE_TGA 1
// Set to 1 for GIF format support
#define wxUSE_GIF 1
// Set to 1 for PNM format support
#define wxUSE_PNM 1
// Set to 1 for PCX format support
#define wxUSE_PCX 1
// Set to 1 for IFF format support (Amiga format)
#define wxUSE_IFF 0
// Set to 1 for XPM format support
#define wxUSE_XPM 1
// Set to 1 for MS Icons and Cursors format support
#define wxUSE_ICO_CUR 1
// Set to 1 to compile in wxPalette class
#define wxUSE_PALETTE 1
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
/* --- end common options --- */
#endif // _WX_SETUP_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/font.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/font.h
// Purpose: wxFont class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONT_H_
#define _WX_FONT_H_
#if __WXMOTIF20__ && !__WXLESSTIF__
#define wxMOTIF_USE_RENDER_TABLE 1
#else
#define wxMOTIF_USE_RENDER_TABLE 0
#endif
#define wxMOTIF_NEW_FONT_HANDLING wxMOTIF_USE_RENDER_TABLE
class wxXFont;
// Font
class WXDLLIMPEXP_CORE wxFont : public wxFontBase
{
public:
// ctors and such
wxFont() { }
wxFont(const wxFontInfo& info);
wxFont(const wxString& nativeFontInfoString);
wxFont(const wxNativeFontInfo& info);
wxFont(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(size, family, style, weight, underlined, face, encoding);
}
wxFont(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(10, family, style, weight, underlined, face, encoding);
SetPixelSize(pixelSize);
}
bool Create(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
// wxMOTIF-specific
bool Create(const wxString& fontname,
wxFontEncoding fontenc = wxFONTENCODING_DEFAULT);
bool Create(const wxNativeFontInfo& fontinfo);
virtual ~wxFont();
// implement base class pure virtuals
virtual float GetFractionalPointSize() const;
virtual wxFontStyle GetStyle() const;
virtual int GetNumericWeight() const;
virtual bool GetUnderlined() const;
virtual wxString GetFaceName() const;
virtual wxFontEncoding GetEncoding() const;
virtual const wxNativeFontInfo *GetNativeFontInfo() const;
virtual void SetFractionalPointSize(float pointSize);
virtual void SetFamily(wxFontFamily family);
virtual void SetStyle(wxFontStyle style);
virtual void SetNumericWeight(int weight);
virtual bool SetFaceName(const wxString& faceName);
virtual void SetUnderlined(bool underlined);
virtual void SetEncoding(wxFontEncoding encoding);
wxDECLARE_COMMON_FONT_METHODS();
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants")
wxFont(int size,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(size, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight, underlined, face, encoding);
}
// Implementation
// Find an existing, or create a new, XFontStruct
// based on this wxFont and the given scale. Append the
// font to list in the private data for future reference.
// TODO This is a fairly basic implementation, that doesn't
// allow for different facenames, and also doesn't do a mapping
// between 'standard' facenames (e.g. Arial, Helvetica, Times Roman etc.)
// and the fonts that are available on a particular system.
// Maybe we need to scan the user's machine to build up a profile
// of the fonts and a mapping file.
// Return font struct, and optionally the Motif font list
wxXFont *GetInternalFont(double scale = 1.0,
WXDisplay* display = NULL) const;
// These two are helper functions for convenient access of the above.
#if wxMOTIF_USE_RENDER_TABLE
WXFontSet GetFontSet(double scale, WXDisplay* display = NULL) const;
WXRenderTable GetRenderTable(WXDisplay* display) const;
#else // if !wxMOTIF_USE_RENDER_TABLE
WXFontStructPtr GetFontStruct(double scale = 1.0,
WXDisplay* display = NULL) const;
WXFontList GetFontList(double scale = 1.0,
WXDisplay* display = NULL) const;
#endif // !wxMOTIF_USE_RENDER_TABLE
// returns either a XmFontList or XmRenderTable, depending
// on Motif version
WXFontType GetFontType(WXDisplay* display) const;
// like the function above but does a copy for XmFontList
WXFontType GetFontTypeC(WXDisplay* display) const;
static WXString GetFontTag();
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual void DoSetNativeFontInfo( const wxNativeFontInfo& info );
virtual wxFontFamily DoGetFamily() const;
void Unshare();
private:
wxDECLARE_DYNAMIC_CLASS(wxFont);
};
#endif // _WX_FONT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/app.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/app.h
// Purpose: wxApp class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_APP_H_
#define _WX_APP_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/event.h"
#include "wx/hashmap.h"
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxFrame;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxApp;
class WXDLLIMPEXP_FWD_CORE wxKeyEvent;
class WXDLLIMPEXP_FWD_BASE wxLog;
class WXDLLIMPEXP_FWD_CORE wxEventLoop;
class WXDLLIMPEXP_FWD_CORE wxXVisualInfo;
class WXDLLIMPEXP_FWD_CORE wxPerDisplayData;
// ----------------------------------------------------------------------------
// the wxApp class for Motif - see wxAppBase for more details
// ----------------------------------------------------------------------------
WX_DECLARE_VOIDPTR_HASH_MAP( wxPerDisplayData*, wxPerDisplayDataMap );
class WXDLLIMPEXP_CORE wxApp : public wxAppBase
{
wxDECLARE_DYNAMIC_CLASS(wxApp);
public:
wxApp();
virtual ~wxApp();
// override base class (pure) virtuals
// -----------------------------------
virtual int MainLoop();
virtual void Exit();
virtual void WakeUpIdle(); // implemented in motif/evtloop.cpp
// implementation from now on
// --------------------------
protected:
bool m_showOnInit;
public:
// Implementation
virtual bool Initialize(int& argc, wxChar **argv);
virtual void CleanUp();
// Motif-specific
WXAppContext GetAppContext() const { return m_appContext; }
WXWidget GetTopLevelWidget();
WXWidget GetTopLevelRealizedWidget();
WXColormap GetMainColormap(WXDisplay* display);
WXDisplay* GetInitialDisplay() const { return m_initialDisplay; }
void SetTopLevelWidget(WXDisplay* display, WXWidget widget);
void SetTopLevelRealizedWidget(WXDisplay* display,
WXWidget widget);
// This handler is called when a property change event occurs
virtual void HandlePropertyChange(WXEvent *event);
wxXVisualInfo* GetVisualInfo(WXDisplay* display);
virtual void* GetXVisualInfo() { return NULL; }
private:
// Motif-specific
WXAppContext m_appContext;
WXColormap m_mainColormap;
WXDisplay* m_initialDisplay;
wxPerDisplayDataMap* m_perDisplayData;
};
#endif
// _WX_APP_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dcmemory.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dcmemory.h
// Purpose: wxMemoryDCImpl class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCMEMORY_H_
#define _WX_DCMEMORY_H_
#include "wx/motif/dcclient.h"
class WXDLLIMPEXP_CORE wxMemoryDCImpl : public wxWindowDCImpl
{
public:
wxMemoryDCImpl(wxMemoryDC *owner) : wxWindowDCImpl(owner) { Init(); }
wxMemoryDCImpl(wxMemoryDC *owner, wxBitmap& bitmap)
: wxWindowDCImpl(owner)
{
Init();
DoSelect(bitmap);
}
wxMemoryDCImpl(wxMemoryDC *owner, wxDC *dc);
virtual ~wxMemoryDCImpl();
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoSelect(const wxBitmap& bitmap);
private:
friend class wxPaintDC;
void Init();
wxBitmap m_bitmap;
wxDECLARE_DYNAMIC_CLASS(wxMemoryDCImpl);
};
#endif
// _WX_DCMEMORY_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/toplevel.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/toplevel.h
// Purpose: wxTopLevelWindow Motif implementation
// Author: Mattia Barbon
// Modified by:
// Created: 12/10/2002
// Copyright: (c) Mattia Barbon
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __MOTIFTOPLEVELH__
#define __MOTIFTOPLEVELH__
class WXDLLIMPEXP_CORE wxTopLevelWindowMotif : public wxTopLevelWindowBase
{
public:
wxTopLevelWindowMotif() { Init(); }
wxTopLevelWindowMotif( wxWindow* parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr )
{
Init();
Create( parent, id, title, pos, size, style, name );
}
bool Create( wxWindow* parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr );
virtual ~wxTopLevelWindowMotif();
virtual bool ShowFullScreen( bool show, long style = wxFULLSCREEN_ALL );
virtual bool IsFullScreen() const;
virtual void Maximize(bool maximize = true);
virtual void Restore();
virtual void Iconize(bool iconize = true);
virtual bool IsMaximized() const;
virtual bool IsIconized() const;
virtual void Raise();
virtual void Lower();
virtual wxString GetTitle() const { return m_title; }
virtual void SetTitle( const wxString& title ) { m_title = title; }
virtual bool SetShape( const wxRegion& region );
WXWidget GetShellWidget() const;
protected:
// common part of all constructors
void Init();
// common part of wxDialog/wxFrame destructors
void PreDestroy();
virtual void DoGetPosition(int* x, int* y) const;
virtual void DoSetSizeHints(int minW, int minH,
int maxW, int maxH,
int incW, int incH);
private:
// really create the Motif widget for TLW
virtual bool XmDoCreateTLW(wxWindow* parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name) = 0;
wxString m_title;
};
#endif // __MOTIFTOPLEVELH__
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/stattext.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/stattext.h
// Purpose: wxStaticText class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATTEXT_H_
#define _WX_STATTEXT_H_
class WXDLLIMPEXP_CORE wxStaticText: public wxStaticTextBase
{
wxDECLARE_DYNAMIC_CLASS(wxStaticText);
public:
wxStaticText() { }
wxStaticText(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr);
// implementation
// --------------
// operations
virtual bool ProcessCommand(wxCommandEvent& WXUNUSED(event))
{
return false;
}
virtual void SetLabel(const wxString& label);
// Get the widget that corresponds to the label
// (for font setting, label setting etc.)
virtual WXWidget GetLabelWidget() const
{ return m_labelWidget; }
virtual void DoSetLabel(const wxString& str);
virtual wxString DoGetLabel() const;
virtual wxSize DoGetBestSize() const;
protected:
WXWidget m_labelWidget;
};
#endif
// _WX_STATTEXT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/radiobut.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/radiobut.h
// Purpose: wxRadioButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBUT_H_
#define _WX_RADIOBUT_H_
class WXDLLIMPEXP_CORE wxRadioButton: public wxControl
{
wxDECLARE_DYNAMIC_CLASS(wxRadioButton);
public:
wxRadioButton();
virtual ~wxRadioButton() { RemoveFromCycle(); }
inline wxRadioButton(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr)
{
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 = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr);
virtual void SetValue(bool val);
virtual bool GetValue() const ;
void Command(wxCommandEvent& event);
// Implementation
virtual void ChangeBackgroundColour();
// *this function is an implementation detail*
// clears the selection in the radiobuttons in the cycle
// and returns the old selection (if any)
wxRadioButton* ClearSelections();
protected:
virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
private:
wxRadioButton* AddInCycle(wxRadioButton* cycle);
void RemoveFromCycle();
wxRadioButton* NextInCycle() { return m_cycle; }
wxRadioButton *m_cycle;
};
#endif
// _WX_RADIOBUT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/radiobox.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/radiobox.h
// Purpose: wxRadioBox class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_RADIOBOX_H_
#define _WX_MOTIF_RADIOBOX_H_
#ifndef wxWIDGET_ARRAY_DEFINED
#define wxWIDGET_ARRAY_DEFINED
#include "wx/dynarray.h"
WX_DEFINE_ARRAY_PTR(WXWidget, wxWidgetArray);
#endif // wxWIDGET_ARRAY_DEFINED
#include "wx/arrstr.h"
class WXDLLIMPEXP_CORE wxRadioBox : public wxControl, public wxRadioBoxBase
{
public:
wxRadioBox() { Init(); }
wxRadioBox(wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0, long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
Create(parent, id, title, pos, size, n, choices,
majorDim, style, val, name);
}
wxRadioBox(wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0, long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
Create(parent, id, title, pos, size, choices,
majorDim, style, val, name);
}
virtual ~wxRadioBox();
bool Create(wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0, long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0, long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
// Enabling
virtual bool Enable(bool enable = true);
virtual bool Enable(unsigned int item, bool enable = true);
virtual bool IsItemEnabled(unsigned int WXUNUSED(n)) const
{
/* TODO */
return true;
}
// Showing
virtual bool Show(bool show = true);
virtual bool Show(unsigned int item, bool show = true);
virtual bool IsItemShown(unsigned int WXUNUSED(n)) const
{
/* TODO */
return true;
}
virtual void SetSelection(int n);
int GetSelection() const;
virtual void SetString(unsigned int item, const wxString& label);
virtual wxString GetString(unsigned int item) const;
virtual wxString GetStringSelection() const;
virtual bool SetStringSelection(const wxString& s);
virtual unsigned int GetCount() const { return m_noItems; } ;
void Command(wxCommandEvent& event);
int GetNumberOfRowsOrCols() const { return m_noRowsOrCols; }
void SetNumberOfRowsOrCols(int n) { m_noRowsOrCols = n; }
// Implementation
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
const wxWidgetArray& GetRadioButtons() const { return m_radioButtons; }
void SetSel(int i) { m_selectedButton = i; }
virtual WXWidget GetLabelWidget() const { return m_labelWidget; }
protected:
virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
unsigned int m_noItems;
int m_noRowsOrCols;
int m_selectedButton;
wxWidgetArray m_radioButtons;
WXWidget m_labelWidget;
wxArrayString m_radioButtonLabels;
private:
void Init();
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
};
#endif // _WX_MOTIF_RADIOBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/checklst.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/checklst.h
// Purpose: wxCheckListBox class - a listbox with checkable items
// Note: this is an optional class.
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHECKLST_H_
#define _WX_CHECKLST_H_
#include "wx/listbox.h"
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
wxDECLARE_DYNAMIC_CLASS(wxCheckListBox);
public:
// ctors
wxCheckListBox();
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// items may be checked
bool IsChecked(unsigned int uiIndex) const;
void Check(unsigned int uiIndex, bool bCheck = true);
// override base class functions
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual int FindString(const wxString& s, bool bCase = false) const;
virtual void SetString(unsigned int n, const wxString& s);
virtual wxString GetString(unsigned int n) const;
private:
void DoToggleItem( int item, int x );
private:
wxDECLARE_EVENT_TABLE();
};
#endif
// _WX_CHECKLST_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/listbox.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/listbox.h
// Purpose: wxListBox class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTBOX_H_
#define _WX_LISTBOX_H_
#include "wx/ctrlsub.h"
#include "wx/clntdata.h"
// forward decl for GetSelections()
class WXDLLIMPEXP_FWD_BASE wxArrayInt;
// List box item
class WXDLLIMPEXP_CORE wxListBox: public wxListBoxBase
{
wxDECLARE_DYNAMIC_CLASS(wxListBox);
public:
wxListBox();
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// implementation of wxControlWithItems
virtual unsigned int GetCount() const;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual int GetSelection() const;
virtual void DoDeleteOneItem(unsigned int n);
virtual int FindString(const wxString& s, bool bCase = false) const;
virtual void DoClear();
virtual void SetString(unsigned int n, const wxString& s);
virtual wxString GetString(unsigned int n) const;
// implementation of wxListBoxbase
virtual void DoSetSelection(int n, bool select);
virtual void DoSetFirstItem(int n);
virtual int GetSelections(wxArrayInt& aSelections) const;
virtual bool IsSelected(int n) const;
// For single or multiple choice list item
void Command(wxCommandEvent& event);
// Implementation
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
WXWidget GetTopWidget() const;
#if wxUSE_CHECKLISTBOX
virtual void DoToggleItem(int WXUNUSED(item), int WXUNUSED(x)) {}
#endif
protected:
virtual wxSize DoGetBestSize() const;
unsigned int m_noItems;
private:
void SetSelectionPolicy();
};
#endif
// _WX_LISTBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/textentry.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/textentry.h
// Purpose: wxMotif-specific wxTextEntry implementation
// Author: Vadim Zeitlin
// Created: 2007-11-05
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_TEXTENTRY_H_
#define _WX_MOTIF_TEXTENTRY_H_
// ----------------------------------------------------------------------------
// wxTextEntry wraps XmTextXXX() methods suitable for single-line controls
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTextEntry : public wxTextEntryBase
{
public:
wxTextEntry() { }
// implement wxTextEntryBase pure virtual methods
virtual void WriteText(const wxString& text);
virtual void Replace(long from, long to, const wxString& value);
virtual void Remove(long from, long to);
virtual void Copy();
virtual void Cut();
virtual void Paste();
virtual void Undo();
virtual void Redo();
virtual bool CanUndo() const;
virtual bool CanRedo() const;
virtual void SetInsertionPoint(long pos);
virtual long GetInsertionPoint() const;
virtual long GetLastPosition() const;
virtual void SetSelection(long from, long to);
virtual void GetSelection(long *from, long *to) const;
virtual bool IsEditable() const;
virtual void SetEditable(bool editable);
protected:
virtual wxString DoGetValue() const;
// translate wx text position (which may be -1 meaning "last one") to a
// valid Motif text position
long GetMotifPos(long pos) const;
private:
// implement this to return the associated xmTextWidgetClass widget
virtual WXWidget GetTextWidget() const = 0;
};
#endif // _WX_MOTIF_TEXTENTRY_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/filedlg.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/filedlg.h
// Purpose: wxFileDialog class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FILEDLG_H_
#define _WX_FILEDLG_H_
//-------------------------------------------------------------------------
// wxFileDialog
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDialog: public wxFileDialogBase
{
wxDECLARE_DYNAMIC_CLASS(wxFileDialog);
public:
// For Motif
static wxString m_fileSelectorAnswer;
static bool m_fileSelectorReturned;
public:
wxFileDialog(wxWindow *parent,
const wxString& message = wxFileSelectorPromptStr,
const wxString& defaultDir = wxEmptyString,
const wxString& defaultFile = wxEmptyString,
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = wxFD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& sz = wxDefaultSize,
const wxString& name = wxFileDialogNameStr);
virtual int ShowModal();
};
#endif // _WX_FILEDLG_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/spinbutt.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/spinbutt.h
// Purpose: wxSpinButton class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SPINBUTT_H_
#define _WX_SPINBUTT_H_
class WXDLLIMPEXP_FWD_CORE wxArrowButton; // internal
class WXDLLIMPEXP_CORE wxSpinButton : public wxSpinButtonBase
{
wxDECLARE_DYNAMIC_CLASS(wxSpinButton);
public:
wxSpinButton() : m_up( 0 ), m_down( 0 ), m_pos( 0 ) { }
wxSpinButton(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL,
const wxString& name = "wxSpinButton")
: m_up( 0 ),
m_down( 0 ),
m_pos( 0 )
{
Create(parent, id, pos, size, style, name);
}
virtual ~wxSpinButton();
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL,
const wxString& name = "wxSpinButton");
// accessors
int GetValue() const;
int GetMin() const { return m_min; }
int GetMax() const { return m_max; }
// operations
void SetValue(int val);
void SetRange(int minVal, int maxVal);
// Implementation
virtual void Command(wxCommandEvent& event)
{ (void)ProcessCommand(event); }
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
public:
// implementation detail
void Increment( int delta );
private:
virtual void DoSetSize(int x, int y, int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual wxSize DoGetBestSize() const;
wxArrowButton* m_up;
wxArrowButton* m_down;
int m_pos;
};
#endif
// _WX_SPINBUTT_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/statbmp.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/statbmp.h
// Purpose: wxStaticBitmap class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATBMP_H_
#define _WX_STATBMP_H_
#include "wx/motif/bmpmotif.h"
#include "wx/icon.h"
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
public:
wxStaticBitmap() { }
virtual ~wxStaticBitmap();
wxStaticBitmap(wxWindow *parent, wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual void SetBitmap(const wxBitmap& bitmap);
virtual bool ProcessCommand(wxCommandEvent& WXUNUSED(event))
{
return false;
}
wxBitmap GetBitmap() const { return m_messageBitmap; }
// for compatibility with wxMSW
wxIcon GetIcon() const
{
// don't use wxDynamicCast, icons and bitmaps are really the same thing
return *(wxIcon*)&m_messageBitmap;
}
// for compatibility with wxMSW
void SetIcon(const wxIcon& icon)
{
SetBitmap( icon );
}
// Implementation
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
protected:
void DoSetBitmap();
protected:
wxBitmap m_messageBitmap;
wxBitmap m_messageBitmapOriginal;
wxBitmapCache m_bitmapCache;
};
#endif
// _WX_STATBMP_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/slider.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/slider.h
// Purpose: wxSlider class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SLIDER_H_
#define _WX_SLIDER_H_
#include "wx/control.h"
// Slider
class WXDLLIMPEXP_CORE wxSlider: public wxSliderBase
{
wxDECLARE_DYNAMIC_CLASS(wxSlider);
public:
wxSlider();
wxSlider(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr)
{
Create(parent, id, value, minValue, maxValue, pos, size, style, validator, name);
}
virtual ~wxSlider();
bool Create(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
virtual int GetValue() const ;
virtual void SetValue(int);
void SetRange(int minValue, int maxValue);
inline int GetMin() const { return m_rangeMin; }
inline int GetMax() const { return m_rangeMax; }
// For trackbars only
void SetPageSize(int pageSize);
int GetPageSize() const ;
void SetLineSize(int lineSize);
int GetLineSize() const ;
void SetThumbLength(int len) ;
int GetThumbLength() const ;
void Command(wxCommandEvent& event);
protected:
int m_rangeMin;
int m_rangeMax;
int m_pageSize;
int m_lineSize;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
private:
wxDECLARE_EVENT_TABLE();
};
#endif
// _WX_SLIDER_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/menuitem.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/menuitem.h
// Purpose: wxMenuItem class
// Author: Vadim Zeitlin
// Modified by:
// Created: 11.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_MENUITEM_H
#define _WX_MOTIF_MENUITEM_H
#include "wx/bitmap.h"
class WXDLLIMPEXP_FWD_CORE wxMenuBar;
// ----------------------------------------------------------------------------
// wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuItem : public wxMenuItemBase
{
public:
// ctor & dtor
wxMenuItem(wxMenu *parentMenu = NULL,
int id = wxID_SEPARATOR,
const wxString& text = wxEmptyString,
const wxString& help = wxEmptyString,
wxItemKind kind = wxITEM_NORMAL,
wxMenu *subMenu = NULL);
virtual ~wxMenuItem();
// accessors (some more are inherited from wxOwnerDrawn or are below)
virtual void SetItemLabel(const wxString& label);
virtual void Enable(bool enable = true);
virtual void Check(bool check = true);
// included SetBitmap and GetBitmap as copied from the GTK include file
// I'm not sure if this works but it silences the linker in the
// menu sample.
// JJ
virtual void SetBitmap(const wxBitmap& bitmap) { m_bitmap = bitmap; }
virtual const wxBitmap& GetBitmap() const { return m_bitmap; }
// implementation from now on
void CreateItem (WXWidget menu, wxMenuBar * menuBar, wxMenu * topMenu,
size_t index);
void DestroyItem(bool full);
WXWidget GetButtonWidget() const { return m_buttonWidget; }
wxMenuBar* GetMenuBar() const { return m_menuBar; }
void SetMenuBar(wxMenuBar* menuBar) { m_menuBar = menuBar; }
wxMenu* GetTopMenu() const { return m_topMenu; }
void SetTopMenu(wxMenu* menu) { m_topMenu = menu; }
private:
WXWidget m_buttonWidget;
wxMenuBar* m_menuBar;
wxMenu* m_topMenu; // Top-level menu e.g. popup-menu
wxBitmap m_bitmap; // Bitmap for menuitem, if any
wxDECLARE_DYNAMIC_CLASS(wxMenuItem);
};
#endif // _WX_MOTIF_MENUITEM_H
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/toolbar.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/toolbar.h
// Purpose: wxToolBar class
// Author: Julian Smart
// Modified by: 13.12.99 by VZ during toolbar classes reorganization
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOOLBAR_H_
#define _WX_TOOLBAR_H_
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
// ctors and dtor
wxToolBar() { Init(); }
wxToolBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr);
virtual ~wxToolBar();
// override/implement base class virtuals
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const;
virtual bool Realize();
// implementation from now on
// find tool by widget
wxToolBarToolBase *FindToolByWidget(WXWidget w) const;
private:
// common part of all ctors
void Init();
// implement base class pure virtuals
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool);
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool);
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable);
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle);
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle);
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled,
wxItemKind kind,
wxObject *clientData,
const wxString& shortHelp,
const wxString& longHelp);
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label);
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
private:
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
};
#endif
// _WX_TOOLBAR_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/gauge.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/gauge.h
// Purpose: wxGauge class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GAUGE_H_
#define _WX_GAUGE_H_
// Group box
class WXDLLIMPEXP_CORE wxGauge : public wxGaugeBase
{
wxDECLARE_DYNAMIC_CLASS(wxGauge);
public:
inline wxGauge() { m_rangeMax = 0; m_gaugePos = 0; }
inline wxGauge(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr)
{
Create(parent, id, range, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr);
void SetRange(int r);
void SetValue(int pos);
int GetRange() const ;
int GetValue() const ;
virtual void Command(wxCommandEvent& WXUNUSED(event)) {} ;
private:
virtual wxSize DoGetBestSize() const;
virtual void DoMoveWindow(int x, int y, int width, int height);
};
#endif
// _WX_GAUGE_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/menu.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/menu.h
// Purpose: wxMenu, wxMenuBar classes
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_MENU_H_
#define _WX_MOTIF_MENU_H_
#include "wx/colour.h"
#include "wx/font.h"
#include "wx/arrstr.h"
class WXDLLIMPEXP_FWD_CORE wxFrame;
// ----------------------------------------------------------------------------
// Menu
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenu : public wxMenuBase
{
public:
// ctors & dtor
wxMenu(const wxString& title, long style = 0)
: wxMenuBase(title, style) { Init(); }
wxMenu(long style = 0) : wxMenuBase(style) { Init(); }
virtual ~wxMenu();
// implement base class virtuals
virtual wxMenuItem* DoAppend(wxMenuItem *item);
virtual wxMenuItem* DoInsert(size_t pos, wxMenuItem *item);
virtual wxMenuItem* DoRemove(wxMenuItem *item);
virtual void Break();
virtual void SetTitle(const wxString& title);
bool ProcessCommand(wxCommandEvent& event);
//// Motif-specific
WXWidget GetButtonWidget() const { return m_buttonWidget; }
void SetButtonWidget(WXWidget buttonWidget) { m_buttonWidget = buttonWidget; }
WXWidget GetMainWidget() const { return m_menuWidget; }
int GetId() const { return m_menuId; }
void SetId(int id) { m_menuId = id; }
void SetMenuBar(wxMenuBar* menuBar) { m_menuBar = menuBar; }
wxMenuBar* GetMenuBar() const { return m_menuBar; }
void CreatePopup(WXWidget logicalParent, int x, int y);
void DestroyPopup();
void ShowPopup(int x, int y);
void HidePopup();
WXWidget CreateMenu(wxMenuBar *menuBar, WXWidget parent, wxMenu *topMenu,
size_t index, const wxString& title = wxEmptyString,
bool isPulldown = false);
// For popups, need to destroy, then recreate menu for a different (or
// possibly same) window, since the parent may change.
void DestroyMenu(bool full);
WXWidget FindMenuItem(int id, wxMenuItem **it = NULL) const;
const wxColour& GetBackgroundColour() const { return m_backgroundColour; }
const wxColour& GetForegroundColour() const { return m_foregroundColour; }
const wxFont& GetFont() const { return m_font; }
void SetBackgroundColour(const wxColour& colour);
void SetForegroundColour(const wxColour& colour);
void SetFont(const wxFont& colour);
void ChangeFont(bool keepOriginalSize = false);
WXWidget GetHandle() const { return m_menuWidget; }
bool IsTearOff() const { return (m_style & wxMENU_TEAROFF) != 0; }
void DestroyWidgetAndDetach();
public:
// Motif-specific data
int m_numColumns;
WXWidget m_menuWidget;
WXWidget m_popupShell; // For holding the popup shell widget
WXWidget m_buttonWidget; // The actual string, so we can grey it etc.
int m_menuId;
wxMenu* m_topLevelMenu ;
bool m_ownedByMenuBar;
wxColour m_foregroundColour;
wxColour m_backgroundColour;
wxFont m_font;
private:
// common code for both constructors:
void Init();
wxDECLARE_DYNAMIC_CLASS(wxMenu);
};
// ----------------------------------------------------------------------------
// Menu Bar
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuBar : public wxMenuBarBase
{
public:
wxMenuBar() { Init(); }
wxMenuBar(long WXUNUSED(style)) { Init(); }
wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style = 0);
wxMenuBar(size_t n, wxMenu *menus[], const wxArrayString& titles, long style = 0);
virtual ~wxMenuBar();
// implement base class (pure) virtuals
// ------------------------------------
virtual bool Append( wxMenu *menu, const wxString &title );
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title);
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title);
virtual wxMenu *Remove(size_t pos);
virtual int FindMenuItem(const wxString& menuString,
const wxString& itemString) const;
virtual wxMenuItem* FindItem( int id, wxMenu **menu = NULL ) const;
virtual void EnableTop( size_t pos, bool flag );
virtual void SetMenuLabel( size_t pos, const wxString& label );
virtual wxString GetMenuLabel( size_t pos ) const;
// implementation only from now on
// -------------------------------
wxFrame* GetMenuBarFrame() const { return m_menuBarFrame; }
void SetMenuBarFrame(wxFrame* frame) { m_menuBarFrame = frame; }
WXWidget GetMainWidget() const { return m_mainWidget; }
void SetMainWidget(WXWidget widget) { m_mainWidget = widget; }
// Create menubar
bool CreateMenuBar(wxFrame* frame);
// Destroy menubar, but keep data structures intact so we can recreate it.
bool DestroyMenuBar();
const wxColour& GetBackgroundColour() const { return m_backgroundColour; }
const wxColour& GetForegroundColour() const { return m_foregroundColour; }
const wxFont& GetFont() const { return m_font; }
virtual bool SetBackgroundColour(const wxColour& colour);
virtual bool SetForegroundColour(const wxColour& colour);
virtual bool SetFont(const wxFont& colour);
void ChangeFont(bool keepOriginalSize = false);
public:
// common part of all ctors
void Init();
wxArrayString m_titles;
wxFrame *m_menuBarFrame;
WXWidget m_mainWidget;
wxColour m_foregroundColour;
wxColour m_backgroundColour;
wxFont m_font;
wxDECLARE_DYNAMIC_CLASS(wxMenuBar);
};
#endif // _WX_MOTIF_MENU_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/colour.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/colour.h
// Purpose: wxColour class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COLOUR_H_
#define _WX_COLOUR_H_
#include "wx/object.h"
#include "wx/string.h"
// Colour
class WXDLLIMPEXP_CORE wxColour : public wxColourBase
{
wxDECLARE_DYNAMIC_CLASS(wxColour);
public:
// constructors
// ------------
DEFINE_STD_WXCOLOUR_CONSTRUCTORS
// copy ctors and assignment operators
wxColour( const wxColour& col );
wxColour& operator = ( const wxColour& col );
// dtor
virtual ~wxColour();
// accessors
virtual bool IsOk() const {return m_isInit; }
unsigned char Red() const { return m_red; }
unsigned char Green() const { return m_green; }
unsigned char Blue() const { return m_blue; }
WXPixel GetPixel() const { return m_pixel; }
void SetPixel(WXPixel pixel) { m_pixel = pixel; m_isInit = true; }
inline bool operator == (const wxColour& colour) const { return (m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue); }
inline bool operator != (const wxColour& colour) const { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); }
// Allocate a colour, or nearest colour, using the given display.
// If realloc is true, ignore the existing pixel, otherwise just return
// the existing one.
// Returns the allocated pixel.
// TODO: can this handle mono displays? If not, we should have an extra
// flag to specify whether this should be black or white by default.
WXPixel AllocColour(WXDisplay* display, bool realloc = false);
protected:
// Helper function
void Init();
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
private:
bool m_isInit;
unsigned char m_red;
unsigned char m_blue;
unsigned char m_green;
public:
WXPixel m_pixel;
};
#endif
// _WX_COLOUR_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/checkbox.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/checkbox.h
// Purpose: wxCheckBox class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHECKBOX_H_
#define _WX_CHECKBOX_H_
// Checkbox item (single checkbox)
class WXDLLIMPEXP_CORE wxCheckBox: public wxCheckBoxBase
{
wxDECLARE_DYNAMIC_CLASS(wxCheckBox);
public:
inline wxCheckBox() { Init(); }
inline wxCheckBox(wxWindow *parent, wxWindowID id, const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
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 = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
virtual void SetValue(bool);
virtual bool GetValue() const ;
virtual void Command(wxCommandEvent& event);
// Implementation
virtual void ChangeBackgroundColour();
private:
// common part of all constructors
void Init()
{
m_evtType = wxEVT_CHECKBOX;
}
virtual void DoSet3StateValue(wxCheckBoxState state);
virtual wxCheckBoxState DoGet3StateValue() const;
// public for the callback
public:
// either wxEVT_CHECKBOX or ..._TOGGLEBUTTON
wxEventType m_evtType;
};
#endif
// _WX_CHECKBOX_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/bmpbuttn.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/bmpbuttn.h
// Purpose: wxBitmapButton class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BMPBUTTN_H_
#define _WX_BMPBUTTN_H_
#include "wx/motif/bmpmotif.h"
#define wxDEFAULT_BUTTON_MARGIN 4
class WXDLLIMPEXP_CORE wxBitmapButton: public wxBitmapButtonBase
{
public:
wxBitmapButton();
virtual ~wxBitmapButton();
wxBitmapButton(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
// Implementation
virtual void ChangeBackgroundColour();
protected:
virtual wxSize DoGetBestSize() const;
virtual void DoSetBitmap(const wxBitmap& bitmap, State which);
virtual void OnSetBitmap();
// original bitmaps may be different from the ones we were initialized with
// if they were changed to reflect button background colour
wxBitmap m_bitmapsOriginal[State_Max];
wxBitmapCache m_bitmapCache;
WXPixmap m_insensPixmap;
wxDECLARE_DYNAMIC_CLASS(wxBitmapButton);
};
#endif // _WX_BMPBUTTN_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/private.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/private.h
// Purpose: Private declarations for wxMotif port
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_H_
#define _WX_PRIVATE_H_
#include "wx/defs.h"
#include <X11/Xlib.h>
#include <Xm/Xm.h>
#include "wx/evtloop.h"
class WXDLLIMPEXP_FWD_CORE wxFont;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxSize;
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxColour;
#include "wx/x11/privx.h"
// Put any private declarations here: native Motif types may be used because
// this header is included after Xm/Xm.h
// ----------------------------------------------------------------------------
// convenience macros
// ----------------------------------------------------------------------------
#define wxCHECK_MOTIF_VERSION( major, minor ) \
( XmVersion >= (major) * 1000 + (minor) )
#define wxCHECK_LESSTIF_VERSION( major, minor ) \
( LesstifVersion >= (major) * 1000 + (minor) )
#define wxCHECK_LESSTIF() ( __WXLESSTIF__ )
// some compilers (e.g. Sun CC) give warnings when treating string literals as
// (non const) "char *" but many Motif functions take "char *" parameters which
// are really "const char *" so use this macro to suppress the warnings when we
// know it's ok
#define wxMOTIF_STR(x) const_cast<char *>(x)
// ----------------------------------------------------------------------------
// Miscellaneous functions
// ----------------------------------------------------------------------------
WXWidget wxCreateBorderWidget( WXWidget parent, long style );
// ----------------------------------------------------------------------------
// common callbacks
// ----------------------------------------------------------------------------
// All widgets should have this as their resize proc.
extern void wxWidgetResizeProc(Widget w, XConfigureEvent *event,
String args[], int *num_args);
// For repainting arbitrary windows
void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data),
XEvent *event, char *);
// ----------------------------------------------------------------------------
// we maintain a hash table which contains the mapping from Widget to wxWindow
// corresponding to the window for this widget
// ----------------------------------------------------------------------------
extern void wxDeleteWindowFromTable(Widget w);
extern wxWindow *wxGetWindowFromTable(Widget w);
extern bool wxAddWindowToTable(Widget w, wxWindow *win);
// ----------------------------------------------------------------------------
// wxBitmap related functions
// ----------------------------------------------------------------------------
// Creates a bitmap with transparent areas drawn in the given colour.
wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, const wxColour& colour);
// ----------------------------------------------------------------------------
// key events related functions
// ----------------------------------------------------------------------------
extern char wxFindMnemonic(const char* s);
extern char * wxFindAccelerator (const char *s);
extern XmString wxFindAcceleratorText (const char *s);
// ----------------------------------------------------------------------------
// TranslateXXXEvent() functions - translate Motif event to wxWindow one
// ----------------------------------------------------------------------------
extern bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win,
Widget widget, const XEvent *xevent);
extern bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win,
Widget widget, const XEvent *xevent);
extern void wxDoChangeForegroundColour(WXWidget widget,
wxColour& foregroundColour);
extern void wxDoChangeBackgroundColour(WXWidget widget,
const wxColour& backgroundColour,
bool changeArmColour = false);
extern void wxDoChangeFont(WXWidget widget, const wxFont& font);
extern void wxGetTextExtent(WXDisplay* display, const wxFont& font,
double scale,
const wxString& string, int* width, int* height,
int* ascent, int* descent);
extern void wxGetTextExtent(const wxWindow* window, const wxString& str,
int* width, int* height,
int* ascent, int* descent);
#define wxNO_COLORS 0x00
#define wxBACK_COLORS 0x01
#define wxFORE_COLORS 0x02
extern XColor itemColors[5] ;
#define wxBACK_INDEX 0
#define wxFORE_INDEX 1
#define wxSELE_INDEX 2
#define wxTOPS_INDEX 3
#define wxBOTS_INDEX 4
// ----------------------------------------------------------------------------
// XmString/wxString conversion utilities
// ----------------------------------------------------------------------------
wxString wxXmStringToString( const XmString& xmString );
XmString wxStringToXmString( const char* string );
inline XmString wxStringToXmString( const wxScopedCharBuffer& string )
{ return wxStringToXmString(string.data()); }
inline XmString wxStringToXmString( const wxString& string )
{ return wxStringToXmString((const char*)string.mb_str()); }
// XmString made easy to use in wxWidgets (and has an added benefit of
// cleaning up automatically)
class wxXmString
{
void Init(const char *str)
{
m_string = XmStringCreateLtoR
(
const_cast<char *>(str),
const_cast<char *>(XmSTRING_DEFAULT_CHARSET)
);
}
public:
wxXmString(const char* str)
{
Init(str);
}
wxXmString(const wchar_t* str)
{
Init(wxConvLibc.cWC2MB(str));
}
wxXmString(const wxString& str)
{
Init(str.mb_str());
}
wxXmString(const wxCStrData& str)
{
Init(str);
}
// just to avoid calling XmStringFree()
wxXmString(const XmString& string) { m_string = string; }
~wxXmString() { XmStringFree(m_string); }
// semi-implicit conversion to XmString (shouldn't rely on implicit
// conversion because many of Motif functions are macros)
XmString operator()() const { return m_string; }
private:
XmString m_string;
};
// ----------------------------------------------------------------------------
// Routines used in both wxTextCtrl/wxListBox and nativa wxComboBox
// (defined in src/motif/listbox.cpp or src/motif/textctrl.cpp
// ----------------------------------------------------------------------------
int wxDoFindStringInList( Widget listWidget, const wxString& str );
int wxDoGetSelectionInList( Widget listWidget );
wxString wxDoGetStringInList( Widget listWidget, int n );
wxSize wxDoGetListBoxBestSize( Widget listWidget, const wxWindow* window );
wxSize wxDoGetSingleTextCtrlBestSize( Widget textWidget,
const wxWindow* window );
// ----------------------------------------------------------------------------
// event-related functions
// ----------------------------------------------------------------------------
// executes one main loop iteration (implemented in src/motif/evtloop.cpp)
// returns true if the loop should be exited
bool wxDoEventLoopIteration( wxGUIEventLoop& evtLoop );
// Consume all events until no more left
void wxFlushEvents(WXDisplay* display);
// ----------------------------------------------------------------------------
// macros to avoid casting WXFOO to Foo all the time
// ----------------------------------------------------------------------------
// argument is of type "wxWindow *"
#define GetWidget(w) ((Widget)(w)->GetHandle())
// ----------------------------------------------------------------------------
// accessors for C modules
// ----------------------------------------------------------------------------
extern "C" XtAppContext wxGetAppContext();
#endif
// _WX_PRIVATE_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/accel.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/accel.h
// Purpose: wxAcceleratorTable class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ACCEL_H_
#define _WX_ACCEL_H_
#include "wx/object.h"
#include "wx/string.h"
#include "wx/event.h"
class WXDLLIMPEXP_CORE wxAcceleratorTable: public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxAcceleratorTable);
public:
wxAcceleratorTable();
wxAcceleratorTable(const wxString& resource); // Load from .rc resource
wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]); // Load from array
virtual ~wxAcceleratorTable();
bool Ok() const { return IsOk(); }
bool IsOk() const;
// Implementation only
int GetCount() const;
wxAcceleratorEntry* GetEntries() const;
};
extern WXDLLIMPEXP_DATA_CORE(wxAcceleratorTable) wxNullAcceleratorTable;
#endif
// _WX_ACCEL_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/scrolbar.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/scrolbar.h
// Purpose: wxScrollBar class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SCROLBAR_H_
#define _WX_SCROLBAR_H_
// Scrollbar item
class WXDLLIMPEXP_CORE wxScrollBar: public wxScrollBarBase
{
wxDECLARE_DYNAMIC_CLASS(wxScrollBar);
public:
inline wxScrollBar() { m_pageSize = 0; m_viewSize = 0; m_objectSize = 0; }
virtual ~wxScrollBar();
inline wxScrollBar(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr);
int GetThumbPosition() const ;
inline int GetThumbSize() const { return m_pageSize; }
inline int GetPageSize() const { return m_viewSize; }
inline int GetRange() const { return m_objectSize; }
virtual void SetThumbPosition(int viewStart);
virtual void SetScrollbar(int position, int thumbSize, int range, int pageSize,
bool refresh = true);
void Command(wxCommandEvent& event);
// Implementation
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
protected:
int m_pageSize;
int m_viewSize;
int m_objectSize;
};
#endif
// _WX_SCROLBAR_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/choice.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/choice.h
// Purpose: wxChoice class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHOICE_H_
#define _WX_CHOICE_H_
#include "wx/clntdata.h"
#ifndef wxWIDGET_ARRAY_DEFINED
#define wxWIDGET_ARRAY_DEFINED
#include "wx/dynarray.h"
WX_DEFINE_ARRAY_PTR(WXWidget, wxWidgetArray);
#endif
// Choice item
class WXDLLIMPEXP_CORE wxChoice: public wxChoiceBase
{
wxDECLARE_DYNAMIC_CLASS(wxChoice);
public:
wxChoice();
virtual ~wxChoice();
wxChoice(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Init();
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxChoice(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Init();
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
// implementation of wxControlWithItems
virtual unsigned int GetCount() const;
virtual int GetSelection() const;
virtual void DoDeleteOneItem(unsigned int n);
virtual void DoClear();
virtual void SetString(unsigned int n, const wxString& s);
virtual wxString GetString(unsigned int n) const;
// implementation of wxChoiceBase
virtual void SetSelection(int n);
virtual void SetColumns(int n = 1 );
virtual int GetColumns() const ;
// Original API
virtual void Command(wxCommandEvent& event);
void SetFocus();
// Implementation
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
WXWidget GetTopWidget() const { return m_formWidget; }
WXWidget GetMainWidget() const { return m_buttonWidget; }
virtual wxSize DoGetBestSize() const;
// implementation, for wxChoiceCallback
const wxWidgetArray& GetWidgets() const { return m_widgetArray; }
const wxArrayString& GetStrings() const { return m_stringArray; }
protected:
// minimum size for the text ctrl
wxSize GetItemsSize() const;
// common part of all contructors
void Init();
WXWidget m_menuWidget;
WXWidget m_buttonWidget;
wxWidgetArray m_widgetArray;
WXWidget m_formWidget;
wxArrayString m_stringArray;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
// implementation of wxControlWithItems
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
};
#endif // _WX_CHOICE_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/ctrlsub.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/ctrlsub.h
// Purpose: common functionality of wxItemContainer-derived controls
// Author: Vadim Zeitlin
// Created: 2007-07-25
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_CTRLSUB_H_
#define _WX_MOTIF_CTRLSUB_H_
#include "wx/dynarray.h"
#include "wx/generic/ctrlsub.h"
// ----------------------------------------------------------------------------
// wxControlWithItems
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxControlWithItems : public wxControlWithItemsGeneric
{
public:
wxControlWithItems() { }
protected:
// Motif functions inserting items in the control interpret positions
// differently from wx: they're 1-based and 0 means to append
unsigned int GetMotifPosition(unsigned int pos) const
{
return pos == GetCount() ? 0 : pos + 1;
}
private:
wxDECLARE_ABSTRACT_CLASS(wxControlWithItems);
wxDECLARE_NO_COPY_CLASS(wxControlWithItems);
};
#endif // _WX_MOTIF_CTRLSUB_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/minifram.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/minifram.h
// Purpose: wxMiniFrame class. A small frame for e.g. floating toolbars.
// If there is no equivalent on your platform, just make it a
// normal frame.
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MINIFRAM_H_
#define _WX_MINIFRAM_H_
#include "wx/frame.h"
class WXDLLIMPEXP_CORE wxMiniFrame: public wxFrame {
wxDECLARE_DYNAMIC_CLASS(wxMiniFrame);
public:
inline wxMiniFrame() {}
inline wxMiniFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE|wxTINY_CAPTION,
const wxString& name = wxFrameNameStr)
{
// Use wxFrame constructor in absence of more specific code.
Create(parent, id, title, pos, size, style, name);
}
virtual ~wxMiniFrame() {}
protected:
};
#endif
// _WX_MINIFRAM_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/bmpmotif.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/bmpmotif.h
// Purpose: Motif-specific bitmap routines
// Author: Julian Smart, originally in bitmap.h
// Modified by:
// Created: 25/03/2003
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BMPMOTIF_H_
#define _WX_BMPMOTIF_H_
#include "wx/defs.h"
#include "wx/bitmap.h"
class WXDLLIMPEXP_CORE wxBitmapCache
{
public:
wxBitmapCache()
{
m_labelPixmap = (WXPixmap)NULL;
m_armPixmap = (WXPixmap)NULL;
m_insensPixmap = (WXPixmap)NULL;
m_image = (WXImage)NULL;
m_display = NULL;
SetColoursChanged();
}
~wxBitmapCache();
void SetColoursChanged();
void SetBitmap( const wxBitmap& bitmap );
WXPixmap GetLabelPixmap( WXWidget w );
WXPixmap GetInsensPixmap( WXWidget w = (WXWidget)NULL );
WXPixmap GetArmPixmap( WXWidget w );
private:
void InvalidateCache();
void CreateImageIfNeeded( WXWidget w );
WXPixmap GetPixmapFromCache(WXWidget w);
struct
{
bool label : 1;
bool arm : 1;
bool insens : 1;
} m_recalcPixmaps;
wxBitmap m_bitmap;
WXDisplay* m_display;
WXPixmap m_labelPixmap, m_armPixmap, m_insensPixmap;
WXImage m_image;
};
#endif // _WX_BMPMOTIF_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dialog.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dialog.h
// Purpose: wxDialog class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIALOG_H_
#define _WX_DIALOG_H_
class WXDLLIMPEXP_FWD_CORE wxEventLoop;
// Dialog boxes
class WXDLLIMPEXP_CORE wxDialog : public wxDialogBase
{
public:
wxDialog();
wxDialog(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxDialogNameStr)
{
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxDialogNameStr);
virtual ~wxDialog();
virtual bool Destroy();
virtual bool Show(bool show = true);
void SetTitle(const wxString& title);
void SetModal(bool flag);
virtual bool IsModal() const
{ return m_modalShowing; }
virtual int ShowModal();
virtual void EndModal(int retCode);
// Implementation
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
WXWidget GetTopWidget() const { return m_mainWidget; }
WXWidget GetClientWidget() const { return m_mainWidget; }
private:
virtual bool XmDoCreateTLW(wxWindow* parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name);
//// Motif-specific
bool m_modalShowing;
wxEventLoop* m_eventLoop;
protected:
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoSetClientSize(int width, int height);
private:
wxDECLARE_DYNAMIC_CLASS(wxDialog);
};
#endif // _WX_DIALOG_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dataobj2.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dataobj2.h
// Purpose: declaration of standard wxDataObjectSimple-derived classes
// Author: Mattia Barbon
// Created: 27.04.03
// Copyright: (c) 2003 Mattia Barbon
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_DATAOBJ2_H_
#define _WX_MOTIF_DATAOBJ2_H_
// ----------------------------------------------------------------------------
// wxBitmapDataObject is a specialization of wxDataObject for bitmaps
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapDataObject : public wxBitmapDataObjectBase
{
public:
// ctors
wxBitmapDataObject()
: wxBitmapDataObjectBase() { }
wxBitmapDataObject(const wxBitmap& bitmap)
: wxBitmapDataObjectBase(bitmap) { }
// implement base class pure virtuals
// ----------------------------------
virtual size_t GetDataSize() const;
virtual bool GetDataHere(void *buf) const;
virtual bool SetData(size_t len, const void *buf);
// unhide base class virtual functions
virtual size_t GetDataSize(const wxDataFormat& WXUNUSED(format)) const
{ return GetDataSize(); }
virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
void *buf) const
{ return GetDataHere(buf); }
virtual bool SetData(const wxDataFormat& WXUNUSED(format),
size_t len, const void *buf)
{ return SetData(len, buf); }
};
#endif // _WX_MOTIF_DATAOBJ2_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/icon.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/icon.h
// Purpose: wxIcon class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ICON_H_
#define _WX_ICON_H_
#include "wx/bitmap.h"
// Icon
class WXDLLIMPEXP_CORE wxIcon : public wxBitmap
{
public:
wxIcon();
// Initialize with XBM data
wxIcon(const char bits[], int width, int height);
// Initialize with XPM data
wxIcon(const char* const* data);
#ifdef wxNEEDS_CHARPP
wxIcon(char **data);
#endif
wxIcon(const wxString& name, wxBitmapType type = wxICON_DEFAULT_TYPE,
int desiredWidth = -1, int desiredHeight = -1)
{
LoadFile(name, type, desiredWidth, desiredHeight);
}
wxIcon(const wxIconLocation& loc)
{
LoadFile(loc.GetFileName(), wxBITMAP_TYPE_ANY);
}
virtual ~wxIcon();
bool LoadFile(const wxString& name, wxBitmapType type,
int desiredWidth, int desiredHeight);
// unhide the base class version
virtual bool LoadFile(const wxString& name,
wxBitmapType flags = wxICON_DEFAULT_TYPE)
{ return LoadFile(name, flags); }
// create from bitmap (which should have a mask unless it's monochrome):
// there shouldn't be any implicit bitmap -> icon conversion (i.e. no
// ctors, assignment operators...), but it's ok to have such function
void CopyFromBitmap(const wxBitmap& bmp);
wxDECLARE_DYNAMIC_CLASS(wxIcon);
};
#endif // _WX_ICON_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/cursor.h
|
/////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/cursor.h
// Purpose: wxCursor class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CURSOR_H_
#define _WX_CURSOR_H_
#include "wx/gdicmn.h"
class WXDLLIMPEXP_FWD_CORE wxImage;
// Cursor
class WXDLLIMPEXP_CORE wxCursor : public wxCursorBase
{
public:
wxCursor();
wxCursor(const char bits[], int width, int height,
int hotSpotX = -1, int hotSpotY = -1,
const char maskBits[] = NULL,
const wxColour* fg = NULL, const wxColour* bg = NULL);
wxCursor(const wxString& name,
wxBitmapType type = wxCURSOR_DEFAULT_TYPE,
int hotSpotX = 0, int hotSpotY = 0);
#if wxUSE_IMAGE
wxCursor(const wxImage& image);
#endif
wxCursor(wxStockCursor id) { InitFromStock(id); }
#if WXWIN_COMPATIBILITY_2_8
wxCursor(int id) { InitFromStock((wxStockCursor)id); }
#endif
virtual ~wxCursor();
// Motif-specific.
// Create/get a cursor for the current display
WXCursor GetXCursor(WXDisplay* display) const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
void InitFromStock(wxStockCursor);
void Create(const char bits[], int width, int height,
int hotSpotX = -1, int hotSpotY = -1,
const char maskBits[] = NULL);
void Create(WXPixmap cursor, WXPixmap mask, int hotSpotX, int hotSpotY);
// Make a cursor from standard id
WXCursor MakeCursor(WXDisplay* display, wxStockCursor id) const;
wxDECLARE_DYNAMIC_CLASS(wxCursor);
};
extern WXDLLIMPEXP_CORE void wxSetCursor(const wxCursor& cursor);
#endif
// _WX_CURSOR_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dnd.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dnd.h
// Purpose: declaration of wxDropTarget, wxDropSource classes
// Author: Julian Smart
// Copyright: (c) 1998 Vadim Zeitlin, Robert Roebling, Julian Smart
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DND_H_
#define _WX_DND_H_
#include "wx/defs.h"
#if wxUSE_DRAG_AND_DROP
#include "wx/object.h"
#include "wx/string.h"
#include "wx/dataobj.h"
#include "wx/cursor.h"
//-------------------------------------------------------------------------
// classes
//-------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxDropTarget;
class WXDLLIMPEXP_FWD_CORE wxTextDropTarget;
class WXDLLIMPEXP_FWD_CORE wxFileDropTarget;
class WXDLLIMPEXP_FWD_CORE wxPrivateDropTarget;
class WXDLLIMPEXP_FWD_CORE wxDropSource;
//-------------------------------------------------------------------------
// wxDropTarget
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDropTarget: public wxObject
{
public:
wxDropTarget();
virtual ~wxDropTarget();
virtual void OnEnter() { }
virtual void OnLeave() { }
virtual bool OnDrop( long x, long y, const void *data, size_t size ) = 0;
// Override these to indicate what kind of data you support:
virtual size_t GetFormatCount() const = 0;
virtual wxDataFormat GetFormat(size_t n) const = 0;
// implementation
};
//-------------------------------------------------------------------------
// wxTextDropTarget
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTextDropTarget: public wxDropTarget
{
public:
wxTextDropTarget() {}
virtual bool OnDrop( long x, long y, const void *data, size_t size );
virtual bool OnDropText( long x, long y, const char *psz );
protected:
virtual size_t GetFormatCount() const;
virtual wxDataFormat GetFormat(size_t n) const;
};
//-------------------------------------------------------------------------
// wxPrivateDropTarget
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPrivateDropTarget: public wxDropTarget
{
public:
wxPrivateDropTarget();
// you have to override OnDrop to get at the data
// the string ID identifies the format of clipboard or DnD data. a word
// processor would e.g. add a wxTextDataObject and a wxPrivateDataObject
// to the clipboard - the latter with the Id "WXWORD_FORMAT".
void SetId( const wxString& id )
{ m_id = id; }
wxString GetId()
{ return m_id; }
private:
virtual size_t GetFormatCount() const;
virtual wxDataFormat GetFormat(size_t n) const;
wxString m_id;
};
// ----------------------------------------------------------------------------
// A drop target which accepts files (dragged from File Manager or Explorer)
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDropTarget: public wxDropTarget
{
public:
wxFileDropTarget() {}
virtual bool OnDrop( long x, long y, const void *data, size_t size );
virtual bool OnDropFiles( long x, long y,
size_t nFiles, const char * const aszFiles[] );
protected:
virtual size_t GetFormatCount() const;
virtual wxDataFormat GetFormat(size_t n) const;
};
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
enum wxDragResult
{
wxDragError, // error prevented the d&d operation from completing
wxDragNone, // drag target didn't accept the data
wxDragCopy, // the data was successfully copied
wxDragMove, // the data was successfully moved
wxDragCancel // the operation was cancelled by user (not an error)
};
class WXDLLIMPEXP_CORE wxDropSource: public wxObject
{
public:
wxDropSource( wxWindow *win );
wxDropSource( wxDataObject &data, wxWindow *win );
virtual ~wxDropSource(void);
void SetData( wxDataObject &data );
wxDragResult DoDragDrop(int flags = wxDrag_CopyOnly);
virtual bool GiveFeedback( wxDragResult WXUNUSED(effect), bool WXUNUSED(bScrolling) ) { return true; }
// implementation
#if 0
void RegisterWindow(void);
void UnregisterWindow(void);
wxWindow *m_window;
wxDragResult m_retValue;
wxDataObject *m_data;
wxCursor m_defaultCursor;
wxCursor m_goaheadCursor;
#endif
};
#endif
// wxUSE_DRAG_AND_DROP
#endif
//_WX_DND_H_
|
h
|
rticonnextdds-usecases
|
data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/popupwin.h
|
///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/popupwin.h
// Purpose: wxPopupWindow class for wxMotif
// Author: Mattia Barbon
// Modified by:
// Created: 28.08.03
// Copyright: (c) 2003 Mattia Barbon
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_POPUPWIN_H_
#define _WX_MOTIF_POPUPWIN_H_
// ----------------------------------------------------------------------------
// wxPopupWindow
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPopupWindow : public wxPopupWindowBase
{
public:
wxPopupWindow() { Init(); }
wxPopupWindow( wxWindow *parent, int flags = wxBORDER_NONE )
{ Init(); (void)Create( parent, flags ); }
bool Create( wxWindow *parent, int flags = wxBORDER_NONE );
virtual bool Show( bool show = true );
private:
void Init() { m_isShown = false; }
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxPopupWindow);
};
#endif // _WX_MOTIF_POPUPWIN_H_
|
h
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.