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/Win32/include/wx/qt/dcscreen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dcscreen.h
// Author: Sean D'Epagnier
// Copyright: (c) Sean D'Epagnier
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DCSCREEN_H_
#define _WX_QT_DCSCREEN_H_
#include "wx/qt/dcclient.h"
class WXDLLIMPEXP_CORE wxScreenDCImpl : public wxWindowDCImpl
{
public:
wxScreenDCImpl( wxScreenDC *owner );
~wxScreenDCImpl();
protected:
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const;
virtual QImage *GetQImage();
wxDECLARE_ABSTRACT_CLASS(wxScreenDCImpl);
};
#endif // _WX_QT_DCSCREEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/combobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/combobox.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_COMBOBOX_H_
#define _WX_QT_COMBOBOX_H_
#include "wx/choice.h"
class QComboBox;
class WXDLLIMPEXP_CORE wxComboBox : public wxChoice, public wxTextEntry
{
public:
wxComboBox();
wxComboBox(wxWindow *parent,
wxWindowID id,
const wxString& value = wxEmptyString,
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 = wxComboBoxNameStr);
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 void SetSelection(int n) wxOVERRIDE { wxChoice::SetSelection(n); }
virtual void SetSelection(long from, long to) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE { return wxChoice::GetSelection(); }
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual wxString GetStringSelection() const wxOVERRIDE
{
return wxItemContainer::GetStringSelection();
}
virtual void Clear() wxOVERRIDE;
// See wxComboBoxBase discussion of IsEmpty().
bool IsListEmpty() const { return wxItemContainer::IsEmpty(); }
bool IsTextEmpty() const { return wxTextEntry::IsEmpty(); }
virtual void SetValue(const wxString& value) wxOVERRIDE;
virtual void Popup();
virtual void Dismiss();
protected:
// From wxTextEntry:
virtual wxString DoGetValue() const wxOVERRIDE;
private:
// From wxTextEntry:
virtual wxWindow *GetEditableWindow() wxOVERRIDE { return this; }
wxDECLARE_DYNAMIC_CLASS(wxComboBox);
};
#endif // _WX_QT_COMBOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/glcanvas.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/qt/glcanvas.cpp
// Author: Sean D'Epagnier
// Copyright: (c) Sean D'Epagnier 2014
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GLCANVAS_H_
#define _WX_GLCANVAS_H_
#include <GL/gl.h>
class QGLWidget;
class QGLContext;
class QGLFormat;
class WXDLLIMPEXP_GL wxGLContext : public wxGLContextBase
{
public:
wxGLContext(wxGLCanvas *win,
const wxGLContext *other = NULL,
const wxGLContextAttrs *ctxAttrs = NULL);
/// virtual ~wxGLContext();
virtual bool SetCurrent(const wxGLCanvas& win) const wxOVERRIDE;
private:
QGLContext *m_glContext;
wxDECLARE_CLASS(wxGLContext);
};
// ----------------------------------------------------------------------------
// wxGLCanvas: OpenGL output window
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasBase
{
public:
explicit // avoid implicitly converting a wxWindow* to wxGLCanvas
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
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);
virtual bool SwapBuffers();
static bool ConvertWXAttrsToQtGL(const int *wxattrs, QGLFormat &format);
private:
// wxDECLARE_EVENT_TABLE();
wxDECLARE_CLASS(wxGLCanvas);
};
#endif // _WX_GLCANVAS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/window.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/window.h
// Purpose: wxWindow class
// Author: Peter Most, Javier Torres, Mariano Reingart
// Copyright: (c) 2009 wxWidgets dev team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_WINDOW_H_
#define _WX_QT_WINDOW_H_
#include <list>
class QShortcut;
template < class T > class QList;
class QWidget;
class QScrollWindow;
class QAbstractScrollArea;
class QScrollArea;
class QPicture;
class QPainter;
class QPaintEvent;
class QResizeEvent;
class QWheelEvent;
class QKeyEvent;
class QMouseEvent;
class QEvent;
class QMoveEvent;
class QEvent;
class QEvent;
class QCloseEvent;
class QContextMenuEvent;
class QFocusEvent;
class WXDLLIMPEXP_FWD_CORE wxScrollBar;
class WXDLLIMPEXP_FWD_CORE wxQtShortcutHandler;
/* wxQt specific notes:
*
* Remember to implement the Qt object getters on all subclasses:
* - GetHandle() returns the Qt object
* - QtGetScrollBarsContainer() returns the widget where scrollbars are placed
* For example, for wxFrame, GetHandle() is the QMainWindow,
* QtGetScrollBarsContainer() is the central widget and QtGetContainer() is a widget
* in a layout inside the central widget that also contains the scrollbars.
* Return 0 from QtGetScrollBarsContainer() to disable SetScrollBar() and friends
* for wxWindow subclasses.
*
*
* Event handling is achieved by using the template class wxQtEventForwarder
* found in winevent_qt.(h|cpp) to send all Qt events here to QtHandleXXXEvent()
* methods. All these methods receive the Qt event and the handler. This is
* done because events of the containers (the scrolled part of the window) are
* sent to the same wxWindow instance, that must be able to differenciate them
* as some events need different handling (paintEvent) depending on that.
* We pass the QWidget pointer to all event handlers for consistency.
*/
class WXDLLIMPEXP_CORE wxWindowQt : public wxWindowBase
{
public:
wxWindowQt();
~wxWindowQt();
wxWindowQt(wxWindowQt *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
bool Create(wxWindowQt *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
// Used by all window classes in the widget creation process.
void PostCreation( bool generic = true );
void AddChild( wxWindowBase *child ) wxOVERRIDE;
virtual bool Show( bool show = true ) wxOVERRIDE;
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual wxString GetLabel() const wxOVERRIDE;
virtual void DoEnable( bool enable ) wxOVERRIDE;
virtual void SetFocus() wxOVERRIDE;
// Parent/Child:
static void QtReparent( QWidget *child, QWidget *parent );
virtual bool Reparent( wxWindowBase *newParent ) wxOVERRIDE;
// Z-order
virtual void Raise() wxOVERRIDE;
virtual void Lower() wxOVERRIDE;
// move the mouse to the specified position
virtual void WarpPointer(int x, int y) wxOVERRIDE;
virtual void Update() wxOVERRIDE;
virtual void Refresh( bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL ) wxOVERRIDE;
virtual bool SetCursor( const wxCursor &cursor ) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
// get the (average) character size for the current font
virtual int GetCharHeight() const wxOVERRIDE;
virtual int GetCharWidth() const wxOVERRIDE;
virtual void SetScrollbar( int orient,
int pos,
int thumbvisible,
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;
// scroll window to the specified position
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = NULL ) wxOVERRIDE;
// Styles
virtual void SetWindowStyleFlag( long style ) wxOVERRIDE;
virtual void SetExtraStyle( long exStyle ) wxOVERRIDE;
virtual bool SetBackgroundStyle(wxBackgroundStyle style) wxOVERRIDE;
virtual bool IsTransparentBackgroundSupported(wxString* reason = NULL) const wxOVERRIDE;
virtual bool SetTransparent(wxByte alpha) wxOVERRIDE;
virtual bool CanSetTransparent() wxOVERRIDE { return true; }
QWidget *GetHandle() const wxOVERRIDE;
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget ) wxOVERRIDE;
#endif
#if wxUSE_ACCEL
// accelerators
// ------------
virtual void SetAcceleratorTable( const wxAcceleratorTable& accel ) wxOVERRIDE;
#endif // wxUSE_ACCEL
// wxQt implementation internals:
virtual QPicture *QtGetPicture() const;
QPainter *QtGetPainter();
virtual bool QtHandlePaintEvent ( QWidget *handler, QPaintEvent *event );
virtual bool QtHandleResizeEvent ( QWidget *handler, QResizeEvent *event );
virtual bool QtHandleWheelEvent ( QWidget *handler, QWheelEvent *event );
virtual bool QtHandleKeyEvent ( QWidget *handler, QKeyEvent *event );
virtual bool QtHandleMouseEvent ( QWidget *handler, QMouseEvent *event );
virtual bool QtHandleEnterEvent ( QWidget *handler, QEvent *event );
virtual bool QtHandleMoveEvent ( QWidget *handler, QMoveEvent *event );
virtual bool QtHandleShowEvent ( QWidget *handler, QEvent *event );
virtual bool QtHandleChangeEvent ( QWidget *handler, QEvent *event );
virtual bool QtHandleCloseEvent ( QWidget *handler, QCloseEvent *event );
virtual bool QtHandleContextMenuEvent ( QWidget *handler, QContextMenuEvent *event );
virtual bool QtHandleFocusEvent ( QWidget *handler, QFocusEvent *event );
static void QtStoreWindowPointer( QWidget *widget, const wxWindowQt *window );
static wxWindowQt *QtRetrieveWindowPointer( const QWidget *widget );
#if wxUSE_ACCEL
virtual void QtHandleShortcut ( int command );
#endif // wxUSE_ACCEL
virtual QScrollArea *QtGetScrollBarsContainer() const;
protected:
virtual void DoGetTextExtent(const wxString& string,
int *x, int *y,
int *descent = NULL,
int *externalLeading = NULL,
const wxFont *font = NULL) const wxOVERRIDE;
// coordinates translation
virtual void DoClientToScreen( int *x, int *y ) const wxOVERRIDE;
virtual void DoScreenToClient( int *x, int *y ) const wxOVERRIDE;
// capture/release the mouse, used by Capture/ReleaseMouse()
virtual void DoCaptureMouse() wxOVERRIDE;
virtual void DoReleaseMouse() wxOVERRIDE;
// retrieve the position/size of the window
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
// same as DoSetSize() for the client size
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE;
#endif // wxUSE_TOOLTIPS
#if wxUSE_MENUS
virtual bool DoPopupMenu(wxMenu *menu, int x, int y) wxOVERRIDE;
#endif // wxUSE_MENUS
QWidget *m_qtWindow;
private:
void Init();
QScrollArea *m_qtContainer;
wxScrollBar *m_horzScrollBar;
wxScrollBar *m_vertScrollBar;
void QtOnScrollBarEvent( wxScrollEvent& event );
wxScrollBar *QtGetScrollBar( int orientation ) const;
wxScrollBar *QtSetScrollBar( int orientation, wxScrollBar *scrollBar=NULL );
bool QtSetBackgroundStyle();
QPicture *m_qtPicture;
QPainter *m_qtPainter;
bool m_mouseInside;
#if wxUSE_ACCEL
QList< QShortcut* > *m_qtShortcuts;
wxQtShortcutHandler *m_qtShortcutHandler;
bool m_processingShortcut;
#endif // wxUSE_ACCEL
wxDECLARE_DYNAMIC_CLASS_NO_COPY( wxWindowQt );
};
#endif // _WX_QT_WINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/dc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dc.h
// Author: Peter Most, Javier Torres, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DC_H_
#define _WX_QT_DC_H_
class QPainter;
class QImage;
class WXDLLIMPEXP_FWD_CORE wxRegion;
class WXDLLIMPEXP_CORE wxQtDCImpl : public wxDCImpl
{
public:
wxQtDCImpl( wxDC *owner );
~wxQtDCImpl();
virtual bool CanDrawBitmap() const;
virtual bool CanGetTextExtent() const;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetSizeMM(int* width, int* height) const;
virtual int GetDepth() const;
virtual wxSize GetPPI() const;
virtual void SetFont(const wxFont& font);
virtual void SetPen(const wxPen& pen);
virtual void SetBrush(const wxBrush& brush);
virtual void SetBackground(const wxBrush& brush);
virtual void SetBackgroundMode(int mode);
#if wxUSE_PALETTE
virtual void SetPalette(const wxPalette& palette);
#endif // wxUSE_PALETTE
virtual void SetLogicalFunction(wxRasterOperationMode function);
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 void Clear();
virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoSetDeviceClippingRegion(const wxRegion& region);
virtual void DestroyClippingRegion();
virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
wxFloodFillStyle style = wxFLOOD_SURFACE);
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const;
virtual void DoDrawPoint(wxCoord x, wxCoord y);
virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
virtual void DoDrawArc(wxCoord x1, wxCoord y1,
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc);
virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
double sa, double ea);
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
wxCoord width, wxCoord height,
double radius);
virtual void DoDrawEllipse(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoCrossHair(wxCoord x, wxCoord y);
virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask = false);
virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y);
virtual void DoDrawRotatedText(const wxString& text,
wxCoord x, wxCoord y, double angle);
virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
wxCoord width, wxCoord height,
wxDC *source,
wxCoord xsrc, wxCoord ysrc,
wxRasterOperationMode rop = wxCOPY,
bool useMask = false,
wxCoord xsrcMask = wxDefaultCoord,
wxCoord ysrcMask = wxDefaultCoord);
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);
// Use Qt transformations, as they automatically scale pen widths, text...
virtual void ComputeScaleAndOrigin();
void QtPreparePainter();
virtual void* GetHandle() const { return (void*) m_qtPainter; }
protected:
virtual QImage *GetQImage() { return m_qtImage; }
QPainter *m_qtPainter;
QImage *m_qtImage;
wxRegion *m_clippingRegion;
private:
enum wxQtRasterColourOp
{
wxQtNONE,
wxQtWHITE,
wxQtBLACK,
wxQtINVERT
};
wxQtRasterColourOp m_rasterColourOp;
QColor *m_qtPenColor;
QColor *m_qtBrushColor;
void ApplyRasterColourOp();
};
#endif // _WX_QT_DC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/msgdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/msgdlg.h
// Author: Peter Most, Javier Torres
// Copyright: (c) Peter Most, Javier Torres
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_MSGDLG_H_
#define _WX_QT_MSGDLG_H_
#include "wx/msgdlg.h"
class QMessageBox;
class WXDLLIMPEXP_CORE wxMessageDialog : public wxMessageDialogBase
{
public:
wxMessageDialog(wxWindow *parent, const wxString& message,
const wxString& caption = wxMessageBoxCaptionStr,
long style = wxOK|wxCENTRE,
const wxPoint& pos = wxDefaultPosition);
virtual ~wxMessageDialog();
// Reimplemented to translate return codes from Qt to wx
virtual int ShowModal();
};
#endif // _WX_QT_MSGDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/clrpicker.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/clrpicker.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CLRPICKER_H_
#define _WX_QT_CLRPICKER_H_
#include "wx/generic/clrpickerg.h"
// TODO: A QtColorPicker is available from
// http://qt.nokia.com/products/appdev/add-on-products/catalog/4/Widgets/qtcolorpicker/
// How to integrate into wxWidgets:
//
// class WXDLLIMPEXP_CORE wxColourPickerWidget : public wxButton, public wxColourPickerWidgetBase
// TODO: For now we reuse the existing wxGenericColourButton but this should be
// changed to use the above mentioned color picker.
class WXDLLIMPEXP_CORE wxColourPickerWidget : public wxGenericColourButton
{
public:
wxColourPickerWidget();
wxColourPickerWidget(wxWindow *parent,
wxWindowID id,
const wxColour& initial = *wxBLACK,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCLRBTN_DEFAULT_STYLE,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxColourPickerWidgetNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxColour& initial = *wxBLACK,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCLRBTN_DEFAULT_STYLE,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxColourPickerWidgetNameStr);
protected:
virtual void UpdateColour();
private:
};
#endif // _WX_QT_CLRPICKER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/notebook.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/notebook.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_NOTEBOOK_H_
#define _WX_QT_NOTEBOOK_H_
class QTabWidget;
class WXDLLIMPEXP_CORE wxNotebook : public wxNotebookBase
{
public:
wxNotebook();
wxNotebook(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
virtual void SetPadding(const wxSize& padding);
virtual void SetTabSize(const wxSize& sz);
virtual bool SetPageText(size_t n, const wxString& strText);
virtual wxString GetPageText(size_t n) const;
virtual int GetPageImage(size_t n) const;
virtual bool SetPageImage(size_t n, int imageId);
virtual bool InsertPage(size_t n, wxWindow *page, const wxString& text,
bool bSelect = false, int imageId = -1);
virtual wxSize CalcSizeFromPage(const wxSize& sizePage) const;
int SetSelection(size_t nPage) { return DoSetSelection(nPage, SetSelection_SendEvent); }
int ChangeSelection(size_t nPage) { return DoSetSelection(nPage); }
virtual QWidget *GetHandle() const;
protected:
virtual wxWindow *DoRemovePage(size_t page);
int DoSetSelection(size_t nPage, int flags = 0);
private:
QTabWidget *m_qtTabWidget;
// internal array to store imageId for each page:
wxVector<int> m_images;
wxDECLARE_DYNAMIC_CLASS( wxNotebook );
};
#endif // _WX_QT_NOTEBOOK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/statline.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/statline.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_STATLINE_H_
#define _WX_QT_STATLINE_H_
class QFrame;
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 );
virtual QWidget *GetHandle() const;
private:
QFrame *m_qtFrame;
wxDECLARE_DYNAMIC_CLASS( wxStaticLine );
};
#endif // _WX_QT_STATLINE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/dvrenderers.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dvrenderers.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DVRENDERERS_H_
#define _WX_QT_DVRENDERERS_H_
// ---------------------------------------------------------
// wxDataViewTextRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewTextRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("string"); }
wxDataViewTextRenderer( const wxString &varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT );
bool SetValue( const wxVariant &value );
bool GetValue( wxVariant &value ) const;
void SetAlignment( int align );
};
// ---------------------------------------------------------
// wxDataViewBitmapRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewBitmapRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("wxBitmap"); }
wxDataViewBitmapRenderer( const wxString &varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT );
bool SetValue( const wxVariant &value );
bool GetValue( wxVariant &value ) const;
};
// ---------------------------------------------------------
// wxDataViewToggleRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewToggleRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("bool"); }
wxDataViewToggleRenderer( const wxString &varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT );
bool SetValue( const wxVariant &value );
bool GetValue( wxVariant &value ) const;
};
// ---------------------------------------------------------
// wxDataViewCustomRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewCustomRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("string"); }
wxDataViewCustomRenderer( const wxString &varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT,
bool no_init = false );
virtual ~wxDataViewCustomRenderer();
virtual bool Render( wxRect cell, wxDC *dc, int state ) = 0;
void RenderText( const wxString &text, int xoffset, wxRect cell, wxDC *dc, int state );
virtual wxSize GetSize() const = 0;
virtual bool Activate( wxRect WXUNUSED(cell),
wxDataViewModel *WXUNUSED(model), const wxDataViewItem &WXUNUSED(item), unsigned int WXUNUSED(col) )
{ return false; }
virtual bool LeftClick( wxPoint WXUNUSED(cursor), wxRect WXUNUSED(cell),
wxDataViewModel *WXUNUSED(model), const wxDataViewItem &WXUNUSED(item), unsigned int WXUNUSED(col) )
{ return false; }
virtual bool StartDrag( wxPoint WXUNUSED(cursor), wxRect WXUNUSED(cell),
wxDataViewModel *WXUNUSED(model), const wxDataViewItem &WXUNUSED(item), unsigned int WXUNUSED(col) )
{ return false; }
// Create DC on request
virtual wxDC *GetDC();
};
// ---------------------------------------------------------
// wxDataViewProgressRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewProgressRenderer: public wxDataViewCustomRenderer
{
public:
static wxString GetDefaultType() { return wxS("long"); }
wxDataViewProgressRenderer( const wxString &label = wxEmptyString,
const wxString &varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT );
virtual ~wxDataViewProgressRenderer();
bool SetValue( const wxVariant &value );
bool GetValue( wxVariant &value ) const;
virtual bool Render( wxRect cell, wxDC *dc, int state );
virtual wxSize GetSize() const;
};
// ---------------------------------------------------------
// wxDataViewIconTextRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewIconTextRenderer: public wxDataViewCustomRenderer
{
public:
static wxString GetDefaultType() { return wxS("wxDataViewIconText"); }
wxDataViewIconTextRenderer( const wxString &varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT );
virtual ~wxDataViewIconTextRenderer();
bool SetValue( const wxVariant &value );
bool GetValue( wxVariant &value ) const;
virtual bool Render( wxRect cell, wxDC *dc, int state );
virtual wxSize GetSize() const;
virtual bool HasEditorCtrl() const { return true; }
virtual wxControl* CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value );
virtual bool GetValueFromEditorCtrl( wxControl* editor, wxVariant &value );
};
// ---------------------------------------------------------
// wxDataViewDateRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewDateRenderer: public wxDataViewCustomRenderer
{
public:
static wxString GetDefaultType() { return wxS("datetime"); }
wxDataViewDateRenderer( const wxString &varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE,
int align = wxDVR_DEFAULT_ALIGNMENT );
bool SetValue( const wxVariant &value );
bool GetValue( wxVariant &value ) const;
virtual bool Render( wxRect cell, wxDC *dc, int state );
virtual wxSize GetSize() const;
virtual bool Activate( wxRect cell,
wxDataViewModel *model, const wxDataViewItem &item, unsigned int col );
};
// -------------------------------------
// wxDataViewChoiceRenderer
// -------------------------------------
class WXDLLIMPEXP_ADV wxDataViewChoiceRenderer: public wxDataViewCustomRenderer
{
public:
wxDataViewChoiceRenderer( const wxArrayString &choices,
wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
int alignment = wxDVR_DEFAULT_ALIGNMENT );
virtual bool Render( wxRect rect, wxDC *dc, int state );
virtual wxSize GetSize() const;
virtual bool SetValue( const wxVariant &value );
virtual bool GetValue( wxVariant &value ) const;
void SetAlignment( int align );
};
#endif // _WX_QT_DVRENDERERS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/frame.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/frame.h
// Purpose: wxFrame class interface
// Author: Peter Most
// Modified by:
// Created: 09.08.09
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_FRAME_H_
#define _WX_QT_FRAME_H_
#include "wx/frame.h"
class QMainWindow;
class QScrollArea;
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);
virtual ~wxFrame();
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 void SetMenuBar(wxMenuBar *menubar);
virtual void SetStatusBar(wxStatusBar *statusBar );
virtual void SetToolBar(wxToolBar *toolbar);
virtual void SetWindowStyleFlag( long style );
virtual void AddChild( wxWindowBase *child );
virtual void RemoveChild( wxWindowBase *child );
QMainWindow *GetQMainWindow() const;
virtual QScrollArea *QtGetScrollBarsContainer() const;
protected:
virtual void DoGetClientSize(int *width, int *height) const;
private:
wxDECLARE_DYNAMIC_CLASS( wxFrame );
};
#endif // _WX_QT_FRAME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/statusbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/statusbar.h
// Author: Peter Most, Javier Torres, Mariano Reingart, Sean D'Epagnier
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_STATUSBAR_H_
#define _WX_QT_STATUSBAR_H_
#include "wx/statusbr.h"
class QLabel;
class QStatusBar;
template < class T > class QList;
class WXDLLIMPEXP_CORE wxStatusBar : public wxStatusBarBase
{
public:
wxStatusBar();
wxStatusBar(wxWindow *parent, wxWindowID winid = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr);
bool Create(wxWindow *parent, wxWindowID winid = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr);
virtual bool GetFieldRect(int i, wxRect& rect) const;
virtual void SetMinHeight(int height);
virtual int GetBorderX() const;
virtual int GetBorderY() const;
virtual void Refresh( bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL );
QStatusBar *GetQStatusBar() const { return m_qtStatusBar; }
QWidget *GetHandle() const;
protected:
virtual void DoUpdateStatusText(int number);
private:
void Init();
void UpdateFields();
QStatusBar *m_qtStatusBar;
QList< QLabel* > *m_qtPanes;
wxDECLARE_DYNAMIC_CLASS(wxStatusBar);
};
#endif // _WX_QT_STATUSBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/dataobj.h | /////////////////////////////////////////////////////////////////////////////
// Name: src/qt/dataobj.cpp
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DATAOBJ_H_
#define _WX_QT_DATAOBJ_H_
class QMimeData;
class WXDLLIMPEXP_CORE wxDataObject : public wxDataObjectBase
{
public:
wxDataObject();
~wxDataObject();
virtual bool IsSupportedFormat(const wxDataFormat& format, Direction dir) const;
virtual wxDataFormat GetPreferredFormat(Direction dir = Get) const;
virtual size_t GetFormatCount(Direction dir = Get) const;
virtual void GetAllFormats(wxDataFormat *formats, Direction dir = Get) const;
virtual size_t GetDataSize(const wxDataFormat& format) const;
virtual bool GetDataHere(const wxDataFormat& format, void *buf) const;
virtual bool SetData(const wxDataFormat& format, size_t len, const void * buf);
private:
QMimeData *m_qtMimeData; // to handle formats that have no helper classes
};
#endif // _WX_QT_DATAOBJ_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/statbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/statbox.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_STATBOX_H_
#define _WX_QT_STATBOX_H_
class QGroupBox;
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 GetBordersForSizer(int *borderTop, int *borderOther) const;
virtual QWidget *GetHandle() const;
protected:
private:
QGroupBox *m_qtGroupBox;
wxDECLARE_DYNAMIC_CLASS( wxStaticBox );
};
#endif // _WX_QT_STATBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/control.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/control.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CONTROL_H_
#define _WX_QT_CONTROL_H_
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);
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 wxSize DoGetBestSize() const;
protected:
bool QtCreateControl( wxWindow *parent, wxWindowID id, const wxPoint &pos,
const wxSize &size, long style, const wxValidator &validator,
const wxString &name );
private:
wxDECLARE_DYNAMIC_CLASS(wxControl);
};
#endif // _WX_QT_CONTROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/dcprint.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dcprint.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DCPRINT_H_
#define _WX_QT_DCPRINT_H_
#include "wx/dc.h"
class WXDLLIMPEXP_CORE wxPrinterDCImpl : public wxDCImpl
{
public:
wxPrinterDCImpl( wxPrinterDC *, const wxPrintData & );
virtual bool CanDrawBitmap() const;
virtual bool CanGetTextExtent() const;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetSizeMM(int* width, int* height) const;
virtual int GetDepth() const;
virtual wxSize GetPPI() const;
virtual void SetFont(const wxFont& font);
virtual void SetPen(const wxPen& pen);
virtual void SetBrush(const wxBrush& brush);
virtual void SetBackground(const wxBrush& brush);
virtual void SetBackgroundMode(int mode);
#if wxUSE_PALETTE
virtual void SetPalette(const wxPalette& palette);
#endif // wxUSE_PALETTE
virtual void SetLogicalFunction(wxRasterOperationMode function);
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 void Clear();
virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoSetDeviceClippingRegion(const wxRegion& region);
virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
wxFloodFillStyle style = wxFLOOD_SURFACE);
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const;
virtual void DoDrawPoint(wxCoord x, wxCoord y);
virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
virtual void DoDrawArc(wxCoord x1, wxCoord y1,
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc);
virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
double sa, double ea);
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
wxCoord width, wxCoord height,
double radius);
virtual void DoDrawEllipse(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoCrossHair(wxCoord x, wxCoord y);
virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask = false);
virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y);
virtual void DoDrawRotatedText(const wxString& text,
wxCoord x, wxCoord y, double angle);
virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
wxCoord width, wxCoord height,
wxDC *source,
wxCoord xsrc, wxCoord ysrc,
wxRasterOperationMode rop = wxCOPY,
bool useMask = false,
wxCoord xsrcMask = wxDefaultCoord,
wxCoord ysrcMask = wxDefaultCoord);
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);
protected:
private:
};
#endif // _WX_QT_DCPRINT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/printdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/printdlg.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_PRINTDLG_H_
#define _WX_QT_PRINTDLG_H_
#include "wx/prntbase.h"
#include "wx/printdlg.h"
class WXDLLIMPEXP_CORE wxQtPrintNativeData: public wxPrintNativeDataBase
{
public:
wxQtPrintNativeData();
virtual bool TransferTo( wxPrintData &data );
virtual bool TransferFrom( const wxPrintData &data );
virtual bool IsOk() const;
};
class WXDLLIMPEXP_CORE wxQtPrintDialog : public wxPrintDialogBase
{
public:
wxQtPrintDialog(wxWindow *parent, wxPrintDialogData *data);
wxQtPrintDialog(wxWindow *parent, wxPrintData *data);
virtual wxPrintDialogData& GetPrintDialogData();
virtual wxPrintData& GetPrintData();
virtual wxDC *GetPrintDC();
protected:
private:
};
class WXDLLIMPEXP_CORE wxQtPageSetupDialog: public wxPageSetupDialogBase
{
public:
wxQtPageSetupDialog();
wxQtPageSetupDialog(wxWindow *parent, wxPageSetupDialogData *data = NULL);
bool Create(wxWindow *parent, wxPageSetupDialogData *data = NULL);
virtual wxPageSetupDialogData& GetPageSetupDialogData();
private:
};
#endif // _WX_QT_PRINTDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/colordlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/colordlg.h
// Author: Sean D'Epagnier
// Copyright: (c) Sean D'Epagnier 2014
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_COLORDLG_H_
#define _WX_QT_COLORDLG_H_
#include "wx/dialog.h"
class QColorDialog;
class WXDLLIMPEXP_CORE wxColourDialog : public wxDialog
{
public:
wxColourDialog() { }
wxColourDialog(wxWindow *parent,
wxColourData *data = NULL) { Create(parent, data); }
bool Create(wxWindow *parent, wxColourData *data = NULL);
wxColourData &GetColourData();
private:
QColorDialog *GetQColorDialog() const;
wxColourData m_data;
};
#endif // _WX_QT_COLORDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/button.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/button.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_BUTTON_H_
#define _WX_QT_BUTTON_H_
#include "wx/control.h"
#include "wx/button.h"
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);
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();
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxButton);
};
#endif // _WX_QT_BUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/treectrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/treectrl.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_TREECTRL_H_
#define _WX_QT_TREECTRL_H_
class QTreeWidget;
class WXDLLIMPEXP_CORE wxTreeCtrl : public wxTreeCtrlBase
{
public:
wxTreeCtrl();
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 = wxTreeCtrlNameStr);
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 = wxTreeCtrlNameStr);
virtual unsigned int GetCount() const;
virtual unsigned int GetIndent() const;
virtual void SetIndent(unsigned int indent);
virtual void SetImageList(wxImageList *imageList);
virtual void SetStateImageList(wxImageList *imageList);
virtual wxString GetItemText(const wxTreeItemId& item) const;
virtual int GetItemImage(const wxTreeItemId& item,
wxTreeItemIcon which = wxTreeItemIcon_Normal) const;
virtual wxTreeItemData *GetItemData(const wxTreeItemId& item) const;
virtual wxColour GetItemTextColour(const wxTreeItemId& item) const;
virtual wxColour GetItemBackgroundColour(const wxTreeItemId& item) const;
virtual wxFont GetItemFont(const wxTreeItemId& item) const;
virtual void SetItemText(const wxTreeItemId& item, const wxString& text);
virtual void SetItemImage(const wxTreeItemId& item,
int image,
wxTreeItemIcon which = wxTreeItemIcon_Normal);
virtual void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
virtual void SetItemHasChildren(const wxTreeItemId& item, bool has = true);
virtual void SetItemBold(const wxTreeItemId& item, bool bold = true);
virtual void SetItemDropHighlight(const wxTreeItemId& item, bool highlight = true);
virtual void SetItemTextColour(const wxTreeItemId& item, const wxColour& col);
virtual void SetItemBackgroundColour(const wxTreeItemId& item, const wxColour& col);
virtual void SetItemFont(const wxTreeItemId& item, const wxFont& font);
virtual bool IsVisible(const wxTreeItemId& item) const;
virtual bool ItemHasChildren(const wxTreeItemId& item) const;
virtual bool IsExpanded(const wxTreeItemId& item) const;
virtual bool IsSelected(const wxTreeItemId& item) const;
virtual bool IsBold(const wxTreeItemId& item) const;
virtual size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = true) const;
virtual wxTreeItemId GetRootItem() const;
virtual wxTreeItemId GetSelection() const;
virtual size_t GetSelections(wxArrayTreeItemIds& selections) const;
virtual void SetFocusedItem(const wxTreeItemId& item);
virtual void ClearFocusedItem();
virtual wxTreeItemId GetFocusedItem() const;
virtual wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
virtual wxTreeItemId GetFirstChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
virtual wxTreeItemId GetNextChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
virtual wxTreeItemId GetLastChild(const wxTreeItemId& item) const;
virtual wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
virtual wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
virtual wxTreeItemId GetFirstVisibleItem() const;
virtual wxTreeItemId GetNextVisible(const wxTreeItemId& item) const;
virtual wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const;
virtual wxTreeItemId AddRoot(const wxString& text,
int image = -1, int selImage = -1,
wxTreeItemData *data = NULL);
virtual void Delete(const wxTreeItemId& item);
virtual void DeleteChildren(const wxTreeItemId& item);
virtual void DeleteAllItems();
virtual void Expand(const wxTreeItemId& item);
virtual void Collapse(const wxTreeItemId& item);
virtual void CollapseAndReset(const wxTreeItemId& item);
virtual void Toggle(const wxTreeItemId& item);
virtual void Unselect();
virtual void UnselectAll();
virtual void SelectItem(const wxTreeItemId& item, bool select = true);
virtual void SelectChildren(const wxTreeItemId& parent);
virtual void EnsureVisible(const wxTreeItemId& item);
virtual void ScrollTo(const wxTreeItemId& item);
virtual wxTextCtrl *EditLabel(const wxTreeItemId& item, wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
virtual wxTextCtrl *GetEditControl() const;
virtual void EndEditLabel(const wxTreeItemId& item, bool discardChanges = false);
virtual void SortChildren(const wxTreeItemId& item);
virtual bool GetBoundingRect(const wxTreeItemId& item, wxRect& rect, bool textOnly = false) const;
virtual QWidget *GetHandle() const;
protected:
virtual int DoGetItemState(const wxTreeItemId& item) const;
virtual void DoSetItemState(const wxTreeItemId& item, int state);
virtual wxTreeItemId DoInsertItem(const wxTreeItemId& parent,
size_t pos,
const wxString& text,
int image, int selImage,
wxTreeItemData *data);
virtual wxTreeItemId DoInsertAfter(const wxTreeItemId& parent,
const wxTreeItemId& idPrevious,
const wxString& text,
int image = -1, int selImage = -1,
wxTreeItemData *data = NULL);
virtual wxTreeItemId DoTreeHitTest(const wxPoint& point, int& flags) const;
private:
QTreeWidget *m_qtTreeWidget;
wxDECLARE_DYNAMIC_CLASS(wxTreeCtrl);
};
#endif // _WX_QT_TREECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/textctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/textctrl.h
// Author: Mariano Reingart, Peter Most
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_TEXTCTRL_H_
#define _WX_QT_TEXTCTRL_H_
class QLineEdit;
class QTextEdit;
class QScrollArea;
class WXDLLIMPEXP_CORE wxTextCtrl : public wxTextCtrlBase
{
public:
wxTextCtrl();
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);
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 int GetLineLength(long lineNo) const;
virtual wxString GetLineText(long lineNo) const;
virtual int GetNumberOfLines() const;
virtual bool IsModified() const;
virtual void MarkDirty();
virtual void DiscardEdits();
virtual bool SetStyle(long start, long end, const wxTextAttr& style);
virtual bool GetStyle(long position, wxTextAttr& style);
virtual bool SetDefaultStyle(const wxTextAttr& style);
virtual long XYToPosition(long x, long y) const;
virtual bool PositionToXY(long pos, long *x, long *y) const;
virtual void ShowPosition(long pos);
virtual void SetInsertionPoint(long pos);
virtual long GetInsertionPoint() const;
virtual void SetSelection( long from, long to );
virtual void GetSelection(long *from, long *to) const;
virtual wxString DoGetValue() const;
virtual void DoSetValue(const wxString &text, int flags = 0);
virtual void WriteText(const wxString& text);
virtual QWidget *GetHandle() const;
protected:
virtual wxSize DoGetBestSize() const;
virtual bool DoLoadFile(const wxString& file, int fileType);
virtual bool DoSaveFile(const wxString& file, int fileType);
virtual QScrollArea *QtGetScrollBarsContainer() const;
private:
QLineEdit *m_qtLineEdit;
QTextEdit *m_qtTextEdit;
wxDECLARE_DYNAMIC_CLASS( wxTextCtrl );
};
#endif // _WX_QT_TEXTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/private/pointer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/private/pointer.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_POINTER_H_
#define _WX_QT_POINTER_H_
#include <QtCore/QPointer>
// Extend QPointer with the ability to delete the object in its destructor. The
// normal behaviour of the QPointer makes sure that this is safe, because if somebody
// has deleted the object, then data() returns NULL and delete does nothing.
template < typename T >
class wxQtPointer : public QPointer< T >
{
public:
inline wxQtPointer()
: QPointer< T >()
{
}
inline wxQtPointer( T *p )
: QPointer< T >( p )
{
}
inline wxQtPointer< T > &operator = ( T *p )
{
QPointer< T >::operator = ( p );
return *this;
}
inline ~wxQtPointer()
{
delete QPointer< T >::data();
}
};
#endif // _WX_QT_POINTER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/private/timer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/timer.h
// Author: Javier Torres
// Copyright: (c) Javier Torres
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_TIMER_H_
#define _WX_QT_TIMER_H_
#if wxUSE_TIMER
#include <QtCore/QObject>
#include "wx/private/timer.h"
//-----------------------------------------------------------------------------
// wxTimer
//-----------------------------------------------------------------------------
class QTimerEvent;
class WXDLLIMPEXP_CORE wxQtTimerImpl : public wxTimerImpl, QObject
{
public:
wxQtTimerImpl( wxTimer* timer );
virtual bool Start( int millisecs = -1, bool oneShot = false );
virtual void Stop();
virtual bool IsRunning() const;
protected:
virtual void timerEvent( QTimerEvent * event );
private:
int m_timerId;
};
#endif // wxUSE_TIMER
#endif // _WX_QT_TIMER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/private/converter.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/converter.h
// Purpose: Converter utility classes and functions
// Author: Peter Most, Kolya Kosenko
// Created: 02/28/10
// Copyright: (c) Peter Most
// (c) 2010 Kolya Kosenko
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CONVERTER_H_
#define _WX_QT_CONVERTER_H_
#include "wx/defs.h"
#include <QtCore/Qt>
#include "wx/kbdstate.h"
// Rely on overloading and let the compiler pick the correct version, which makes
// them easier to use then to write wxQtConvertQtRectToWxRect() or wxQtConvertWxRectToQtRect()
class WXDLLIMPEXP_FWD_CORE wxPoint;
class QPoint;
wxPoint wxQtConvertPoint( const QPoint &point );
QPoint wxQtConvertPoint( const wxPoint &point );
class WXDLLIMPEXP_FWD_CORE wxRect;
class QRect;
wxRect wxQtConvertRect( const QRect &rect );
QRect wxQtConvertRect( const wxRect &rect );
class WXDLLIMPEXP_FWD_BASE wxString;
class QString;
wxString wxQtConvertString( const QString &str );
QString wxQtConvertString( const wxString &str );
#if wxUSE_DATETIME
class WXDLLIMPEXP_FWD_BASE wxDateTime;
class QDate;
wxDateTime wxQtConvertDate(const QDate& date);
QDate wxQtConvertDate(const wxDateTime& date);
#endif // wxUSE_DATETIME
class WXDLLIMPEXP_FWD_BASE wxSize;
class QSize;
wxSize wxQtConvertSize( const QSize &size );
QSize wxQtConvertSize( const wxSize &size );
Qt::Orientation wxQtConvertOrientation( long style, wxOrientation defaultOrientation );
wxOrientation wxQtConvertOrientation( Qt::Orientation );
wxKeyCode wxQtConvertKeyCode( int key, Qt::KeyboardModifiers modifiers );
void wxQtFillKeyboardModifiers( Qt::KeyboardModifiers modifiers, wxKeyboardState *state );
int wxQtConvertKeyCode( int keyCode, int modifiers, Qt::KeyboardModifiers &qtmodifiers );
#endif // _WX_QT_CONVERTER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/private/winevent.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/qt/winevent_qt.h
// Purpose: QWidget to wxWindow event handler
// Author: Javier Torres, Peter Most
// Modified by:
// Created: 21.06.10
// Copyright: (c) Javier Torres
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_EVENTSIGNALFORWARDER_H_
#define _WX_QT_EVENTSIGNALFORWARDER_H_
#include <QtCore/QEvent>
#include <QtGui/QCloseEvent>
#include "wx/log.h"
#include "wx/window.h"
#include "wx/qt/private/converter.h"
#include "wx/qt/private/utils.h"
class QPaintEvent;
template< typename Handler >
class wxQtSignalHandler
{
protected:
wxQtSignalHandler( Handler *handler )
{
m_handler = handler;
}
void EmitEvent( wxEvent &event ) const
{
wxWindow *handler = GetHandler();
event.SetEventObject( handler );
handler->HandleWindowEvent( event );
}
virtual Handler *GetHandler() const
{
return m_handler;
}
private:
Handler *m_handler;
};
template < typename Widget, typename Handler >
class wxQtEventSignalHandler : public Widget, public wxQtSignalHandler< Handler >
{
public:
wxQtEventSignalHandler( wxWindow *parent, Handler *handler )
: Widget( parent != NULL ? parent->GetHandle() : NULL )
, wxQtSignalHandler< Handler >( handler )
{
// Set immediatelly as it is used to check if wxWindow is alive
wxWindow::QtStoreWindowPointer( this, handler );
// Handle QWidget destruction signal AFTER it gets deleted
QObject::connect( this, &QObject::destroyed, this,
&wxQtEventSignalHandler::HandleDestroyedSignal );
}
void HandleDestroyedSignal()
{
}
virtual Handler *GetHandler() const
{
// Only process the signal / event if the wxWindow is not destroyed
if ( !wxWindow::QtRetrieveWindowPointer( this ) )
{
return NULL;
}
else
return wxQtSignalHandler< Handler >::GetHandler();
}
protected:
/* Not implemented here: wxHelpEvent, wxIdleEvent wxJoystickEvent,
* wxMouseCaptureLostEvent, wxMouseCaptureChangedEvent,
* wxPowerEvent, wxScrollWinEvent, wxSysColourChangedEvent */
//wxActivateEvent
virtual void changeEvent ( QEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleChangeEvent(this, event) )
Widget::changeEvent(event);
else
event->accept();
}
//wxCloseEvent
virtual void closeEvent ( QCloseEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleCloseEvent(this, event) )
Widget::closeEvent(event);
else
event->accept();
}
//wxContextMenuEvent
virtual void contextMenuEvent ( QContextMenuEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleContextMenuEvent(this, event) )
Widget::contextMenuEvent(event);
else
event->accept();
}
//wxDropFilesEvent
//virtual void dropEvent ( QDropEvent * event ) { }
//wxMouseEvent
virtual void enterEvent ( QEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleEnterEvent(this, event) )
Widget::enterEvent(event);
else
event->accept();
}
//wxFocusEvent.
virtual void focusInEvent ( QFocusEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleFocusEvent(this, event) )
Widget::focusInEvent(event);
else
event->accept();
}
//wxFocusEvent.
virtual void focusOutEvent ( QFocusEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleFocusEvent(this, event) )
Widget::focusOutEvent(event);
else
event->accept();
}
//wxShowEvent
virtual void hideEvent ( QHideEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleShowEvent(this, event) )
Widget::hideEvent(event);
else
event->accept();
}
//wxKeyEvent
virtual void keyPressEvent ( QKeyEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleKeyEvent(this, event) )
Widget::keyPressEvent(event);
else
event->accept();
}
//wxKeyEvent
virtual void keyReleaseEvent ( QKeyEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleKeyEvent(this, event) )
Widget::keyReleaseEvent(event);
else
event->accept();
}
//wxMouseEvent
virtual void leaveEvent ( QEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleEnterEvent(this, event) )
Widget::leaveEvent(event);
else
event->accept();
}
//wxMouseEvent
virtual void mouseDoubleClickEvent ( QMouseEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
Widget::mouseDoubleClickEvent(event);
else
event->accept();
}
//wxMouseEvent
virtual void mouseMoveEvent ( QMouseEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
Widget::mouseMoveEvent(event);
else
event->accept();
}
//wxMouseEvent
virtual void mousePressEvent ( QMouseEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
Widget::mousePressEvent(event);
else
event->accept();
}
//wxMouseEvent
virtual void mouseReleaseEvent ( QMouseEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleMouseEvent(this, event) )
Widget::mouseReleaseEvent(event);
else
event->accept();
}
//wxMoveEvent
virtual void moveEvent ( QMoveEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleMoveEvent(this, event) )
Widget::moveEvent(event);
else
event->accept();
}
//wxEraseEvent then wxPaintEvent
virtual void paintEvent ( QPaintEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandlePaintEvent(this, event) )
Widget::paintEvent(event);
else
event->accept();
}
//wxSizeEvent
virtual void resizeEvent ( QResizeEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleResizeEvent(this, event) )
Widget::resizeEvent(event);
else
event->accept();
}
//wxShowEvent
virtual void showEvent ( QShowEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleShowEvent(this, event) )
Widget::showEvent(event);
else
event->accept();
}
//wxMouseEvent
virtual void wheelEvent ( QWheelEvent * event )
{
if ( !this->GetHandler() )
return;
if ( !this->GetHandler()->QtHandleWheelEvent(this, event) )
Widget::wheelEvent(event);
else
event->accept();
}
/* Unused Qt events
virtual void actionEvent ( QActionEvent * event ) { }
virtual void dragEnterEvent ( QDragEnterEvent * event ) { }
virtual void dragLeaveEvent ( QDragLeaveEvent * event ) { }
virtual void dragMoveEvent ( QDragMoveEvent * event ) { }
virtual void inputMethodEvent ( QInputMethodEvent * event ) { }
virtual bool macEvent ( EventHandlerCallRef caller, EventRef event ) { }
virtual bool qwsEvent ( QWSEvent * event ) { }
virtual void tabletEvent ( QTabletEvent * event ) { }
virtual bool winEvent ( MSG * message, long * result ) { }
virtual bool x11Event ( XEvent * event ) { } */
};
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/qt/private/utils.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/utils.h
// Purpose: utility classes and/or functions
// Author: Peter Most, Javier Torres
// Created: 15/05/10
// Copyright: (c) Peter Most, Javier Torres
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_UTILS_H_
#define _WX_QT_UTILS_H_
#include "wx/mousestate.h"
#include <QtCore/Qt>
void wxQtFillMouseButtons( Qt::MouseButtons buttons, wxMouseState *state );
void wxMissingImplementation( const char fileName[], unsigned lineNumber,
const char feature[] );
#define wxMISSING_IMPLEMENTATION( feature )\
wxMissingImplementation( __FILE__, __LINE__, feature )
#define wxMISSING_FUNCTION() \
wxMISSING_IMPLEMENTATION( __WXFUNCTION__ )
#endif // _WX_QT_UTILS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/icondir.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/icondir.h
// Purpose: Declarations of structs used for loading MS icons
// Author: wxWidgets team
// Created: 2017-05-19
// Copyright: (c) 2017 wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_ICONDIR_H_
#define _WX_PRIVATE_ICONDIR_H_
#include "wx/defs.h" // wxUint* declarations
// Structs declared here are used for loading group icons from
// .ICO files or MS Windows resources.
// Icon entry and directory structs for .ICO files and
// MS Windows resources are very similar but not identical.
#if wxUSE_ICO_CUR
#if wxUSE_STREAMS
// icon entry in .ICO files
struct ICONDIRENTRY
{
wxUint8 bWidth; // Width of the image
wxUint8 bHeight; // Height of the image (times 2)
wxUint8 bColorCount; // Number of colors in image (0 if >=8bpp)
wxUint8 bReserved; // Reserved
// these two are different in icons and cursors:
// icon or cursor
wxUint16 wPlanes; // Color Planes or XHotSpot
wxUint16 wBitCount; // Bits per pixel or YHotSpot
wxUint32 dwBytesInRes; // how many bytes in this resource?
wxUint32 dwImageOffset; // where in the file is this image
};
// icon directory in .ICO files
struct ICONDIR
{
wxUint16 idReserved; // Reserved
wxUint16 idType; // resource type (1 for icons, 2 for cursors)
wxUint16 idCount; // how many images?
};
#endif // wxUSE_STREAMS
#ifdef __WINDOWS__
#pragma pack(push)
#pragma pack(2)
// icon entry in MS Windows resources
struct GRPICONDIRENTRY
{
wxUint8 bWidth; // Width of the image
wxUint8 bHeight; // Height of the image (times 2)
wxUint8 bColorCount; // Number of colors in image (0 if >=8bpp)
wxUint8 bReserved; // Reserved
// these two are different in icons and cursors:
// icon or cursor
wxUint16 wPlanes; // Color Planes or XHotSpot
wxUint16 wBitCount; // Bits per pixel or YHotSpot
wxUint32 dwBytesInRes; // how many bytes in this resource?
wxUint16 nID; // actual icon resource ID
};
// icon directory in MS Windows resources
struct GRPICONDIR
{
wxUint16 idReserved; // Reserved
wxUint16 idType; // resource type (1 for icons, 2 for cursors)
wxUint16 idCount; // how many images?
GRPICONDIRENTRY idEntries[1]; // The entries for each image
};
#pragma pack(pop)
#endif // __WINDOWS__
#endif // wxUSE_ICO_CUR
#endif // _WX_PRIVATE_ICONDIR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/graphics.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/graphics.h
// Purpose: private graphics context header
// Author: Stefan Csomor
// Modified by:
// Created:
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GRAPHICS_PRIVATE_H_
#define _WX_GRAPHICS_PRIVATE_H_
#if wxUSE_GRAPHICS_CONTEXT
#include "wx/graphics.h"
class WXDLLIMPEXP_CORE wxGraphicsObjectRefData : public wxObjectRefData
{
public :
wxGraphicsObjectRefData( wxGraphicsRenderer* renderer );
wxGraphicsObjectRefData( const wxGraphicsObjectRefData* data );
wxGraphicsRenderer* GetRenderer() const ;
virtual wxGraphicsObjectRefData* Clone() const ;
protected :
wxGraphicsRenderer* m_renderer;
} ;
class WXDLLIMPEXP_CORE wxGraphicsBitmapData : public wxGraphicsObjectRefData
{
public :
wxGraphicsBitmapData( wxGraphicsRenderer* renderer) :
wxGraphicsObjectRefData(renderer) {}
virtual ~wxGraphicsBitmapData() {}
// returns the native representation
virtual void * GetNativeBitmap() const = 0;
} ;
class WXDLLIMPEXP_CORE wxGraphicsMatrixData : public wxGraphicsObjectRefData
{
public :
wxGraphicsMatrixData( wxGraphicsRenderer* renderer) :
wxGraphicsObjectRefData(renderer) {}
virtual ~wxGraphicsMatrixData() {}
// concatenates the matrix
virtual void Concat( const wxGraphicsMatrixData *t ) = 0;
// sets the matrix to the respective values
virtual void Set(wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
wxDouble tx=0.0, wxDouble ty=0.0) = 0;
// gets the component valuess of the matrix
virtual void Get(wxDouble* a=NULL, wxDouble* b=NULL, wxDouble* c=NULL,
wxDouble* d=NULL, wxDouble* tx=NULL, wxDouble* ty=NULL) const = 0;
// makes this the inverse matrix
virtual void Invert() = 0;
// returns true if the elements of the transformation matrix are equal ?
virtual bool IsEqual( const wxGraphicsMatrixData* t) const = 0;
// return true if this is the identity matrix
virtual bool IsIdentity() const = 0;
//
// transformation
//
// add the translation to this matrix
virtual void Translate( wxDouble dx , wxDouble dy ) = 0;
// add the scale to this matrix
virtual void Scale( wxDouble xScale , wxDouble yScale ) = 0;
// add the rotation to this matrix (radians)
virtual void Rotate( wxDouble angle ) = 0;
//
// apply the transforms
//
// applies that matrix to the point
virtual void TransformPoint( wxDouble *x, wxDouble *y ) const = 0;
// applies the matrix except for translations
virtual void TransformDistance( wxDouble *dx, wxDouble *dy ) const =0;
// returns the native representation
virtual void * GetNativeMatrix() const = 0;
} ;
class WXDLLIMPEXP_CORE wxGraphicsPathData : public wxGraphicsObjectRefData
{
public :
wxGraphicsPathData(wxGraphicsRenderer* renderer) : wxGraphicsObjectRefData(renderer) {}
virtual ~wxGraphicsPathData() {}
//
// These are the path primitives from which everything else can be constructed
//
// begins a new subpath at (x,y)
virtual void MoveToPoint( wxDouble x, wxDouble y ) = 0;
// adds a straight line from the current point to (x,y)
virtual void AddLineToPoint( wxDouble x, wxDouble y ) = 0;
// adds a cubic Bezier curve from the current point, using two control points and an end point
virtual void AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y ) = 0;
// adds another path
virtual void AddPath( const wxGraphicsPathData* path ) =0;
// closes the current sub-path
virtual void CloseSubpath() = 0;
// gets the last point of the current path, (0,0) if not yet set
virtual void GetCurrentPoint( wxDouble* x, wxDouble* y) const = 0;
// adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
virtual void AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise ) = 0;
//
// These are convenience functions which - if not available natively will be assembled
// using the primitives from above
//
// adds a quadratic Bezier curve from the current point, using a control point and an end point
virtual void AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y );
// appends a rectangle as a new closed subpath
virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
// appends an ellipsis as a new closed subpath fitting the passed rectangle
virtual void AddCircle( wxDouble x, wxDouble y, wxDouble r );
// appends a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1)
virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r ) ;
// appends an ellipse
virtual void AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h);
// appends a rounded rectangle
virtual void AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius);
// returns the native path
virtual void * GetNativePath() const = 0;
// give the native path returned by GetNativePath() back (there might be some deallocations necessary)
virtual void UnGetNativePath(void *p) const= 0;
// transforms each point of this path by the matrix
virtual void Transform( const wxGraphicsMatrixData* matrix ) =0;
// gets the bounding box enclosing all points (possibly including control points)
virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const=0;
virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxODDEVEN_RULE) const=0;
};
#endif
#endif // _WX_GRAPHICS_PRIVATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/jsscriptwrapper.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/jsscriptwrapper.h
// Purpose: JS Script Wrapper for wxWebView
// Author: Jose Lorenzo
// Created: 2017-08-12
// Copyright: (c) 2017 Jose Lorenzo <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_JSSCRIPTWRAPPER_H_
#define _WX_PRIVATE_JSSCRIPTWRAPPER_H_
#include "wx/regex.h"
// ----------------------------------------------------------------------------
// Helper for wxWebView::RunScript()
// ----------------------------------------------------------------------------
// This class provides GetWrappedCode(), GetOutputCode() and GetCleanUpCode()
// functions that should be executed in the backend-appropriate way by each
// wxWebView implementation in order to actually execute the user-provided
// JavaScript code, retrieve its result (if it executed successfully) and
// perform the cleanup at the end.
class wxJSScriptWrapper
{
public:
wxJSScriptWrapper(const wxString& js, int* runScriptCount)
: m_escapedCode(js)
{
// We assign the return value of JavaScript snippet we execute to the
// variable with this name in order to be able to access it later if
// needed.
//
// Note that we use a different name for it for each call to
// RunScript() (which creates a new wxJSScriptWrapper every time) to
// avoid any possible conflict between different calls.
m_outputVarName = wxString::Format("__wxOut%i", (*runScriptCount)++);
// Adds one escape level if there is a single quote, double quotes or
// escape characters
wxRegEx escapeDoubleQuotes("(\\\\*)([\\'\"\n\r\v\t\b\f])");
escapeDoubleQuotes.Replace(&m_escapedCode,"\\1\\1\\\\\\2");
}
// Get the code to execute, its returned value will be either boolean true,
// if it executed successfully, or the exception message if an error
// occurred.
//
// Execute GetOutputCode() later to get the real output after successful
// execution of this code.
wxString GetWrappedCode() const
{
return wxString::Format
(
"try { var %s = eval(\"%s\"); true; } "
"catch (e) { e.name + \": \" + e.message; }",
m_outputVarName,
m_escapedCode
);
}
// Get code returning the result of the last successful execution of the
// code returned by GetWrappedCode().
wxString GetOutputCode() const
{
#if wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT && defined(__WXOSX__)
return wxString::Format
(
"if (typeof %s == 'object') JSON.stringify(%s);"
"else if (typeof %s == 'undefined') 'undefined';"
"else %s;",
m_outputVarName,
m_outputVarName,
m_outputVarName,
m_outputVarName
);
#elif wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE
return wxString::Format
(
"try {"
"(%s == null || typeof %s != 'object') ? String(%s)"
": JSON.stringify(%s);"
"}"
"catch (e) {"
"try {"
"function __wx$stringifyJSON(obj) {"
"if (!(obj instanceof Object))"
"return typeof obj === \"string\""
"? \'\"\' + obj + \'\"\'"
": \'\' + obj;"
"else if (obj instanceof Array) {"
"if (obj[0] === undefined)"
"return \'[]\';"
"else {"
"var arr = [];"
"for (var i = 0; i < obj.length; i++)"
"arr.push(__wx$stringifyJSON(obj[i]));"
"return \'[\' + arr + \']\';"
"}"
"}"
"else if (typeof obj === \"object\") {"
"if (obj instanceof Date) {"
"if (!Date.prototype.toISOString) {"
"(function() {"
"function pad(number) {"
"return number < 10"
"? '0' + number"
": number;"
"}"
"Date.prototype.toISOString = function() {"
"return this.getUTCFullYear() +"
"'-' + pad(this.getUTCMonth() + 1) +"
"'-' + pad(this.getUTCDate()) +"
"'T' + pad(this.getUTCHours()) +"
"':' + pad(this.getUTCMinutes()) +"
"':' + pad(this.getUTCSeconds()) +"
"'.' + (this.getUTCMilliseconds() / 1000)"
".toFixed(3).slice(2, 5) + 'Z\"';"
"};"
"}());"
"}"
"return '\"' + obj.toISOString(); + '\"'"
"}"
"var objElements = [];"
"for (var key in obj)"
"{"
"if (typeof obj[key] === \"function\")"
"return \'{}\';"
"else {"
"objElements.push(\'\"\'"
"+ key + \'\":\' +"
"__wx$stringifyJSON(obj[key]));"
"}"
"}"
"return \'{\' + objElements + \'}\';"
"}"
"}"
"__wx$stringifyJSON(%s);"
"}"
"catch (e) { e.name + \": \" + e.message; }"
"}",
m_outputVarName,
m_outputVarName,
m_outputVarName,
m_outputVarName,
m_outputVarName
);
#else
return m_outputVarName;
#endif
}
// Execute the code returned by this function to let the output of the code
// we executed be garbage-collected.
wxString GetCleanUpCode() const
{
return wxString::Format("%s = undefined;", m_outputVarName);
}
private:
wxString m_escapedCode;
wxString m_outputVarName;
wxDECLARE_NO_COPY_CLASS(wxJSScriptWrapper);
};
#endif // _WX_PRIVATE_JSSCRIPTWRAPPER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fontmgr.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fontmgr.h
// Purpose: font management for ports that don't have their own
// Author: Vaclav Slavik
// Created: 2006-11-18
// Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
// (c) 2006 REA Elektronik GmbH
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FONTMGR_H_
#define _WX_PRIVATE_FONTMGR_H_
#include "wx/list.h"
#include "wx/fontutil.h"
class wxFontsManager;
class wxFontInstance;
class wxFontInstanceList;
class wxFontFace;
class wxFontBundle;
class wxFontBundleHash;
class wxFontMgrFontRefData;
WX_DECLARE_LIST(wxFontBundle, wxFontBundleList);
/**
This class represents single font face with set parameters (point size,
antialiasing).
*/
class wxFontInstanceBase
{
protected:
wxFontInstanceBase(float ptSize, bool aa) : m_ptSize(ptSize), m_aa(aa) {}
virtual ~wxFontInstanceBase() {}
public:
float GetPointSize() const { return m_ptSize; }
bool IsAntiAliased() const { return m_aa; }
protected:
float m_ptSize;
bool m_aa;
};
/// This class represents loaded font face (bundle+weight+italics).
class wxFontFaceBase
{
protected:
/// Ctor. Creates object with reference count = 0, Acquire() must be
/// called after the object is created.
wxFontFaceBase();
virtual ~wxFontFaceBase();
public:
/// Increases reference count of the face
virtual void Acquire();
/**
Decreases reference count of the face. Call this when you no longer
use the object returned by wxFontBundle. Note that this doesn't destroy
the object, but only optionally shuts it down, so it's possible to
call Acquire() and Release() more than once.
*/
virtual void Release();
/**
Returns instance of the font at given size.
@param ptSize point size of the font to create; note that this is
a float and not integer, it should be wxFont's point
size multiplied by wxDC's scale factor
@param aa should the font be antialiased?
*/
virtual wxFontInstance *GetFontInstance(float ptSize, bool aa);
protected:
/// Called to create a new instance of the font by GetFontInstance() if
/// it wasn't found it cache.
virtual wxFontInstance *CreateFontInstance(float ptSize, bool aa) = 0;
protected:
unsigned m_refCnt;
wxFontInstanceList *m_instances;
};
/**
This class represents font bundle. Font bundle is set of faces that have
the same name, but differ in weight and italics.
*/
class wxFontBundleBase
{
public:
wxFontBundleBase();
virtual ~wxFontBundleBase();
/// Returns name of the bundle
virtual wxString GetName() const = 0;
/// Returns true if the font is fixed-width
virtual bool IsFixed() const = 0;
/// Type of faces in the bundle
enum FaceType
{
// NB: values of these constants are set so that it's possible to
// make OR-combinations of them and still get valid enum element
FaceType_Regular = 0,
FaceType_Italic = 1,
FaceType_Bold = 2,
FaceType_BoldItalic = FaceType_Italic | FaceType_Bold,
FaceType_Max
};
/// Returns true if the given face is available
bool HasFace(FaceType type) const { return m_faces[type] != NULL; }
/**
Returns font face object that can be used to render font of given type.
Note that this method can only be called if HasFace(type) returns true.
Acquire() was called on the returned object, you must call Release()
when you stop using it.
*/
wxFontFace *GetFace(FaceType type) const;
/**
Returns font face object that can be used to render given font.
Acquire() was called on the returned object, you must call Release()
when you stop using it.
*/
wxFontFace *GetFaceForFont(const wxFontMgrFontRefData& font) const;
protected:
wxFontFace *m_faces[FaceType_Max];
};
/**
Base class for wxFontsManager class, which manages the list of all
available fonts and their loaded instances.
*/
class wxFontsManagerBase
{
protected:
wxFontsManagerBase();
virtual ~wxFontsManagerBase();
public:
/// Returns the font manager singleton, creating it if it doesn't exist
static wxFontsManager *Get();
/// Called by wxApp to shut down the manager
static void CleanUp();
/// Returns list of all available font bundles
const wxFontBundleList& GetBundles() const { return *m_list; }
/**
Returns object representing font bundle with the given name.
The returned object is owned by wxFontsManager, you must not delete it.
*/
wxFontBundle *GetBundle(const wxString& name) const;
/**
Returns object representing font bundle that can be used to render
given font.
The returned object is owned by wxFontsManager, you must not delete it.
*/
wxFontBundle *GetBundleForFont(const wxFontMgrFontRefData& font) const;
/// This method must be called by derived
void AddBundle(wxFontBundle *bundle);
/// Returns default facename for given wxFont family
virtual wxString GetDefaultFacename(wxFontFamily family) const = 0;
private:
wxFontBundleHash *m_hash;
wxFontBundleList *m_list;
protected:
static wxFontsManager *ms_instance;
};
#if defined(__WXDFB__)
#include "wx/dfb/private/fontmgr.h"
#endif
/// wxFontMgrFontRefData implementation using wxFontsManager classes
class wxFontMgrFontRefData : public wxGDIRefData
{
public:
wxFontMgrFontRefData(int size = wxDEFAULT,
wxFontFamily family = wxFONTFAMILY_DEFAULT,
wxFontStyle style = wxFONTSTYLE_NORMAL,
int weight = wxFONTWEIGHT_NORMAL,
bool underlined = false,
const wxString& faceName = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
wxFontMgrFontRefData(const wxFontMgrFontRefData& data);
~wxFontMgrFontRefData();
wxFontBundle *GetFontBundle() const;
wxFontInstance *GetFontInstance(float scale, bool antialiased) const;
bool IsFixedWidth() const { return GetFontBundle()->IsFixed(); }
const wxNativeFontInfo *GetNativeFontInfo() const { return &m_info; }
float GetFractionalPointSize() const { return m_info.pointSize; }
wxString GetFaceName() const { return m_info.faceName; }
wxFontFamily GetFamily() const { return m_info.family; }
wxFontStyle GetStyle() const { return m_info.style; }
int GetNumericWeight() const { return m_info.weight; }
bool GetUnderlined() const { return m_info.underlined; }
wxFontEncoding GetEncoding() const { return m_info.encoding; }
void SetFractionalPointSize(float pointSize);
void SetFamily(wxFontFamily family);
void SetStyle(wxFontStyle style);
void SetNumericWeight(int weight);
void SetFaceName(const wxString& faceName);
void SetUnderlined(bool underlined);
void SetEncoding(wxFontEncoding encoding);
private:
void EnsureValidFont();
wxNativeFontInfo m_info;
wxFontFace *m_fontFace;
wxFontBundle *m_fontBundle;
bool m_fontValid;
};
#endif // _WX_PRIVATE_FONTMGR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/selectdispatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/selectdispatcher.h
// Purpose: wxSelectDispatcher class
// Authors: Lukasz Michalski and Vadim Zeitlin
// Created: December 2006
// Copyright: (c) Lukasz Michalski
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_SELECTDISPATCHER_H_
#define _WX_PRIVATE_SELECTDISPATCHER_H_
#include "wx/defs.h"
#if wxUSE_SELECT_DISPATCHER
#if defined(HAVE_SYS_SELECT_H)
#include <sys/time.h>
#include <sys/select.h>
#endif
#include <sys/types.h>
#include "wx/thread.h"
#include "wx/private/fdiodispatcher.h"
// helper class storing all the select() fd sets
class WXDLLIMPEXP_BASE wxSelectSets
{
public:
// ctor zeroes out all fd_sets
wxSelectSets();
// default copy ctor, assignment operator and dtor are ok
// return true if fd appears in any of the sets
bool HasFD(int fd) const;
// add or remove FD to our sets depending on whether flags contains
// wxFDIO_INPUT/OUTPUT/EXCEPTION bits
bool SetFD(int fd, int flags);
// same as SetFD() except it unsets the bits set in the flags for the given
// fd
bool ClearFD(int fd)
{
return SetFD(fd, 0);
}
// call select() with our sets: the other parameters are the same as for
// select() itself
int Select(int nfds, struct timeval *tv);
// call the handler methods corresponding to the sets having this fd if it
// is present in any set and return true if it is
bool Handle(int fd, wxFDIOHandler& handler) const;
private:
typedef void (wxFDIOHandler::*Callback)();
// the FD sets indices
enum
{
Read,
Write,
Except,
Max
};
// the sets used with select()
fd_set m_fds[Max];
// the wxFDIO_XXX flags, functions and names (used for debug messages only)
// corresponding to the FD sets above
static int ms_flags[Max];
static const char *ms_names[Max];
static Callback ms_handlers[Max];
};
class WXDLLIMPEXP_BASE wxSelectDispatcher : public wxMappedFDIODispatcher
{
public:
// default ctor
wxSelectDispatcher() { m_maxFD = -1; }
// implement pure virtual methods of the base class
virtual bool RegisterFD(int fd, wxFDIOHandler *handler, int flags = wxFDIO_ALL) wxOVERRIDE;
virtual bool ModifyFD(int fd, wxFDIOHandler *handler, int flags = wxFDIO_ALL) wxOVERRIDE;
virtual bool UnregisterFD(int fd) wxOVERRIDE;
virtual bool HasPending() const wxOVERRIDE;
virtual int Dispatch(int timeout = TIMEOUT_INFINITE) wxOVERRIDE;
private:
// common part of RegisterFD() and ModifyFD()
bool DoUpdateFDAndHandler(int fd, wxFDIOHandler *handler, int flags);
// call the handlers for the fds present in the given sets, return the
// number of handlers we called
int ProcessSets(const wxSelectSets& sets);
// helper of ProcessSets(): call the handler if its fd is in the set
void DoProcessFD(int fd, const fd_set& fds, wxFDIOHandler *handler,
const char *name);
// common part of HasPending() and Dispatch(): calls select() with the
// specified timeout
int DoSelect(wxSelectSets& sets, int timeout) const;
#if wxUSE_THREADS
wxCriticalSection m_cs;
#endif // wxUSE_THREADS
// the select sets containing all the registered fds
wxSelectSets m_sets;
// the highest registered fd value or -1 if none
int m_maxFD;
};
#endif // wxUSE_SELECT_DISPATCHER
#endif // _WX_PRIVATE_SOCKETEVTDISPATCH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/eventloopsourcesmanager.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/eventloopsourcesmanager.h
// Purpose: declares wxEventLoopSourcesManagerBase class
// Author: Rob Bresalier
// Created: 2013-06-19
// Copyright: (c) 2013 Rob Bresalier
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_EVENTLOOPSOURCESMANAGER_H_
#define _WX_PRIVATE_EVENTLOOPSOURCESMANAGER_H_
// For pulling in the value of wxUSE_EVENTLOOP_SOURCE
#include "wx/evtloop.h"
#if wxUSE_EVENTLOOP_SOURCE
class WXDLLIMPEXP_BASE wxEventLoopSourcesManagerBase
{
public:
virtual wxEventLoopSource*
AddSourceForFD(int fd, wxEventLoopSourceHandler *handler, int flags) = 0;
virtual ~wxEventLoopSourcesManagerBase() { }
};
#endif // wxUSE_EVENTLOOP_SOURCE
#endif // _WX_PRIVATE_EVENTLOOPSOURCESMANAGER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/threadinfo.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/threadinfo.h
// Purpose: declaration of wxThreadSpecificInfo: thread-specific information
// Author: Vadim Zeitlin
// Created: 2009-07-13
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_THREADINFO_H_
#define _WX_PRIVATE_THREADINFO_H_
#include "wx/defs.h"
class WXDLLIMPEXP_FWD_BASE wxLog;
#if wxUSE_INTL
#include "wx/hashset.h"
WX_DECLARE_HASH_SET(wxString, wxStringHash, wxStringEqual,
wxLocaleUntranslatedStrings);
#endif
// ----------------------------------------------------------------------------
// wxThreadSpecificInfo: contains all thread-specific information used by wx
// ----------------------------------------------------------------------------
// Group all thread-specific information we use (e.g. the active wxLog target)
// a in this class to avoid consuming more TLS slots than necessary as there is
// only a limited number of them.
class wxThreadSpecificInfo
{
public:
// Return this thread's instance.
static wxThreadSpecificInfo& Get();
// the thread-specific logger or NULL if the thread is using the global one
// (this is not used for the main thread which always uses the global
// logger)
wxLog *logger;
// true if logging is currently disabled for this thread (this is also not
// used for the main thread which uses wxLog::ms_doLog)
//
// NB: we use a counter-intuitive "disabled" flag instead of "enabled" one
// because the default, for 0-initialized struct, should be to enable
// logging
bool loggingDisabled;
#if wxUSE_INTL
// Storage for wxTranslations::GetUntranslatedString()
wxLocaleUntranslatedStrings untranslatedStrings;
#endif
#if wxUSE_THREADS
// Cleans up storage for the current thread. Should be called when a thread
// is being destroyed. If it's not called, the only bad thing that happens
// is that the memory is deallocated later, on process termination.
static void ThreadCleanUp();
#endif
private:
wxThreadSpecificInfo() : logger(NULL), loggingDisabled(false) {}
};
#define wxThreadInfo wxThreadSpecificInfo::Get()
#endif // _WX_PRIVATE_THREADINFO_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/preferences.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/preferences.h
// Purpose: wxPreferencesEditorImpl declaration.
// Author: Vaclav Slavik
// Created: 2013-02-19
// Copyright: (c) 2013 Vaclav Slavik <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_PREFERENCES_H_
#define _WX_PRIVATE_PREFERENCES_H_
#include "wx/preferences.h"
#if wxUSE_TOOLBAR && defined(__WXOSX_COCOA__) && wxOSX_USE_NATIVE_TOOLBAR
#define wxHAS_PREF_EDITOR_NATIVE
#endif
// ----------------------------------------------------------------------------
// wxPreferencesEditorImpl: defines wxPreferencesEditor implementation.
// ----------------------------------------------------------------------------
class wxPreferencesEditorImpl
{
public:
// This is implemented in a platform-specific way.
static wxPreferencesEditorImpl* Create(const wxString& title);
// These methods simply mirror the public wxPreferencesEditor ones.
virtual void AddPage(wxPreferencesPage* page) = 0;
virtual void Show(wxWindow* parent) = 0;
virtual void Dismiss() = 0;
virtual ~wxPreferencesEditorImpl() {}
protected:
wxPreferencesEditorImpl() {}
};
#endif // _WX_PRIVATE_PREFERENCES_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/display.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/display.h
// Purpose: wxDisplayImpl class declaration
// Author: Vadim Zeitlin
// Created: 2006-03-15
// Copyright: (c) 2002-2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_DISPLAY_H_
#define _WX_PRIVATE_DISPLAY_H_
#include "wx/display.h"
#include "wx/gdicmn.h" // for wxRect
#include "wx/vector.h"
// ----------------------------------------------------------------------------
// wxDisplayFactory: allows to create wxDisplay objects
// ----------------------------------------------------------------------------
class wxDisplayFactory
{
public:
wxDisplayFactory() { }
virtual ~wxDisplayFactory();
// Create the display if necessary using CreateDisplay(), otherwise just
// get it from cache.
wxDisplayImpl* GetDisplay(unsigned n)
{
if ( m_impls.empty() )
m_impls.resize(GetCount());
else if ( m_impls[n] )
return m_impls[n];
m_impls[n] = CreateDisplay(n);
return m_impls[n];
}
// get the total number of displays
virtual unsigned GetCount() = 0;
// return the display for the given point or wxNOT_FOUND
virtual int GetFromPoint(const wxPoint& pt) = 0;
// return the display for the given window or wxNOT_FOUND
//
// the window pointer must not be NULL (i.e. caller should check it)
virtual int GetFromWindow(const wxWindow *window);
protected:
// create a new display object
//
// it can return a NULL pointer if the display creation failed
virtual wxDisplayImpl *CreateDisplay(unsigned n) = 0;
private:
// On-demand populated vector of wxDisplayImpl objects.
wxVector<wxDisplayImpl*> m_impls;
wxDECLARE_NO_COPY_CLASS(wxDisplayFactory);
};
// ----------------------------------------------------------------------------
// wxDisplayImpl: base class for all wxDisplay implementations
// ----------------------------------------------------------------------------
class wxDisplayImpl
{
public:
// virtual dtor for this base class
virtual ~wxDisplayImpl() { }
// return the full area of this display
virtual wxRect GetGeometry() const = 0;
// return the area of the display available for normal windows
virtual wxRect GetClientArea() const { return GetGeometry(); }
// return the depth or 0 if unknown
virtual int GetDepth() const = 0;
// return the scale factor used to convert logical pixels to physical ones
virtual double GetScaleFactor() const { return 1.0; }
// return the resolution of the display, uses GetSize(), GetScaleFactor()
// and GetSizeMM() by default but can be also overridden directly
virtual wxSize GetPPI() const;
// return the physical size of the display or (0, 0) if unknown: this is
// only used by GetPPI() implementation in the base class, so if GetPPI()
// is overridden, this one doesn't have to be implemented
virtual wxSize GetSizeMM() const { return wxSize(0, 0); }
// return the name (may be empty)
virtual wxString GetName() const { return wxString(); }
// return the index of this display
unsigned GetIndex() const { return m_index; }
// return true if this is the primary monitor (usually one with index 0)
virtual bool IsPrimary() const { return GetIndex() == 0; }
#if wxUSE_DISPLAY
// implements wxDisplay::GetModes()
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const = 0;
// get current video mode
virtual wxVideoMode GetCurrentMode() const = 0;
// change current mode, return true if succeeded, false otherwise
virtual bool ChangeMode(const wxVideoMode& mode) = 0;
#endif // wxUSE_DISPLAY
protected:
// create the object providing access to the display with the given index
wxDisplayImpl(unsigned n) : m_index(n) { }
// Compute PPI from the sizes in pixels and mm.
//
// Return (0, 0) if physical size (in mm) is not known, i.e. 0.
static wxSize ComputePPI(int pxX, int pxY, int mmX, int mmY);
// the index of this display (0 is always the primary one)
const unsigned m_index;
friend class wxDisplayFactory;
wxDECLARE_NO_COPY_CLASS(wxDisplayImpl);
};
// ----------------------------------------------------------------------------
// wxDisplayImplSingle: the simplest possible impl for the main display only
// ----------------------------------------------------------------------------
// Note that this is still an ABC and GetGeometry() and GetClientArea() methods
// must be implemented in the derived classes.
class WXDLLEXPORT wxDisplayImplSingle : public wxDisplayImpl
{
public:
wxDisplayImplSingle() : wxDisplayImpl(0) { }
#if wxUSE_DISPLAY
// no video modes support for us, provide just the stubs
virtual wxArrayVideoModes
GetModes(const wxVideoMode& WXUNUSED(mode)) const wxOVERRIDE
{
return wxArrayVideoModes();
}
virtual wxVideoMode GetCurrentMode() const wxOVERRIDE
{
return wxVideoMode();
}
virtual bool ChangeMode(const wxVideoMode& WXUNUSED(mode)) wxOVERRIDE
{
return false;
}
#endif // wxUSE_DISPLAY
wxDECLARE_NO_COPY_CLASS(wxDisplayImplSingle);
};
// ----------------------------------------------------------------------------
// wxDisplayFactorySingle
// ----------------------------------------------------------------------------
// This is the simplest implementation of wxDisplayFactory using single/main
// display only. It is used when wxUSE_DISPLAY == 0 because getting the size of
// the main display is always needed.
//
// Note that this is still an ABC and derived classes must implement
// CreateSingleDisplay().
class wxDisplayFactorySingle : public wxDisplayFactory
{
public:
virtual unsigned GetCount() wxOVERRIDE { return 1; }
virtual int GetFromPoint(const wxPoint& pt) wxOVERRIDE;
protected:
virtual wxDisplayImpl *CreateDisplay(unsigned n) wxOVERRIDE;
virtual wxDisplayImpl *CreateSingleDisplay() = 0;
};
#endif // _WX_PRIVATE_DISPLAY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fdioeventloopsourcehandler.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fdioeventloopsourcehandler.h
// Purpose: declares wxFDIOEventLoopSourceHandler class
// Author: Rob Bresalier, Vadim Zeitlin
// Created: 2013-06-13 (extracted from src/unix/evtloopunix.cpp)
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// (c) 2013 Rob Bresalier
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FDIO_EVENT_LOOP_SOURCE_HANDLER_H
#define _WX_PRIVATE_FDIO_EVENT_LOOP_SOURCE_HANDLER_H
#include "wx/evtloopsrc.h"
// This class is a temporary bridge between event loop sources and
// FDIODispatcher. It is going to be removed soon, when all subject interfaces
// are modified
class wxFDIOEventLoopSourceHandler : public wxFDIOHandler
{
public:
explicit wxFDIOEventLoopSourceHandler(wxEventLoopSourceHandler* handler)
: m_handler(handler)
{
}
// Just forward to the real handler.
virtual void OnReadWaiting() wxOVERRIDE { m_handler->OnReadWaiting(); }
virtual void OnWriteWaiting() wxOVERRIDE { m_handler->OnWriteWaiting(); }
virtual void OnExceptionWaiting() wxOVERRIDE { m_handler->OnExceptionWaiting(); }
protected:
wxEventLoopSourceHandler* const m_handler;
wxDECLARE_NO_COPY_CLASS(wxFDIOEventLoopSourceHandler);
};
#endif // _WX_PRIVATE_FDIO_EVENT_LOOP_SOURCE_HANDLER_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/wxprintf.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/wxprintf.h
// Purpose: wxWidgets wxPrintf() implementation
// Author: Ove Kaven
// Modified by: Ron Lee, Francesco Montorsi
// Created: 09/04/99
// Copyright: (c) wxWidgets copyright
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_WXPRINTF_H_
#define _WX_PRIVATE_WXPRINTF_H_
// ---------------------------------------------------------------------------
// headers and macros
// ---------------------------------------------------------------------------
#include "wx/crt.h"
#include "wx/log.h"
#include "wx/utils.h"
#include <string.h>
// prefer snprintf over sprintf
#if defined(__VISUALC__) || \
(defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
#define system_sprintf(buff, max, flags, data) \
::_snprintf(buff, max, flags, data)
#elif defined(HAVE_SNPRINTF)
#define system_sprintf(buff, max, flags, data) \
::snprintf(buff, max, flags, data)
#else // NB: at least sprintf() should always be available
// since 'max' is not used in this case, wxVsnprintf() should always
// ensure that 'buff' is big enough for all common needs
// (see wxMAX_SVNPRINTF_FLAGBUFFER_LEN and wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN)
#define system_sprintf(buff, max, flags, data) \
::sprintf(buff, flags, data)
#define SYSTEM_SPRINTF_IS_UNSAFE
#endif
// ---------------------------------------------------------------------------
// printf format string parsing
// ---------------------------------------------------------------------------
// some limits of our implementation
#define wxMAX_SVNPRINTF_ARGUMENTS 64
#define wxMAX_SVNPRINTF_FLAGBUFFER_LEN 32
#define wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN 512
// the conversion specifiers accepted by wxCRT_VsnprintfW
enum wxPrintfArgType
{
wxPAT_INVALID = -1,
wxPAT_INT, // %d, %i, %o, %u, %x, %X
wxPAT_LONGINT, // %ld, etc
#ifdef wxLongLong_t
wxPAT_LONGLONGINT, // %Ld, etc
#endif
wxPAT_SIZET, // %zd, etc
wxPAT_DOUBLE, // %e, %E, %f, %g, %G
wxPAT_LONGDOUBLE, // %le, etc
wxPAT_POINTER, // %p
wxPAT_CHAR, // %hc (in ANSI mode: %c, too)
wxPAT_WCHAR, // %lc (in Unicode mode: %c, too)
wxPAT_PCHAR, // %s (related to a char *)
wxPAT_PWCHAR, // %s (related to a wchar_t *)
wxPAT_NINT, // %n
wxPAT_NSHORTINT, // %hn
wxPAT_NLONGINT, // %ln
wxPAT_STAR // '*' used for width or precision
};
// an argument passed to wxCRT_VsnprintfW
union wxPrintfArg
{
int pad_int; // %d, %i, %o, %u, %x, %X
long int pad_longint; // %ld, etc
#ifdef wxLongLong_t
wxLongLong_t pad_longlongint; // %Ld, etc
#endif
size_t pad_sizet; // %zd, etc
double pad_double; // %e, %E, %f, %g, %G
long double pad_longdouble; // %le, etc
void *pad_pointer; // %p
char pad_char; // %hc (in ANSI mode: %c, too)
wchar_t pad_wchar; // %lc (in Unicode mode: %c, too)
void *pad_str; // %s
int *pad_nint; // %n
short int *pad_nshortint; // %hn
long int *pad_nlongint; // %ln
};
// helper for converting string into either char* or wchar_t* depending
// on the type of wxPrintfConvSpec<T> instantiation:
template<typename CharType> struct wxPrintfStringHelper {};
template<> struct wxPrintfStringHelper<char>
{
typedef const wxWX2MBbuf ConvertedType;
static ConvertedType Convert(const wxString& s) { return s.mb_str(); }
};
template<> struct wxPrintfStringHelper<wchar_t>
{
typedef const wxWX2WCbuf ConvertedType;
static ConvertedType Convert(const wxString& s) { return s.wc_str(); }
};
// Contains parsed data relative to a conversion specifier given to
// wxCRT_VsnprintfW and parsed from the format string
// NOTE: in C++ there is almost no difference between struct & classes thus
// there is no performance gain by using a struct here...
template<typename CharType>
class wxPrintfConvSpec
{
public:
// the position of the argument relative to this conversion specifier
size_t m_pos;
// the type of this conversion specifier
wxPrintfArgType m_type;
// the minimum and maximum width
// when one of this var is set to -1 it means: use the following argument
// in the stack as minimum/maximum width for this conversion specifier
int m_nMinWidth, m_nMaxWidth;
// does the argument need to the be aligned to left ?
bool m_bAlignLeft;
// pointer to the '%' of this conversion specifier in the format string
// NOTE: this points somewhere in the string given to the Parse() function -
// it's task of the caller ensure that memory is still valid !
const CharType *m_pArgPos;
// pointer to the last character of this conversion specifier in the
// format string
// NOTE: this points somewhere in the string given to the Parse() function -
// it's task of the caller ensure that memory is still valid !
const CharType *m_pArgEnd;
// a little buffer where formatting flags like #+\.hlqLz are stored by Parse()
// for use in Process()
char m_szFlags[wxMAX_SVNPRINTF_FLAGBUFFER_LEN];
public:
// we don't declare this as a constructor otherwise it would be called
// automatically and we don't want this: to be optimized, wxCRT_VsnprintfW
// calls this function only on really-used instances of this class.
void Init();
// Parses the first conversion specifier in the given string, which must
// begin with a '%'. Returns false if the first '%' does not introduce a
// (valid) conversion specifier and thus should be ignored.
bool Parse(const CharType *format);
// Process this conversion specifier and puts the result in the given
// buffer. Returns the number of characters written in 'buf' or -1 if
// there's not enough space.
int Process(CharType *buf, size_t lenMax, wxPrintfArg *p, size_t written);
// Loads the argument of this conversion specifier from given va_list.
bool LoadArg(wxPrintfArg *p, va_list &argptr);
private:
// An helper function of LoadArg() which is used to handle the '*' flag
void ReplaceAsteriskWith(int w);
};
template<typename CharType>
void wxPrintfConvSpec<CharType>::Init()
{
m_nMinWidth = 0;
m_nMaxWidth = 0xFFFF;
m_pos = 0;
m_bAlignLeft = false;
m_pArgPos = m_pArgEnd = NULL;
m_type = wxPAT_INVALID;
memset(m_szFlags, 0, sizeof(m_szFlags));
// this character will never be removed from m_szFlags array and
// is important when calling sprintf() in wxPrintfConvSpec::Process() !
m_szFlags[0] = '%';
}
template<typename CharType>
bool wxPrintfConvSpec<CharType>::Parse(const CharType *format)
{
bool done = false;
// temporary parse data
size_t flagofs = 1;
bool in_prec, // true if we found the dot in some previous iteration
prec_dot; // true if the dot has been already added to m_szFlags
int ilen = 0;
m_bAlignLeft = in_prec = prec_dot = false;
m_pArgPos = m_pArgEnd = format;
do
{
#define CHECK_PREC \
if (in_prec && !prec_dot) \
{ \
m_szFlags[flagofs++] = '.'; \
prec_dot = true; \
}
// what follows '%'?
const CharType ch = *(++m_pArgEnd);
switch ( ch )
{
case wxT('\0'):
return false; // not really an argument
case wxT('%'):
return false; // not really an argument
case wxT('#'):
case wxT('0'):
case wxT(' '):
case wxT('+'):
case wxT('\''):
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
break;
case wxT('-'):
CHECK_PREC
m_bAlignLeft = true;
m_szFlags[flagofs++] = char(ch);
break;
case wxT('.'):
// don't use CHECK_PREC here to avoid warning about the value
// assigned to prec_dot inside it being never used (because
// overwritten just below) from Borland in release build
if (in_prec && !prec_dot)
m_szFlags[flagofs++] = '.';
in_prec = true;
prec_dot = false;
m_nMaxWidth = 0;
// dot will be auto-added to m_szFlags if non-negative
// number follows
break;
case wxT('h'):
ilen = -1;
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
break;
case wxT('l'):
// NB: it's safe to use flagofs-1 as flagofs always start from 1
if (m_szFlags[flagofs-1] == 'l') // 'll' modifier is the same as 'L' or 'q'
ilen = 2;
else
ilen = 1;
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
break;
case wxT('q'):
case wxT('L'):
ilen = 2;
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
break;
#ifdef __WINDOWS__
// under Windows we support the special '%I64' notation as longlong
// integer conversion specifier for MSVC compatibility
// (it behaves exactly as '%lli' or '%Li' or '%qi')
case wxT('I'):
if (*(m_pArgEnd+1) == wxT('6') &&
*(m_pArgEnd+2) == wxT('4'))
{
m_pArgEnd++;
m_pArgEnd++;
ilen = 2;
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
m_szFlags[flagofs++] = '6';
m_szFlags[flagofs++] = '4';
break;
}
// else: fall-through, 'I' is MSVC equivalent of C99 'z'
wxFALLTHROUGH;
#endif // __WINDOWS__
case wxT('z'):
case wxT('Z'):
// 'z' is C99 standard for size_t and ptrdiff_t, 'Z' was used
// for this purpose in libc5 and by wx <= 2.8
ilen = 3;
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
break;
case wxT('*'):
if (in_prec)
{
CHECK_PREC
// tell Process() to use the next argument
// in the stack as maxwidth...
m_nMaxWidth = -1;
}
else
{
// tell Process() to use the next argument
// in the stack as minwidth...
m_nMinWidth = -1;
}
// save the * in our formatting buffer...
// will be replaced later by Process()
m_szFlags[flagofs++] = char(ch);
break;
case wxT('1'): case wxT('2'): case wxT('3'):
case wxT('4'): case wxT('5'): case wxT('6'):
case wxT('7'): case wxT('8'): case wxT('9'):
{
int len = 0;
CHECK_PREC
while ( (*m_pArgEnd >= CharType('0')) &&
(*m_pArgEnd <= CharType('9')) )
{
m_szFlags[flagofs++] = char(*m_pArgEnd);
len = len*10 + (*m_pArgEnd - wxT('0'));
m_pArgEnd++;
}
if (in_prec)
m_nMaxWidth = len;
else
m_nMinWidth = len;
m_pArgEnd--; // the main loop pre-increments n again
}
break;
case wxT('$'): // a positional parameter (e.g. %2$s) ?
{
if (m_nMinWidth <= 0)
break; // ignore this formatting flag as no
// numbers are preceding it
// remove from m_szFlags all digits previously added
do {
flagofs--;
} while (m_szFlags[flagofs] >= '1' &&
m_szFlags[flagofs] <= '9');
// re-adjust the offset making it point to the
// next free char of m_szFlags
flagofs++;
m_pos = m_nMinWidth;
m_nMinWidth = 0;
}
break;
case wxT('d'):
case wxT('i'):
case wxT('o'):
case wxT('u'):
case wxT('x'):
case wxT('X'):
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
if (ilen == 0)
m_type = wxPAT_INT;
else if (ilen == -1)
// NB: 'short int' value passed through '...'
// is promoted to 'int', so we have to get
// an int from stack even if we need a short
m_type = wxPAT_INT;
else if (ilen == 1)
m_type = wxPAT_LONGINT;
else if (ilen == 2)
#ifdef wxLongLong_t
m_type = wxPAT_LONGLONGINT;
#else // !wxLongLong_t
m_type = wxPAT_LONGINT;
#endif // wxLongLong_t/!wxLongLong_t
else if (ilen == 3)
m_type = wxPAT_SIZET;
done = true;
break;
case wxT('e'):
case wxT('E'):
case wxT('f'):
case wxT('g'):
case wxT('G'):
CHECK_PREC
m_szFlags[flagofs++] = char(ch);
if (ilen == 2)
m_type = wxPAT_LONGDOUBLE;
else
m_type = wxPAT_DOUBLE;
done = true;
break;
case wxT('p'):
m_type = wxPAT_POINTER;
m_szFlags[flagofs++] = char(ch);
done = true;
break;
case wxT('c'):
if (ilen == -1)
{
// in Unicode mode %hc == ANSI character
// and in ANSI mode, %hc == %c == ANSI...
m_type = wxPAT_CHAR;
}
else if (ilen == 1)
{
// in ANSI mode %lc == Unicode character
// and in Unicode mode, %lc == %c == Unicode...
m_type = wxPAT_WCHAR;
}
else
{
#if wxUSE_UNICODE
// in Unicode mode, %c == Unicode character
m_type = wxPAT_WCHAR;
#else
// in ANSI mode, %c == ANSI character
m_type = wxPAT_CHAR;
#endif
}
done = true;
break;
case wxT('s'):
if (ilen == -1)
{
// Unicode mode wx extension: we'll let %hs mean non-Unicode
// strings (when in ANSI mode, %s == %hs == ANSI string)
m_type = wxPAT_PCHAR;
}
else if (ilen == 1)
{
// in Unicode mode, %ls == %s == Unicode string
// in ANSI mode, %ls == Unicode string
m_type = wxPAT_PWCHAR;
}
else
{
#if wxUSE_UNICODE
m_type = wxPAT_PWCHAR;
#else
m_type = wxPAT_PCHAR;
#endif
}
done = true;
break;
case wxT('n'):
if (ilen == 0)
m_type = wxPAT_NINT;
else if (ilen == -1)
m_type = wxPAT_NSHORTINT;
else if (ilen >= 1)
m_type = wxPAT_NLONGINT;
done = true;
break;
default:
// bad format, don't consider this an argument;
// leave it unchanged
return false;
}
if (flagofs == wxMAX_SVNPRINTF_FLAGBUFFER_LEN)
{
wxLogDebug(wxT("Too many flags specified for a single conversion specifier!"));
return false;
}
}
while (!done);
return true; // parsing was successful
}
template<typename CharType>
void wxPrintfConvSpec<CharType>::ReplaceAsteriskWith(int width)
{
char temp[wxMAX_SVNPRINTF_FLAGBUFFER_LEN];
// find the first * in our flag buffer
char *pwidth = strchr(m_szFlags, '*');
wxCHECK_RET(pwidth, wxT("field width must be specified"));
// save what follows the * (the +1 is to skip the asterisk itself!)
strcpy(temp, pwidth+1);
if (width < 0)
{
pwidth[0] = wxT('-');
pwidth++;
}
// replace * with the actual integer given as width
#ifndef SYSTEM_SPRINTF_IS_UNSAFE
int maxlen = (m_szFlags + wxMAX_SVNPRINTF_FLAGBUFFER_LEN - pwidth) /
sizeof(*m_szFlags);
#endif
int offset = system_sprintf(pwidth, maxlen, "%d", abs(width));
// restore after the expanded * what was following it
strcpy(pwidth+offset, temp);
}
template<typename CharType>
bool wxPrintfConvSpec<CharType>::LoadArg(wxPrintfArg *p, va_list &argptr)
{
// did the '*' width/precision specifier was used ?
if (m_nMaxWidth == -1)
{
// take the maxwidth specifier from the stack
m_nMaxWidth = va_arg(argptr, int);
if (m_nMaxWidth < 0)
m_nMaxWidth = 0;
else
ReplaceAsteriskWith(m_nMaxWidth);
}
if (m_nMinWidth == -1)
{
// take the minwidth specifier from the stack
m_nMinWidth = va_arg(argptr, int);
ReplaceAsteriskWith(m_nMinWidth);
if (m_nMinWidth < 0)
{
m_bAlignLeft = !m_bAlignLeft;
m_nMinWidth = -m_nMinWidth;
}
}
switch (m_type) {
case wxPAT_INT:
p->pad_int = va_arg(argptr, int);
break;
case wxPAT_LONGINT:
p->pad_longint = va_arg(argptr, long int);
break;
#ifdef wxLongLong_t
case wxPAT_LONGLONGINT:
p->pad_longlongint = va_arg(argptr, wxLongLong_t);
break;
#endif // wxLongLong_t
case wxPAT_SIZET:
p->pad_sizet = va_arg(argptr, size_t);
break;
case wxPAT_DOUBLE:
p->pad_double = va_arg(argptr, double);
break;
case wxPAT_LONGDOUBLE:
p->pad_longdouble = va_arg(argptr, long double);
break;
case wxPAT_POINTER:
p->pad_pointer = va_arg(argptr, void *);
break;
case wxPAT_CHAR:
p->pad_char = (char)va_arg(argptr, int); // char is promoted to int when passed through '...'
break;
case wxPAT_WCHAR:
p->pad_wchar = (wchar_t)va_arg(argptr, int); // char is promoted to int when passed through '...'
break;
case wxPAT_PCHAR:
case wxPAT_PWCHAR:
p->pad_str = va_arg(argptr, void *);
break;
case wxPAT_NINT:
p->pad_nint = va_arg(argptr, int *);
break;
case wxPAT_NSHORTINT:
p->pad_nshortint = va_arg(argptr, short int *);
break;
case wxPAT_NLONGINT:
p->pad_nlongint = va_arg(argptr, long int *);
break;
case wxPAT_STAR:
// this will be handled as part of the next argument
return true;
case wxPAT_INVALID:
default:
return false;
}
return true; // loading was successful
}
template<typename CharType>
int wxPrintfConvSpec<CharType>::Process(CharType *buf, size_t lenMax, wxPrintfArg *p, size_t written)
{
// buffer to avoid dynamic memory allocation each time for small strings;
// note that this buffer is used only to hold results of number formatting,
// %s directly writes user's string in buf, without using szScratch
char szScratch[wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN];
size_t lenScratch = 0, lenCur = 0;
#define APPEND_CH(ch) \
{ \
if ( lenCur == lenMax ) \
return -1; \
\
buf[lenCur++] = ch; \
}
switch ( m_type )
{
case wxPAT_INT:
lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_int);
break;
case wxPAT_LONGINT:
lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longint);
break;
#ifdef wxLongLong_t
case wxPAT_LONGLONGINT:
lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longlongint);
break;
#endif // SIZEOF_LONG_LONG
case wxPAT_SIZET:
lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_sizet);
break;
case wxPAT_LONGDOUBLE:
lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longdouble);
break;
case wxPAT_DOUBLE:
lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_double);
break;
case wxPAT_POINTER:
lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_pointer);
break;
case wxPAT_CHAR:
case wxPAT_WCHAR:
{
wxUniChar ch;
if (m_type == wxPAT_CHAR)
ch = p->pad_char;
else // m_type == wxPAT_WCHAR
ch = p->pad_wchar;
CharType val = ch;
size_t i;
if (!m_bAlignLeft)
for (i = 1; i < (size_t)m_nMinWidth; i++)
APPEND_CH(wxT(' '));
APPEND_CH(val);
if (m_bAlignLeft)
for (i = 1; i < (size_t)m_nMinWidth; i++)
APPEND_CH(wxT(' '));
}
break;
case wxPAT_PCHAR:
case wxPAT_PWCHAR:
{
wxString s;
if ( !p->pad_str )
{
if ( m_nMaxWidth >= 6 )
s = wxT("(null)");
}
else if (m_type == wxPAT_PCHAR)
s.assign(static_cast<const char *>(p->pad_str));
else // m_type == wxPAT_PWCHAR
s.assign(static_cast<const wchar_t *>(p->pad_str));
typename wxPrintfStringHelper<CharType>::ConvertedType strbuf(
wxPrintfStringHelper<CharType>::Convert(s));
// at this point we are sure that m_nMaxWidth is positive or
// null (see top of wxPrintfConvSpec::LoadArg)
int len = wxMin((unsigned int)m_nMaxWidth, wxStrlen(strbuf));
int i;
if (!m_bAlignLeft)
{
for (i = len; i < m_nMinWidth; i++)
APPEND_CH(wxT(' '));
}
len = wxMin((unsigned int)len, lenMax-lenCur);
wxStrncpy(buf+lenCur, strbuf, len);
lenCur += len;
if (m_bAlignLeft)
{
for (i = len; i < m_nMinWidth; i++)
APPEND_CH(wxT(' '));
}
}
break;
case wxPAT_NINT:
*p->pad_nint = written;
break;
case wxPAT_NSHORTINT:
*p->pad_nshortint = (short int)written;
break;
case wxPAT_NLONGINT:
*p->pad_nlongint = written;
break;
case wxPAT_INVALID:
default:
return -1;
}
// if we used system's sprintf() then we now need to append the s_szScratch
// buffer to the given one...
switch (m_type)
{
case wxPAT_INT:
case wxPAT_LONGINT:
#ifdef wxLongLong_t
case wxPAT_LONGLONGINT:
#endif
case wxPAT_SIZET:
case wxPAT_LONGDOUBLE:
case wxPAT_DOUBLE:
case wxPAT_POINTER:
wxASSERT(lenScratch < wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN);
// NB: 1) we can compare lenMax (for CharType*, i.e. possibly
// wchar_t*) with lenScratch (char*) because this code is
// formatting integers and that will have the same length
// even in UTF-8 (the only case when char* length may be
// more than wchar_t* length of the same string)
// 2) wxStrncpy converts the 2nd argument to 1st argument's
// type transparently if their types differ, so this code
// works for both instantiations
if (lenMax < lenScratch)
{
// fill output buffer and then return -1
wxStrncpy(buf, szScratch, lenMax);
return -1;
}
wxStrncpy(buf, szScratch, lenScratch);
lenCur += lenScratch;
break;
default:
break; // all other cases were completed previously
}
return lenCur;
}
// helper that parses format string
template<typename CharType>
struct wxPrintfConvSpecParser
{
typedef wxPrintfConvSpec<CharType> ConvSpec;
wxPrintfConvSpecParser(const CharType *fmt)
{
nspecs =
nargs = 0;
posarg_present =
nonposarg_present = false;
memset(pspec, 0, sizeof(pspec));
// parse the format string
for ( const CharType *toparse = fmt; *toparse != wxT('\0'); toparse++ )
{
// skip everything except format specifications
if ( *toparse != '%' )
continue;
// also skip escaped percent signs
if ( toparse[1] == '%' )
{
toparse++;
continue;
}
ConvSpec *spec = &specs[nspecs];
spec->Init();
// attempt to parse this format specification
if ( !spec->Parse(toparse) )
continue;
// advance to the end of this specifier
toparse = spec->m_pArgEnd;
// special handling for specifications including asterisks: we need
// to reserve an extra slot (or two if asterisks were used for both
// width and precision) in specs array in this case
if ( const char *f = strchr(spec->m_szFlags, '*') )
{
unsigned numAsterisks = 1;
if ( strchr(++f, '*') )
numAsterisks++;
for ( unsigned n = 0; n < numAsterisks; n++ )
{
if ( ++nspecs == wxMAX_SVNPRINTF_ARGUMENTS )
break;
// TODO: we need to support specifiers of the form "%2$*1$s"
// (this is the same as "%*s") as if any positional arguments
// are used all asterisks must be positional as well but this
// requires a lot of changes in this code (basically we'd need
// to rewrite Parse() to return "*" and conversion itself as
// separate entries)
if ( posarg_present )
{
wxFAIL_MSG
(
wxString::Format
(
"Format string \"%s\" uses both positional "
"parameters and '*' but this is not currently "
"supported by this implementation, sorry.",
fmt
)
);
}
specs[nspecs] = *spec;
// make an entry for '*' and point to it from pspec
spec->Init();
spec->m_type = wxPAT_STAR;
pspec[nargs++] = spec;
spec = &specs[nspecs];
}
// If we hit the maximal number of arguments inside the inner
// loop, break out of the outer one as well.
if ( nspecs == wxMAX_SVNPRINTF_ARGUMENTS )
break;
}
// check if this is a positional or normal argument
if ( spec->m_pos > 0 )
{
// the positional arguments start from number 1 so we need
// to adjust the index
spec->m_pos--;
// We could be reusing an already existing argument, only
// increment their number if it's really a new one.
if ( spec->m_pos >= nargs )
{
nargs = spec->m_pos + 1;
}
else if ( pspec[spec->m_pos] ) // Had we seen it before?
{
// Check that the type specified this time is compatible
// with the previously-specified type.
wxASSERT_MSG
(
pspec[spec->m_pos]->m_type == spec->m_type,
"Positional parameter specified multiple times "
"with incompatible types."
);
}
posarg_present = true;
}
else // not a positional argument...
{
spec->m_pos = nargs++;
nonposarg_present = true;
}
// this conversion specifier is tied to the pos-th argument...
pspec[spec->m_pos] = spec;
if ( ++nspecs == wxMAX_SVNPRINTF_ARGUMENTS )
break;
}
// warn if we lost any arguments (the program probably will crash
// anyhow because of stack corruption...)
if ( nspecs == wxMAX_SVNPRINTF_ARGUMENTS )
{
wxFAIL_MSG
(
wxString::Format
(
"wxVsnprintf() currently supports only %d arguments, "
"but format string \"%s\" defines more of them.\n"
"You need to change wxMAX_SVNPRINTF_ARGUMENTS and "
"recompile if more are really needed.",
fmt, wxMAX_SVNPRINTF_ARGUMENTS
)
);
}
}
// total number of valid elements in specs
unsigned nspecs;
// total number of arguments, also number of valid elements in pspec, and
// always less than or (usually) equal to nspecs
unsigned nargs;
// all format specifications in this format string in order of their
// appearance (which may be different from arguments order)
ConvSpec specs[wxMAX_SVNPRINTF_ARGUMENTS];
// pointer to specs array element for the N-th argument
ConvSpec *pspec[wxMAX_SVNPRINTF_ARGUMENTS];
// true if any positional/non-positional parameters are used
bool posarg_present,
nonposarg_present;
};
#undef APPEND_CH
#undef CHECK_PREC
#endif // _WX_PRIVATE_WXPRINTF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/secretstore.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/secretstore.h
// Purpose: Classes used in wxSecretStore implementation only.
// Author: Vadim Zeitlin
// Created: 2016-05-27
// Copyright: (c) 2016 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_SECRETSTORE_H_
#define _WX_PRIVATE_SECRETSTORE_H_
#include "wx/object.h" // wxRefCounter
// Both of the implementation classes here are ref-counted so that the
// corresponding public objects could be copied cheaply and, in the case of
// wxSecretValue, also to avoid having the secret in more than one place in
// memory at a time.
// ----------------------------------------------------------------------------
// Class holding wxSecretValue data
// ----------------------------------------------------------------------------
// This is a common base class for our own and libsecret-based implementations.
class wxSecretValueImpl : public wxRefCounter
{
public:
wxSecretValueImpl()
{
}
virtual size_t GetSize() const = 0;
virtual const void *GetData() const = 0;
};
// Trivial common implementation of wxSecretValueImpl used under MSW and OS X.
#if defined(__WINDOWS__) || defined(__DARWIN__)
class wxSecretValueGenericImpl : public wxSecretValueImpl
{
public:
wxSecretValueGenericImpl(size_t size, const void *data)
: m_size(size),
m_data(new char[size])
{
memcpy(m_data, data, size);
}
virtual ~wxSecretValueGenericImpl()
{
if ( m_data )
{
wxSecretValue::Wipe(m_size, m_data);
delete [] m_data;
}
}
virtual size_t GetSize() const wxOVERRIDE { return m_size; }
virtual const void *GetData() const wxOVERRIDE { return m_data; }
private:
const size_t m_size;
char* const m_data;
};
#endif // MSW or OSX
// ----------------------------------------------------------------------------
// Base class for wxSecretStore implementations
// ----------------------------------------------------------------------------
// All its methods are similar to the methods of the public class except that
// they work with the implementation rather than public objects and they all
// take an extra "wxString&" output parameter which is filled with the low
// level error message in case of an error. This message will be logged by
// wxSecretStore itself, wxSecretStoreImpl methods shouldn't do any logging on
// their own.
class wxSecretStoreImpl : public wxRefCounter
{
public:
virtual bool Save(const wxString& service,
const wxString& username,
const wxSecretValueImpl& password,
wxString& errmsg) = 0;
virtual bool Load(const wxString& service,
wxString* username,
wxSecretValueImpl** password,
wxString& errmsg) const = 0;
virtual bool Delete(const wxString& service,
wxString& errmsg) = 0;
};
#endif // _WX_PRIVATE_SECRETSTORE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/addremovectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/addremovectrl.h
// Purpose: wxAddRemoveImpl helper class declaration
// Author: Vadim Zeitlin
// Created: 2015-02-04
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_ADDREMOVECTRL_H_
#define _WX_PRIVATE_ADDREMOVECTRL_H_
#include "wx/button.h"
#include "wx/sizer.h"
// ----------------------------------------------------------------------------
// wxAddRemoveImplBase: implementation-only part of wxAddRemoveCtrl, base part
// ----------------------------------------------------------------------------
class wxAddRemoveImplBase
{
public:
// Base class ctor just initializes the associated adaptor, the derived
// class is supposed to create the buttons and layout everything.
//
// Takes ownership of the adaptor pointer.
explicit wxAddRemoveImplBase(wxAddRemoveAdaptor* adaptor,
wxAddRemoveCtrl* WXUNUSED(parent),
wxWindow* ctrlItems)
: m_adaptor(adaptor)
{
ctrlItems->Bind(wxEVT_CHAR, &wxAddRemoveImplBase::OnChar, this);
}
// wxOSX implementation needs to override this as it doesn't use sizers,
// for the others it is not necessary.
virtual wxSize GetBestClientSize() const { return wxDefaultSize; }
virtual void SetButtonsToolTips(const wxString& addtip,
const wxString& removetip) = 0;
virtual ~wxAddRemoveImplBase()
{
delete m_adaptor;
}
// Event handlers which must be connected to the appropriate sources by the
// derived classes.
void OnUpdateUIAdd(wxUpdateUIEvent& event)
{
event.Enable( m_adaptor->CanAdd() );
}
void OnUpdateUIRemove(wxUpdateUIEvent& event)
{
event.Enable( m_adaptor->CanRemove() );
}
void OnAdd(wxCommandEvent& WXUNUSED(event))
{
m_adaptor->OnAdd();
}
void OnRemove(wxCommandEvent& WXUNUSED(event))
{
m_adaptor->OnRemove();
}
private:
// This event handler is connected by this class itself and doesn't need to
// be accessible to the derived classes.
void OnChar(wxKeyEvent& event)
{
switch ( event.GetKeyCode() )
{
case '+':
case WXK_INSERT:
case WXK_NUMPAD_INSERT:
if ( m_adaptor->CanAdd() )
m_adaptor->OnAdd();
return;
case '-':
case WXK_DELETE:
case WXK_NUMPAD_DELETE:
if ( m_adaptor->CanRemove() )
m_adaptor->OnRemove();
return;
}
event.Skip();
}
wxAddRemoveAdaptor* const m_adaptor;
wxDECLARE_NO_COPY_CLASS(wxAddRemoveImplBase);
};
// GTK+ uses a wxToolBar-based implementation and so doesn't need this class.
#ifndef __WXGTK__
// Base class for the ports using actual wxButtons for the "+"/"-" buttons.
class wxAddRemoveImplWithButtons : public wxAddRemoveImplBase
{
public:
explicit wxAddRemoveImplWithButtons(wxAddRemoveAdaptor* adaptor,
wxAddRemoveCtrl* parent,
wxWindow* ctrlItems)
: wxAddRemoveImplBase(adaptor, parent, ctrlItems)
{
m_btnAdd =
m_btnRemove = NULL;
}
virtual void SetButtonsToolTips(const wxString& addtip,
const wxString& removetip) wxOVERRIDE
{
m_btnAdd->SetToolTip(addtip);
m_btnRemove->SetToolTip(removetip);
}
protected:
// Must be called by the derived class ctor after creating the buttons to
// set up the event handlers.
void SetUpEvents()
{
m_btnAdd->Bind(wxEVT_UPDATE_UI,
&wxAddRemoveImplBase::OnUpdateUIAdd, this);
m_btnRemove->Bind(wxEVT_UPDATE_UI,
&wxAddRemoveImplBase::OnUpdateUIRemove, this);
m_btnAdd->Bind(wxEVT_BUTTON, &wxAddRemoveImplBase::OnAdd, this);
m_btnRemove->Bind(wxEVT_BUTTON, &wxAddRemoveImplBase::OnRemove, this);
}
wxButton *m_btnAdd,
*m_btnRemove;
wxDECLARE_NO_COPY_CLASS(wxAddRemoveImplWithButtons);
};
#endif // !wxGTK
#ifdef __WXOSX__
#include "wx/osx/private/addremovectrl.h"
#elif defined(__WXGTK20__)
#include "wx/gtk/private/addremovectrl.h"
#elif defined(__WXGTK__)
#include "wx/gtk1/private/addremovectrl.h"
#else
#include "wx/generic/private/addremovectrl.h"
#endif
#endif // _WX_PRIVATE_ADDREMOVECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/extfield.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/extfield.h
// Purpose: Declare wxExternalField helper
// Author: Vadim Zeitlin
// Created: 2017-11-21
// Copyright: (c) 2017 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_EXTFIELD_H_
#define _WX_PRIVATE_EXTFIELD_H_
// ----------------------------------------------------------------------------
// wxExternalField: store object data outside of it
// ----------------------------------------------------------------------------
// This class allows to store some data without consuming space for the objects
// that don't need it and can be useful for avoiding to add rarely used fields
// to the classes that are used by many objects, e.g. wxWindow.
//
// Note that using this class costs in speed and convenience of access to the
// field, which requires a hash lookup instead of accessing it directly. It
// also only currently works for heap-allocated fields as it's probably never
// worth using it for fields of simple types.
//
// Template parameter Object is the class that "contains" the field, Field is
// the type of the field itself and FieldMap is the hash map, defined
// separately using WX_DECLARE_HASH_MAP(), with Object* as the key and Field*
// as the value type.
template <typename Object, typename Field, typename FieldMap>
class wxExternalField
{
public:
typedef Object ObjectType;
typedef Field FieldType;
typedef FieldMap MapType;
// Store the field object to be used for the given object, replacing the
// existing one, if any.
//
// This method takes ownership of the field pointer which will be destroyed
// by EraseForObject().
static void StoreForObject(ObjectType* obj, FieldType* field)
{
const typename MapType::iterator it = ms_map.find(obj);
if ( it != ms_map.end() )
{
delete it->second;
it->second = field;
}
else
{
ms_map.insert(typename MapType::value_type(obj, field));
}
}
// Find the object for the corresponding window.
static FieldType* FromObject(ObjectType* obj)
{
const typename MapType::const_iterator it = ms_map.find(obj);
return it == ms_map.end() ? NULL : it->second;
}
// Erase the object used for the corresponding window, return true if there
// was one or false otherwise.
static bool EraseForObject(ObjectType* obj)
{
const typename MapType::iterator it = ms_map.find(obj);
if ( it == ms_map.end() )
return false;
delete it->second;
ms_map.erase(it);
return true;
}
private:
static FieldMap ms_map;
};
template <typename O, typename F, typename M>
M wxExternalField<O, F, M>::ms_map;
#endif // _WX_PRIVATE_EXTFIELD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/menuradio.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/menuradio.h
// Purpose: wxMenuRadioItemsData implementation
// Author: Vadim Zeitlin
// Modified: Artur Wieczorek: added UpdateOnInsertNonRadio()
// Created: 2017-08-12
// Copyright: (c) 2011 Vadim Zeitlin et al
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef WX_PRIVATE_MENURADIO_H_
#define WX_PRIVATE_MENURADIO_H_
#include "wx/vector.h"
// Contains the data about the radio items groups in the given menu.
class wxMenuRadioItemsData
{
public:
wxMenuRadioItemsData() { }
// Default copy ctor, assignment operator and dtor are all ok.
// Find the start and end of the group containing the given position or
// return false if it's not inside any range.
bool GetGroupRange(int pos, int *start, int *end) const
{
// We use a simple linear search here because there are not that many
// items in a menu and hence even fewer radio items ranges anyhow, so
// normally there is no need to do anything fancy (like keeping the
// array sorted and using binary search).
for ( Ranges::const_iterator it = m_ranges.begin();
it != m_ranges.end();
++it )
{
const Range& r = *it;
if ( r.start <= pos && pos <= r.end )
{
if ( start )
*start = r.start;
if ( end )
*end = r.end;
return true;
}
}
return false;
}
// Take into account the new radio item about to be added at the given
// position. The are two cases to handle:
// - If item precedes the range, the range indices have to be updated.
// - If item falls inside the range, this range is extended to include
// the item.
// Returns true if this item starts a new radio group, false if it extends
// an existing one.
bool UpdateOnInsertRadio(int pos)
{
bool inExistingGroup = false;
for ( Ranges::iterator it = m_ranges.begin();
it != m_ranges.end();
++it )
{
Range& r = *it;
if ( pos < r.start )
{
// Item is inserted before this range, update its indices.
r.start++;
r.end++;
}
else if ( pos <= r.end + 1 )
{
wxASSERT_MSG(!inExistingGroup,
wxS("Item already inserted inside another range"));
// Item is inserted in the middle of this range or immediately
// after it in which case it extends this range so make it span
// one more item in any case.
r.end++;
inExistingGroup = true;
}
//else: Item is inserted after this range, nothing to do for it.
}
if ( inExistingGroup )
return false;
// Make a new range for the group this item will belong to.
Range r;
r.start = pos;
r.end = pos;
m_ranges.push_back(r);
return true;
}
// Take into account the new non-radio item about to be added at the given
// position. The are two cases to handle:
// - If item precedes the range, the range indices have to be updated.
// - If item falls inside the range, this range has to be split into
// two new ranges.
// Returns true if existing group has been split into two subgroups.
bool UpdateOnInsertNonRadio(int pos)
{
bool wasSplit = false;
Range newRange;
for ( Ranges::iterator it = m_ranges.begin();
it != m_ranges.end();
++it )
{
Range& r = *it;
if ( pos <= r.start )
{
// Item is inserted before this range or just at its start,
// update its indices.
r.start++;
r.end++;
}
else if ( pos <= r.end )
{
wxASSERT_MSG(!wasSplit,
wxS("Item already inserted inside another range"));
// Item is inserted inside this range in which case
// it breaks the range into two parts: one ending before
// the item and one started after it.
// The new range after the item has to be stored and added to the list
// after finishing the iteration through the ranges.
newRange.start = pos + 1; // start after the item
newRange.end = r.end + 1; // inherits current end "moved up" by one item
wasSplit = true;
// Current range ends just before the item position.
r.end = pos - 1;
}
//else: Item is inserted after this range, nothing to do for it.
}
if ( !wasSplit )
return false;
// Add a split range to the list.
m_ranges.push_back(newRange);
return true;
}
// Update the ranges of the existing radio groups after removing the menu
// item at the given position.
//
// The item being removed can be the item of any kind, not only the radio
// button belonging to the radio group, and this function checks for it
// and, as a side effect, returns true if this item was found inside an
// existing radio group.
bool UpdateOnRemoveItem(int pos)
{
bool inExistingGroup = false;
// Pointer to (necessarily unique) empty group which could be left
// after removing the last radio button from it.
Ranges::iterator itEmptyGroup = m_ranges.end();
for ( Ranges::iterator it = m_ranges.begin();
it != m_ranges.end();
++it )
{
Range& r = *it;
if ( pos < r.start )
{
// Removed item was positioned before this range, update its
// indices.
r.start--;
r.end--;
}
else if ( pos <= r.end )
{
// Removed item belongs to this radio group (it is a radio
// button), update index of its end.
r.end--;
// Check if empty group left after removal.
// If so, it will be deleted later on.
if ( r.end < r.start )
itEmptyGroup = it;
inExistingGroup = true;
}
//else: Removed item was after this range, nothing to do for it.
}
// Remove empty group from the list.
if ( itEmptyGroup != m_ranges.end() )
m_ranges.erase(itEmptyGroup);
return inExistingGroup;
}
private:
// Contains the inclusive positions of the range start and end.
struct Range
{
int start;
int end;
};
typedef wxVector<Range> Ranges;
Ranges m_ranges;
};
#endif // WX_PRIVATE_MENURADIO_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/notifmsg.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/notifmsg.h
// Purpose: wxNotificationMessage declarations
// Author: Tobias Taschner
// Created: 2015-08-04
// Copyright: (c) 2015 wxWidgets development team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_NOTIFMSG_H_
#define _WX_PRIVATE_NOTIFMSG_H_
class wxNotificationMessageImpl
{
public:
wxNotificationMessageImpl(wxNotificationMessageBase* notification):
m_notification(notification),
m_active(false)
{
}
virtual ~wxNotificationMessageImpl() { }
virtual bool Show(int timeout) = 0;
virtual bool Close() = 0;
virtual void SetTitle(const wxString& title) = 0;
virtual void SetMessage(const wxString& message) = 0;
virtual void SetParent(wxWindow *parent) = 0;
virtual void SetFlags(int flags) = 0;
virtual void SetIcon(const wxIcon& icon) = 0;
virtual bool AddAction(wxWindowID actionid, const wxString &label) = 0;
virtual void Detach()
{
if (m_active)
m_notification = NULL;
else
delete this;
}
bool ProcessNotificationEvent(wxEvent& event)
{
if (m_notification)
return m_notification->ProcessEvent(event);
else
return false;
}
wxNotificationMessageBase* GetNotification() const
{
return m_notification;
}
protected:
wxNotificationMessageBase* m_notification;
bool m_active;
void SetActive(bool active)
{
m_active = active;
// Delete the implementation if the notification is detached
if (!m_notification && !active)
delete this;
}
};
#endif // _WX_PRIVATE_NOTIFMSG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/flagscheck.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/flagscheck.h
// Purpose: helpers for checking that (bit)flags don't overlap
// Author: Vaclav Slavik
// Created: 2008-02-21
// Copyright: (c) 2008 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FLAGSCHECK_H_
#define _WX_PRIVATE_FLAGSCHECK_H_
#include "wx/debug.h"
// IBM xlC 8 can't parse the template syntax
#if !defined(__IBMCPP__)
#include "wx/meta/if.h"
namespace wxPrivate
{
// These templates are used to implement wxADD_FLAG macro below.
//
// The idea is that we want to trigger *compilation* error if the flags
// overlap, not just runtime assert failure. We can't implement the check
// using just a simple logical operation, we need checks equivalent to this
// code:
//
// mask = wxFLAG_1;
// assert( (mask & wxFLAG_2) == 0 ); // no overlap
// mask |= wxFLAG_3;
// assert( (mask & wxFLAG_3) == 0 ); // no overlap
// mask |= wxFLAG_3;
// ...
//
// This can be done at compilation time by using templates metaprogramming
// technique that makes the compiler carry on the computation.
//
// NB: If any of this doesn't compile with your compiler and would be too
// hard to make work, it's probably best to disable this code and replace
// the macros below with empty stubs, this isn't anything critical.
template<int val> struct FlagsHaveConflictingValues
{
// no value here - triggers compilation error
};
template<int val> struct FlagValue
{
enum { value = val };
};
// This template adds its template parameter integer 'add' to another integer
// 'all' and produces their OR-combination (all | add). The result is "stored"
// as constant SafelyAddToMask<>::value. Combination of many flags is achieved
// by chaining parameter lists: the 'add' parameter is value member of
// another (different) SafelyAddToMask<> instantiation.
template<int all, int add> struct SafelyAddToMask
{
// This typedefs ensures that no flags in the list conflict. If there's
// any overlap between the already constructed part of the mask ('all')
// and the value being added to it ('add'), the test that is wxIf<>'s
// first parameter will be non-zero and so Added value will be
// FlagsHaveConflictingValues<add>. The next statement will try to use
// AddedValue::value, but there's no such thing in
// FlagsHaveConflictingValues<> and so compilation will fail.
typedef typename wxIf<(all & add) == 0,
FlagValue<add>,
FlagsHaveConflictingValues<add> >::value
AddedValue;
enum { value = all | AddedValue::value };
};
} // wxPrivate namespace
// This macro is used to ensure that no two flags that can be combined in
// the same integer value have overlapping bits. This is sometimes not entirely
// trivial to ensure, for example in wxWindow styles or flags for wxSizerItem
// that span several enums, some of them used for multiple purposes.
//
// By constructing allowed flags mask using wxADD_FLAG macro and then using
// this mask to check flags passed as arguments, you can ensure that
//
// a) if any of the allowed flags overlap, you will get compilation error
// b) if invalid flag is used, there will be an assert at runtime
//
// Example usage:
//
// static const int SIZER_FLAGS_MASK =
// wxADD_FLAG(wxCENTRE,
// wxADD_FLAG(wxHORIZONTAL,
// wxADD_FLAG(wxVERTICAL,
// ...
// 0))...);
//
// And wherever flags are used:
//
// wxASSERT_VALID_FLAG( m_flag, SIZER_FLAGS_MASK );
#define wxADD_FLAG(f, others) \
::wxPrivate::SafelyAddToMask<f, others>::value
#else
#define wxADD_FLAG(f, others) (f | others)
#endif
// Checks if flags value 'f' is within the mask of allowed values
#define wxASSERT_VALID_FLAGS(f, mask) \
wxASSERT_MSG( (f & mask) == f, \
"invalid flag: not within " #mask )
#endif // _WX_PRIVATE_FLAGSCHECK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/richtooltip.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/richtooltip.h
// Purpose: wxRichToolTipImpl declaration.
// Author: Vadim Zeitlin
// Created: 2011-10-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_RICHTOOLTIP_H_
#define _WX_PRIVATE_RICHTOOLTIP_H_
#include "wx/richtooltip.h"
// ----------------------------------------------------------------------------
// wxRichToolTipImpl: defines wxRichToolTip implementation.
// ----------------------------------------------------------------------------
class wxRichToolTipImpl
{
public:
// This is implemented in a platform-specific way.
static wxRichToolTipImpl* Create(const wxString& title,
const wxString& message);
// These methods simply mirror the public wxRichToolTip ones.
virtual void SetBackgroundColour(const wxColour& col,
const wxColour& colEnd) = 0;
virtual void SetCustomIcon(const wxIcon& icon) = 0;
virtual void SetStandardIcon(int icon) = 0;
virtual void SetTimeout(unsigned milliseconds,
unsigned millisecondsShowdelay = 0) = 0;
virtual void SetTipKind(wxTipKind tipKind) = 0;
virtual void SetTitleFont(const wxFont& font) = 0;
virtual void ShowFor(wxWindow* win, const wxRect* rect = NULL) = 0;
virtual ~wxRichToolTipImpl() { }
protected:
wxRichToolTipImpl() { }
};
#endif // _WX_PRIVATE_RICHTOOLTIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/tlwgeom.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/tlwgeom.h
// Purpose: Declaration of platform-specific and private wxTLWGeometry.
// Author: Vadim Zeitlin
// Created: 2018-04-29
// Copyright: (c) 2018 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_TLWGEOM_H_
#define _WX_PRIVATE_TLWGEOM_H_
#include "wx/display.h"
#include "wx/toplevel.h"
// ----------------------------------------------------------------------------
// wxTLWGeometryBase: abstract base class for platform-specific classes
// ----------------------------------------------------------------------------
// wxTLWGeometry contains full information about the window geometry, which may
// include things other than the obvious ones like its current position and
// size (e.g. under MSW it also stores the position of the maximized window,
// under GTK the size of non-client decorations etc). It is private to wx and
// is only used indirectly, via wxTopLevelWindow::SaveGeometry() and
// RestoreToGeometry() methods, in the public API.
class wxTLWGeometryBase
{
public:
typedef wxTopLevelWindow::GeometrySerializer Serializer;
wxTLWGeometryBase() {}
virtual ~wxTLWGeometryBase() {}
// Initialize from the given window.
virtual bool GetFrom(const wxTopLevelWindow* tlw) = 0;
// Resize the window to use this geometry.
virtual bool ApplyTo(wxTopLevelWindow* tlw) = 0;
// Serialize or deserialize the object by using the provided object for
// writing/reading the values of the different fields of this object.
virtual bool Save(const Serializer& ser) const = 0;
virtual bool Restore(Serializer& ser) = 0;
};
// ----------------------------------------------------------------------------
// wxTLWGeometryGeneric: simplest possible generic implementation
// ----------------------------------------------------------------------------
// names for various persistent options
#define wxPERSIST_TLW_X "x"
#define wxPERSIST_TLW_Y "y"
#define wxPERSIST_TLW_W "w"
#define wxPERSIST_TLW_H "h"
#define wxPERSIST_TLW_MAXIMIZED "Maximized"
#define wxPERSIST_TLW_ICONIZED "Iconized"
// MSW has its own native implementation and doesn't use this class.
#ifndef __WXMSW__
class wxTLWGeometryGeneric : public wxTLWGeometryBase
{
public:
wxTLWGeometryGeneric()
{
m_hasPos =
m_hasSize =
m_iconized =
m_maximized = false;
}
virtual bool Save(const Serializer& ser) const wxOVERRIDE
{
if ( !ser.SaveField(wxPERSIST_TLW_X, m_rectScreen.x) ||
!ser.SaveField(wxPERSIST_TLW_Y, m_rectScreen.y) )
return false;
if ( !ser.SaveField(wxPERSIST_TLW_W, m_rectScreen.width) ||
!ser.SaveField(wxPERSIST_TLW_H, m_rectScreen.height) )
return false;
if ( !ser.SaveField(wxPERSIST_TLW_MAXIMIZED, m_maximized) )
return false;
if ( !ser.SaveField(wxPERSIST_TLW_ICONIZED, m_iconized) )
return false;
return true;
}
virtual bool Restore(Serializer& ser) wxOVERRIDE
{
m_hasPos = ser.RestoreField(wxPERSIST_TLW_X, &m_rectScreen.x) &&
ser.RestoreField(wxPERSIST_TLW_Y, &m_rectScreen.y);
m_hasSize = ser.RestoreField(wxPERSIST_TLW_W, &m_rectScreen.width) &&
ser.RestoreField(wxPERSIST_TLW_H, &m_rectScreen.height);
int tmp;
if ( ser.RestoreField(wxPERSIST_TLW_MAXIMIZED, &tmp) )
m_maximized = tmp != 0;
if ( ser.RestoreField(wxPERSIST_TLW_ICONIZED, &tmp) )
m_iconized = tmp != 0;
// If we restored at least something, return true.
return m_hasPos || m_hasSize || m_maximized || m_iconized;
}
virtual bool GetFrom(const wxTopLevelWindow* tlw) wxOVERRIDE
{
m_rectScreen = tlw->GetScreenRect();
m_hasPos =
m_hasSize = true;
m_iconized = tlw->IsIconized();
m_maximized = tlw->IsMaximized();
return true;
}
virtual bool ApplyTo(wxTopLevelWindow* tlw) wxOVERRIDE
{
if ( m_hasPos )
{
// to avoid making the window completely invisible if it had been
// shown on a monitor which was disconnected since the last run
// (this is pretty common for notebook with external displays)
//
// NB: we should allow window position to be (slightly) off screen,
// it's not uncommon to position the window so that its upper
// left corner has slightly negative coordinate
if ( wxDisplay::GetFromPoint(m_rectScreen.GetTopLeft()) != wxNOT_FOUND ||
(m_hasSize &&
wxDisplay::GetFromPoint(m_rectScreen.GetBottomRight()) != wxNOT_FOUND) )
{
tlw->Move(m_rectScreen.GetTopLeft(), wxSIZE_ALLOW_MINUS_ONE);
}
//else: should we try to adjust position/size somehow?
}
if ( m_hasSize )
{
// a previous version of the program could have saved the window
// size which used to be big enough, but which is not big enough
// any more for the new version, so check that the size we restore
// doesn't cut off parts of the window
wxSize size = m_rectScreen.GetSize();
size.IncTo(tlw->GetBestSize());
tlw->SetSize(size);
}
// note that the window can be both maximized and iconized
if ( m_maximized )
tlw->Maximize();
if ( m_iconized )
tlw->Iconize();
return true;
}
private:
wxRect m_rectScreen;
bool m_hasPos;
bool m_hasSize;
bool m_iconized;
bool m_maximized;
};
#endif // !__WXMSW__
#ifdef __WXGTK20__
#include "wx/gtk/private/tlwgeom.h"
#elif defined(__WXMSW__)
#include "wx/msw/private/tlwgeom.h"
#else
class wxTLWGeometry : public wxTLWGeometryGeneric
{
};
#endif
#endif // _WX_PRIVATE_TLWGEOM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/markupparser.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/markupparser.h
// Purpose: Classes for parsing simple markup.
// Author: Vadim Zeitlin
// Created: 2011-02-16
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_MARKUPPARSER_H_
#define _WX_PRIVATE_MARKUPPARSER_H_
#include "wx/string.h"
// ----------------------------------------------------------------------------
// wxMarkupSpanAttributes: information about attributes for a markup span.
// ----------------------------------------------------------------------------
struct wxMarkupSpanAttributes
{
enum OptionalBool
{
Unspecified = -1,
No,
Yes
};
wxMarkupSpanAttributes()
{
m_sizeKind = Size_Unspecified;
m_isBold =
m_isItalic =
m_isUnderlined =
m_isStrikethrough = Unspecified;
}
// If a string is empty, it means that the corresponding attribute is not
// set.
wxString m_fgCol,
m_bgCol,
m_fontFace;
// There are many ways of specifying the size. First of all, the size may
// be relative in which case m_fontSize is either -1 or +1 meaning that
// it's one step smaller or larger than the current font. Second, it may be
// absolute in which case m_fontSize contains either the size in 1024th of
// a point (Pango convention) or its values are in [-3, 3] interval and map
// to [xx-small, xx-large] CSS-like font size specification. And finally it
// may be not specified at all, of course, in which case the value of
// m_fontSize doesn't matter and it shouldn't be used.
enum
{
Size_Unspecified,
Size_Relative,
Size_Symbolic,
Size_PointParts
} m_sizeKind;
int m_fontSize;
// If the value is Unspecified, the attribute wasn't given.
OptionalBool m_isBold,
m_isItalic,
m_isUnderlined,
m_isStrikethrough;
};
// ----------------------------------------------------------------------------
// wxMarkupParserOutput: gathers the results of parsing markup.
// ----------------------------------------------------------------------------
// A class deriving directly from this one needs to implement all the pure
// virtual functions below but as the handling of all simple tags (bold, italic
// &c) is often very similar, it is usually more convenient to inherit from
// wxMarkupParserFontOutput defined in wx/private/markupparserfont.h instead.
class wxMarkupParserOutput
{
public:
wxMarkupParserOutput() { }
virtual ~wxMarkupParserOutput() { }
// Virtual functions called by wxMarkupParser while parsing the markup.
// Called for a run of normal text.
virtual void OnText(const wxString& text) = 0;
// These functions correspond to the simple tags without parameters.
virtual void OnBoldStart() = 0;
virtual void OnBoldEnd() = 0;
virtual void OnItalicStart() = 0;
virtual void OnItalicEnd() = 0;
virtual void OnUnderlinedStart() = 0;
virtual void OnUnderlinedEnd() = 0;
virtual void OnStrikethroughStart() = 0;
virtual void OnStrikethroughEnd() = 0;
virtual void OnBigStart() = 0;
virtual void OnBigEnd() = 0;
virtual void OnSmallStart() = 0;
virtual void OnSmallEnd() = 0;
virtual void OnTeletypeStart() = 0;
virtual void OnTeletypeEnd() = 0;
// The generic span start and end functions.
virtual void OnSpanStart(const wxMarkupSpanAttributes& attrs) = 0;
virtual void OnSpanEnd(const wxMarkupSpanAttributes& attrs) = 0;
private:
wxDECLARE_NO_COPY_CLASS(wxMarkupParserOutput);
};
// ----------------------------------------------------------------------------
// wxMarkupParser: parses the given markup text into wxMarkupParserOutput.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMarkupParser
{
public:
// Initialize the parser with the object that will receive parsing results.
// This object lifetime must be greater than ours.
explicit wxMarkupParser(wxMarkupParserOutput& output)
: m_output(output)
{
}
// Parse the entire string and call wxMarkupParserOutput methods.
//
// Return true if the string was successfully parsed or false if it failed
// (presumably because of syntax errors in the markup).
bool Parse(const wxString& text);
// Quote a normal string, not meant to be interpreted as markup, so that it
// produces the same string when parsed as markup. This means, for example,
// replacing '<' in the input string with "<" to prevent them from being
// interpreted as tag opening characters.
static wxString Quote(const wxString& text);
// Strip markup from a string, i.e. simply remove all tags and replace
// XML entities with their values (or with "&&" in case of "&" to
// prevent it from being interpreted as mnemonic marker).
static wxString Strip(const wxString& text);
private:
// Simple struct combining the name of a tag and its attributes.
struct TagAndAttrs
{
TagAndAttrs(const wxString& name_) : name(name_) { }
wxString name;
wxMarkupSpanAttributes attrs;
};
// Call the wxMarkupParserOutput method corresponding to the given tag.
//
// Return false if the tag doesn't match any of the known ones.
bool OutputTag(const TagAndAttrs& tagAndAttrs, bool start);
// Parse the attributes and fill the provided TagAndAttrs object with the
// information about them. Does nothing if attrs string is empty.
//
// Returns empty string on success of a [fragment of an] error message if
// we failed to parse the attributes.
wxString ParseAttrs(wxString attrs, TagAndAttrs& tagAndAttrs);
wxMarkupParserOutput& m_output;
wxDECLARE_NO_COPY_CLASS(wxMarkupParser);
};
#endif // _WX_PRIVATE_MARKUPPARSER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fdiohandler.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fdiohandler.h
// Purpose: declares wxFDIOHandler class
// Author: Vadim Zeitlin
// Created: 2009-08-17
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FDIOHANDLER_H_
#define _WX_PRIVATE_FDIOHANDLER_H_
// ----------------------------------------------------------------------------
// wxFDIOHandler: interface used to process events on file descriptors
// ----------------------------------------------------------------------------
class wxFDIOHandler
{
public:
wxFDIOHandler() { m_regmask = 0; }
// called when descriptor is available for non-blocking read
virtual void OnReadWaiting() = 0;
// called when descriptor is available for non-blocking write
virtual void OnWriteWaiting() = 0;
// called when there is exception on descriptor
virtual void OnExceptionWaiting() = 0;
// called to check if the handler is still valid, only used by
// wxSocketImplUnix currently
virtual bool IsOk() const { return true; }
// get/set the mask of events for which we're currently registered for:
// it's a combination of wxFDIO_{INPUT,OUTPUT,EXCEPTION}
int GetRegisteredEvents() const { return m_regmask; }
void SetRegisteredEvent(int flag) { m_regmask |= flag; }
void ClearRegisteredEvent(int flag) { m_regmask &= ~flag; }
// virtual dtor for the base class
virtual ~wxFDIOHandler() { }
private:
int m_regmask;
wxDECLARE_NO_COPY_CLASS(wxFDIOHandler);
};
#endif // _WX_PRIVATE_FDIOHANDLER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fdiodispatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fdiodispatcher.h
// Purpose: classes for dispatching IO notifications for file descriptors
// Authors: Lukasz Michalski
// Created: December 2006
// Copyright: (c) Lukasz Michalski
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FDIODISPATCHER_H_
#define _WX_PRIVATE_FDIODISPATCHER_H_
#include "wx/hashmap.h"
#include "wx/private/fdiohandler.h"
// those flags describes sets where descriptor should be added
enum wxFDIODispatcherEntryFlags
{
wxFDIO_INPUT = 1,
wxFDIO_OUTPUT = 2,
wxFDIO_EXCEPTION = 4,
wxFDIO_ALL = wxFDIO_INPUT | wxFDIO_OUTPUT | wxFDIO_EXCEPTION
};
// base class for wxSelectDispatcher and wxEpollDispatcher
class WXDLLIMPEXP_BASE wxFDIODispatcher
{
public:
enum { TIMEOUT_INFINITE = -1 };
// return the global dispatcher to be used for IO events, can be NULL only
// if wxSelectDispatcher wasn't compiled into the library at all as
// creating it never fails
//
// don't delete the returned pointer
static wxFDIODispatcher *Get();
// if we have any registered handlers, check for any pending events to them
// and dispatch them -- this is used from wxX11 and wxDFB event loops
// implementation
static void DispatchPending();
// register handler for the given descriptor with the dispatcher, return
// true on success or false on error
virtual bool RegisterFD(int fd, wxFDIOHandler *handler, int flags) = 0;
// modify descriptor flags or handler, return true on success
virtual bool ModifyFD(int fd, wxFDIOHandler *handler, int flags) = 0;
// unregister descriptor previously registered with RegisterFD()
virtual bool UnregisterFD(int fd) = 0;
// check if any events are currently available without dispatching them
virtual bool HasPending() const = 0;
// wait for an event for at most timeout milliseconds and process it;
// return the number of events processed (possibly 0 if timeout expired) or
// -1 if an error occurred
virtual int Dispatch(int timeout = TIMEOUT_INFINITE) = 0;
virtual ~wxFDIODispatcher() { }
};
//entry for wxFDIOHandlerMap
struct wxFDIOHandlerEntry
{
wxFDIOHandlerEntry()
{
}
wxFDIOHandlerEntry(wxFDIOHandler *handler_, int flags_)
: handler(handler_),
flags(flags_)
{
}
wxFDIOHandler *handler;
int flags;
};
// this hash is used to map file descriptors to their handlers
WX_DECLARE_HASH_MAP(
int,
wxFDIOHandlerEntry,
wxIntegerHash,
wxIntegerEqual,
wxFDIOHandlerMap
);
// FDIODispatcher that holds map fd <-> FDIOHandler, this should be used if
// this map isn't maintained elsewhere already as it is usually needed anyhow
//
// notice that all functions for FD management have implementation
// in the base class and should be called from the derived classes
class WXDLLIMPEXP_BASE wxMappedFDIODispatcher : public wxFDIODispatcher
{
public:
// find the handler for the given fd, return NULL if none
wxFDIOHandler *FindHandler(int fd) const;
// register handler for the given descriptor with the dispatcher, return
// true on success or false on error
virtual bool RegisterFD(int fd, wxFDIOHandler *handler, int flags) wxOVERRIDE;
// modify descriptor flags or handler, return true on success
virtual bool ModifyFD(int fd, wxFDIOHandler *handler, int flags) wxOVERRIDE;
// unregister descriptor previously registered with RegisterFD()
virtual bool UnregisterFD(int fd) wxOVERRIDE;
virtual ~wxMappedFDIODispatcher() { }
protected:
// the fd -> handler map containing all the registered handlers
wxFDIOHandlerMap m_handlers;
};
#endif // _WX_PRIVATE_FDIODISPATCHER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fileback.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fileback.h
// Purpose: Back an input stream with memory or a file
// Author: Mike Wetherell
// Copyright: (c) 2006 Mike Wetherell
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FILEBACK_H__
#define _WX_FILEBACK_H__
#include "wx/defs.h"
#if wxUSE_FILESYSTEM
#include "wx/stream.h"
// ----------------------------------------------------------------------------
// Backs an input stream with memory or a file to make it seekable.
//
// One or more wxBackedInputStreams can be used to read it's data. The data is
// reference counted, so stays alive until the last wxBackingFile or
// wxBackedInputStream using it is destroyed.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxBackingFile
{
public:
enum { DefaultBufSize = 16384 };
// Takes ownership of stream. If the stream is smaller than bufsize, the
// backing file is never created and the backing is done with memory.
wxBackingFile(wxInputStream *stream,
size_t bufsize = DefaultBufSize,
const wxString& prefix = wxT("wxbf"));
wxBackingFile() : m_impl(NULL) { }
~wxBackingFile();
wxBackingFile(const wxBackingFile& backer);
wxBackingFile& operator=(const wxBackingFile& backer);
operator bool() const { return m_impl != NULL; }
private:
class wxBackingFileImpl *m_impl;
friend class wxBackedInputStream;
};
// ----------------------------------------------------------------------------
// An input stream to read from a wxBackingFile.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxBackedInputStream : public wxInputStream
{
public:
wxBackedInputStream(const wxBackingFile& backer);
// If the length of the backer's parent stream is unknown then GetLength()
// returns wxInvalidOffset until the parent has been read to the end.
wxFileOffset GetLength() const wxOVERRIDE;
// Returns the length, reading the parent stream to the end if necessary.
wxFileOffset FindLength() const;
bool IsSeekable() const wxOVERRIDE { return true; }
protected:
size_t OnSysRead(void *buffer, size_t size) wxOVERRIDE;
wxFileOffset OnSysSeek(wxFileOffset pos, wxSeekMode mode) wxOVERRIDE;
wxFileOffset OnSysTell() const wxOVERRIDE;
private:
wxBackingFile m_backer;
wxFileOffset m_pos;
wxDECLARE_NO_COPY_CLASS(wxBackedInputStream);
};
#endif // wxUSE_FILESYSTEM
#endif // _WX_FILEBACK_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/textmeasure.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/textmeasure.h
// Purpose: declaration of wxTextMeasure class
// Author: Manuel Martin
// Created: 2012-10-05
// Copyright: (c) 1997-2012 wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_TEXTMEASURE_H_
#define _WX_PRIVATE_TEXTMEASURE_H_
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxFont;
class WXDLLIMPEXP_FWD_CORE wxWindow;
// ----------------------------------------------------------------------------
// wxTextMeasure: class used to measure text extent.
// ----------------------------------------------------------------------------
class wxTextMeasureBase
{
public:
// The first ctor argument must be non-NULL, i.e. each object of this class
// is associated with either a valid wxDC or a valid wxWindow. The font can
// be NULL to use the current DC/window font or can be specified explicitly.
wxTextMeasureBase(const wxDC *dc, const wxFont *theFont);
wxTextMeasureBase(const wxWindow *win, const wxFont *theFont);
// Even though this class is not supposed to be used polymorphically, give
// it a virtual dtor to avoid compiler warnings.
virtual ~wxTextMeasureBase() { }
// Return the extent of a single line string.
void GetTextExtent(const wxString& string,
wxCoord *width,
wxCoord *height,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL);
// The same for a multiline (with '\n') string.
void GetMultiLineTextExtent(const wxString& text,
wxCoord *width,
wxCoord *height,
wxCoord *heightOneLine = NULL);
// Find the dimensions of the largest string.
wxSize GetLargestStringExtent(size_t n, const wxString* strings);
wxSize GetLargestStringExtent(const wxArrayString& strings)
{
return GetLargestStringExtent(strings.size(), &strings[0]);
}
// Fill the array with the widths for each "0..N" substrings for N from 1
// to text.length().
//
// The scaleX argument is the horizontal scale used by wxDC and is only
// used in the generic implementation.
bool GetPartialTextExtents(const wxString& text,
wxArrayInt& widths,
double scaleX);
// This is another method which is only used by MeasuringGuard.
bool IsUsingDCImpl() const { return m_useDCImpl; }
protected:
// RAII wrapper for the two methods above.
class MeasuringGuard
{
public:
MeasuringGuard(wxTextMeasureBase& tm) : m_tm(tm)
{
// BeginMeasuring() should only be called if we have a native DC,
// so don't call it if we delegate to a DC of unknown type.
if ( !m_tm.IsUsingDCImpl() )
m_tm.BeginMeasuring();
}
~MeasuringGuard()
{
if ( !m_tm.IsUsingDCImpl() )
m_tm.EndMeasuring();
}
private:
wxTextMeasureBase& m_tm;
};
// These functions are called by our public methods before and after each
// call to DoGetTextExtent(). Derived classes may override them to prepare
// for -- possibly several -- subsequent calls to DoGetTextExtent().
//
// As these calls must be always paired, they're never called directly but
// only by our friend MeasuringGuard class.
virtual void BeginMeasuring() { }
virtual void EndMeasuring() { }
// The main function of this class, to be implemented in platform-specific
// way used by all our public methods.
//
// The width and height pointers here are never NULL and the input string
// is not empty.
virtual void DoGetTextExtent(const wxString& string,
wxCoord *width,
wxCoord *height,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL) = 0;
// The real implementation of GetPartialTextExtents().
//
// On input, widths array contains text.length() zero elements and the text
// is guaranteed to be non-empty.
virtual bool DoGetPartialTextExtents(const wxString& text,
wxArrayInt& widths,
double scaleX) = 0;
// Call either DoGetTextExtent() or wxDC::GetTextExtent() depending on the
// value of m_useDCImpl.
//
// This must be always used instead of calling DoGetTextExtent() directly!
void CallGetTextExtent(const wxString& string,
wxCoord *width,
wxCoord *height,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL);
// Return a valid font: if one was given to us in the ctor, use this one,
// otherwise use the current font of the associated wxDC or wxWindow.
wxFont GetFont() const;
// Exactly one of m_dc and m_win is non-NULL for any given object of this
// class.
const wxDC* const m_dc;
const wxWindow* const m_win;
// If this is true, simply forward to wxDC::GetTextExtent() from our
// CallGetTextExtent() instead of calling our own DoGetTextExtent().
//
// We need this because our DoGetTextExtent() typically only works with
// native DCs, i.e. those having an HDC under Windows or using Pango under
// GTK+. However wxTextMeasure object can be constructed for any wxDC, not
// necessarily a native one and in this case we must call back into the DC
// implementation of text measuring itself.
bool m_useDCImpl;
// This one can be NULL or not.
const wxFont* const m_font;
wxDECLARE_NO_COPY_CLASS(wxTextMeasureBase);
};
// Include the platform dependent class declaration, if any.
#if defined(__WXGTK20__)
#include "wx/gtk/private/textmeasure.h"
#elif defined(__WXMSW__)
#include "wx/msw/private/textmeasure.h"
#else // no platform-specific implementation of wxTextMeasure yet
#include "wx/generic/private/textmeasure.h"
#define wxUSE_GENERIC_TEXTMEASURE 1
#endif
#ifndef wxUSE_GENERIC_TEXTMEASURE
#define wxUSE_GENERIC_TEXTMEASURE 0
#endif
#endif // _WX_PRIVATE_TEXTMEASURE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/timer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/timer.h
// Purpose: Base class for wxTimer implementations
// Author: Lukasz Michalski <[email protected]>
// Created: 31.10.2006
// Copyright: (c) 2006-2007 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TIMERIMPL_H_BASE_
#define _WX_TIMERIMPL_H_BASE_
#include "wx/defs.h"
#include "wx/event.h"
#include "wx/timer.h"
// ----------------------------------------------------------------------------
// wxTimerImpl: abstract base class for wxTimer implementations
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxTimerImpl
{
public:
// default ctor, SetOwner() must be called after it (wxTimer does it)
wxTimerImpl(wxTimer *owner);
// this must be called initially but may be also called later
void SetOwner(wxEvtHandler *owner, int timerid);
// empty but virtual base class dtor, the caller is responsible for
// stopping the timer before it's destroyed (it can't be done from here as
// it's too late)
virtual ~wxTimerImpl() { }
// start the timer. When overriding call base version first.
virtual bool Start(int milliseconds = -1, bool oneShot = false);
// stop the timer, only called if the timer is really running (unlike
// wxTimer::Stop())
virtual void Stop() = 0;
// return true if the timer is running
virtual bool IsRunning() const = 0;
// this should be called by the port-specific code when the timer expires
virtual void Notify() { m_timer->Notify(); }
// the default implementation of wxTimer::Notify(): generate a wxEVT_TIMER
void SendEvent();
// accessors for wxTimer:
wxEvtHandler *GetOwner() const { return m_owner; }
int GetId() const { return m_idTimer; }
int GetInterval() const { return m_milli; }
bool IsOneShot() const { return m_oneShot; }
protected:
wxTimer *m_timer;
wxEvtHandler *m_owner;
int m_idTimer; // id passed to wxTimerEvent
int m_milli; // the timer interval
bool m_oneShot; // true if one shot
wxDECLARE_NO_COPY_CLASS(wxTimerImpl);
};
#endif // _WX_TIMERIMPL_H_BASE_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fd.h
// Purpose: private stuff for working with file descriptors
// Author: Vadim Zeitlin
// Created: 2008-11-23 (moved from wx/unix/private.h)
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FD_H_
#define _WX_PRIVATE_FD_H_
// standard Linux headers produce many warnings when used with icc so define
// our own replacements for FD_XXX macros
#if defined(__INTELC__) && defined(__LINUX__)
inline void wxFD_ZERO(fd_set *fds)
{
#pragma warning(push)
#pragma warning(disable:593)
FD_ZERO(fds);
#pragma warning(pop)
}
inline void wxFD_SET(int fd, fd_set *fds)
{
#pragma warning(push, 1)
#pragma warning(disable:1469)
FD_SET(fd, fds);
#pragma warning(pop)
}
inline bool wxFD_ISSET(int fd, fd_set *fds)
{
#pragma warning(push, 1)
#pragma warning(disable:1469)
return FD_ISSET(fd, fds);
#pragma warning(pop)
}
inline void wxFD_CLR(int fd, fd_set *fds)
{
#pragma warning(push, 1)
#pragma warning(disable:1469)
FD_CLR(fd, fds);
#pragma warning(pop)
}
#else // !__INTELC__
#define wxFD_ZERO(fds) FD_ZERO(fds)
#define wxFD_SET(fd, fds) FD_SET(fd, fds)
#define wxFD_ISSET(fd, fds) FD_ISSET(fd, fds)
#define wxFD_CLR(fd, fds) FD_CLR(fd, fds)
#endif // __INTELC__/!__INTELC__
#endif // _WX_PRIVATE_FD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/filename.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/filename.h
// Purpose: Internal declarations for src/common/filename.cpp
// Author: Mike Wetherell
// Modified by:
// Created: 2006-10-22
// Copyright: (c) 2006 Mike Wetherell
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FILENAME_H_
#define _WX_PRIVATE_FILENAME_H_
#include "wx/file.h"
#include "wx/ffile.h"
// Self deleting temp files aren't supported on all platforms. Therefore
// rather than let these be in the API, they can be used internally to
// implement classes (e.g. wxTempFileStream), that will do the clean up when
// the OS doesn't support it.
// Same usage as wxFileName::CreateTempFileName() with the extra parameter
// deleteOnClose. *deleteOnClose true on entry requests a file created with a
// delete on close flag, on exit the value of *deleteOnClose indicates whether
// available.
#if wxUSE_FILE
wxString wxCreateTempFileName(const wxString& prefix,
wxFile *fileTemp,
bool *deleteOnClose = NULL);
#endif
#if wxUSE_FFILE
wxString wxCreateTempFileName(const wxString& prefix,
wxFFile *fileTemp,
bool *deleteOnClose = NULL);
#endif
// Returns an open temp file, if possible either an unlinked open file or one
// that will delete on close. Only returns the filename if neither was
// possible, so that the caller can delete the file when done.
#if wxUSE_FILE
bool wxCreateTempFile(const wxString& prefix,
wxFile *fileTemp,
wxString *name);
#endif
#if wxUSE_FFILE
bool wxCreateTempFile(const wxString& prefix,
wxFFile *fileTemp,
wxString *name);
#endif
#endif // _WX_PRIVATE_FILENAME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/window.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/window.h
// Purpose: misc wxWindow helpers
// Author: Vaclav Slavik
// Created: 2010-01-21
// Copyright: (c) 2010 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_WINDOW_H_
#define _WX_PRIVATE_WINDOW_H_
#include "wx/gdicmn.h"
namespace wxPrivate
{
// Windows' computes dialog units using average character width over upper-
// and lower-case ASCII alphabet and not using the average character width
// metadata stored in the font; see
// http://support.microsoft.com/default.aspx/kb/145994 for detailed discussion.
//
// This helper function computes font dimensions in the same way. It works with
// either wxDC or wxWindow argument.
template<typename T>
inline wxSize GetAverageASCIILetterSize(const T& of_what)
{
const wxStringCharType *TEXT_TO_MEASURE =
wxS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
wxSize s = of_what.GetTextExtent(TEXT_TO_MEASURE);
s.x = (s.x / 26 + 1) / 2;
return s;
}
} // namespace wxPrivate
#endif // _WX_PRIVATE_WINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/pipestream.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/pipestream.h
// Purpose: Declares wxPipeInputStream and wxPipeOutputStream.
// Author: Vadim Zeitlin
// Modified by: Rob Bresalier
// Created: 2013-04-27
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// (c) 2013 Rob Bresalier
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_PIPESTREAM_H_
#define _WX_PRIVATE_PIPESTREAM_H_
#include "wx/platform.h"
// wxPipeInputStream is a platform-dependent input stream class (i.e. deriving,
// possible indirectly, from wxInputStream) for reading from a pipe, i.e. a
// pipe FD under Unix or a pipe HANDLE under MSW. It provides a single extra
// IsOpened() method.
//
// wxPipeOutputStream is similar but has no additional methods at all.
#if defined(__UNIX__) && !defined(__WINDOWS__)
#include "wx/unix/private/pipestream.h"
#elif defined(__WINDOWS__)
#include "wx/msw/private/pipestream.h"
#endif
#endif // _WX_PRIVATE_PIPESTREAM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/overlay.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/overlay.h
// Purpose: wxOverlayImpl declaration
// Author: Stefan Csomor
// Modified by:
// Created: 2006-10-20
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_OVERLAY_H_
#define _WX_PRIVATE_OVERLAY_H_
#include "wx/overlay.h"
#ifdef wxHAS_NATIVE_OVERLAY
#if defined(__WXOSX__) && wxOSX_USE_COCOA
#include "wx/osx/cocoa/private/overlay.h"
#elif defined(__WXDFB__)
#include "wx/dfb/private/overlay.h"
#else
#error "unknown native wxOverlay implementation"
#endif
#else // !wxHAS_NATIVE_OVERLAY
#include "wx/bitmap.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
// generic implementation of wxOverlay
class wxOverlayImpl
{
public:
wxOverlayImpl();
~wxOverlayImpl();
// clears the overlay without restoring the former state
// to be done eg when the window content has been changed and repainted
void Reset();
// returns true if it has been setup
bool IsOk();
void Init(wxDC* dc, int x , int y , int width , int height);
void BeginDrawing(wxDC* dc);
void EndDrawing(wxDC* dc);
void Clear(wxDC* dc);
private:
wxBitmap m_bmpSaved ;
int m_x ;
int m_y ;
int m_width ;
int m_height ;
wxWindow* m_window ;
};
#endif // wxHAS_NATIVE_OVERLAY/!wxHAS_NATIVE_OVERLAY
#endif // _WX_PRIVATE_OVERLAY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/markupparserattr.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/markupparserattr.h
// Purpose: Classes mapping markup attributes to wxFont/wxColour.
// Author: Vadim Zeitlin
// Created: 2011-02-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_MARKUPPARSERATTR_H_
#define _WX_PRIVATE_MARKUPPARSERATTR_H_
#include "wx/private/markupparser.h"
#include "wx/stack.h"
#include "wx/colour.h"
#include "wx/font.h"
// ----------------------------------------------------------------------------
// wxMarkupParserAttrOutput: simplified wxFont-using version of the above.
// ----------------------------------------------------------------------------
// This class assumes that wxFont and wxColour are used to perform all the
// markup tags and implements the base class virtual functions in terms of
// OnAttr{Start,End}() only.
//
// Notice that you still must implement OnText() inherited from the base class
// when deriving from this one.
class wxMarkupParserAttrOutput : public wxMarkupParserOutput
{
public:
// A container of font and colours with inheritance support. It holds two
// sets of attributes:
// 1. The currently specified ones from parsed tags that contain
// information on on what should change in the output; some of them
// may be invalid if only the others are affected by a change.
// 2. The _effective_ attributes that are always valid and accumulate
// all past changes as the markup is being parser; these are used
// to restore state when unwinding nested attributes.
struct Attr
{
Attr(const Attr *attrInEffect,
const wxFont& font_,
const wxColour& foreground_ = wxColour(),
const wxColour& background_ = wxColour())
: font(font_), foreground(foreground_), background(background_)
{
if (attrInEffect)
{
effectiveFont = font.IsOk() ? font : attrInEffect->effectiveFont;
effectiveForeground = foreground_.IsOk() ? foreground_ : attrInEffect->effectiveForeground;
effectiveBackground = background.IsOk() ? background : attrInEffect->effectiveBackground;
}
else
{
effectiveFont = font;
effectiveForeground = foreground;
effectiveBackground = background;
}
}
wxFont font;
wxColour foreground,
background;
wxFont effectiveFont;
wxColour effectiveForeground,
effectiveBackground;
};
// This object must be initialized with the font and colours to use
// initially, i.e. the ones used before any tags in the string.
wxMarkupParserAttrOutput(const wxFont& font,
const wxColour& foreground,
const wxColour& background)
{
m_attrs.push(Attr(NULL, font, foreground, background));
}
// Indicates the change of the font and/or colours used. Any of the
// fields of the argument may be invalid indicating that the corresponding
// attribute didn't actually change.
virtual void OnAttrStart(const Attr& attr) = 0;
// Indicates the end of the region affected by the given attributes
// (the same ones that were passed to the matching OnAttrStart(), use
// GetAttr() to get the ones that will be used from now on).
virtual void OnAttrEnd(const Attr& attr) = 0;
// Implement all pure virtual methods inherited from the base class in
// terms of our own ones.
virtual void OnBoldStart() wxOVERRIDE { DoChangeFont(&wxFont::Bold); }
virtual void OnBoldEnd() wxOVERRIDE { DoEndAttr(); }
virtual void OnItalicStart() wxOVERRIDE { DoChangeFont(&wxFont::Italic); }
virtual void OnItalicEnd() wxOVERRIDE { DoEndAttr(); }
virtual void OnUnderlinedStart() wxOVERRIDE { DoChangeFont(&wxFont::Underlined); }
virtual void OnUnderlinedEnd() wxOVERRIDE { DoEndAttr(); }
virtual void OnStrikethroughStart() wxOVERRIDE { DoChangeFont(&wxFont::Strikethrough); }
virtual void OnStrikethroughEnd() wxOVERRIDE { DoEndAttr(); }
virtual void OnBigStart() wxOVERRIDE { DoChangeFont(&wxFont::Larger); }
virtual void OnBigEnd() wxOVERRIDE { DoEndAttr(); }
virtual void OnSmallStart() wxOVERRIDE { DoChangeFont(&wxFont::Smaller); }
virtual void OnSmallEnd() wxOVERRIDE { DoEndAttr(); }
virtual void OnTeletypeStart() wxOVERRIDE
{
wxFont font(GetFont());
font.SetFamily(wxFONTFAMILY_TELETYPE);
DoSetFont(font);
}
virtual void OnTeletypeEnd() wxOVERRIDE { DoEndAttr(); }
virtual void OnSpanStart(const wxMarkupSpanAttributes& spanAttr) wxOVERRIDE
{
wxFont font(GetFont());
if ( !spanAttr.m_fontFace.empty() )
font.SetFaceName(spanAttr.m_fontFace);
FontModifier<wxFontWeight>()(spanAttr.m_isBold,
font, &wxFont::SetWeight,
wxFONTWEIGHT_NORMAL, wxFONTWEIGHT_BOLD);
FontModifier<wxFontStyle>()(spanAttr.m_isItalic,
font, &wxFont::SetStyle,
wxFONTSTYLE_NORMAL, wxFONTSTYLE_ITALIC);
FontModifier<bool>()(spanAttr.m_isUnderlined,
font, &wxFont::SetUnderlined,
false, true);
FontModifier<bool>()(spanAttr.m_isStrikethrough,
font, &wxFont::SetStrikethrough,
false, true);
switch ( spanAttr.m_sizeKind )
{
case wxMarkupSpanAttributes::Size_Unspecified:
break;
case wxMarkupSpanAttributes::Size_Relative:
if ( spanAttr.m_fontSize > 0 )
font.MakeLarger();
else
font.MakeSmaller();
break;
case wxMarkupSpanAttributes::Size_Symbolic:
// The values of font size intentionally coincide with the
// values of wxFontSymbolicSize enum elements so simply cast
// one to the other.
font.SetSymbolicSize(
static_cast<wxFontSymbolicSize>(spanAttr.m_fontSize)
);
break;
case wxMarkupSpanAttributes::Size_PointParts:
font.SetFractionalPointSize(spanAttr.m_fontSize/1024.);
break;
}
const Attr attr(&m_attrs.top(), font, spanAttr.m_fgCol, spanAttr.m_bgCol);
OnAttrStart(attr);
m_attrs.push(attr);
}
virtual void OnSpanEnd(const wxMarkupSpanAttributes& WXUNUSED(spanAttr)) wxOVERRIDE
{
DoEndAttr();
}
protected:
// Get the current attributes, i.e. the ones that should be used for
// rendering (or measuring or whatever) the text at the current position in
// the string.
//
// It may be called from OnAttrStart() to get the old attributes used
// before and from OnAttrEnd() to get the new attributes that will be used
// from now on but is mostly meant to be used from overridden OnText()
// implementations.
const Attr& GetAttr() const { return m_attrs.top(); }
// A shortcut for accessing the font of the current attribute.
const wxFont& GetFont() const { return GetAttr().font; }
private:
// Change only the font to the given one. Call OnAttrStart() to notify
// about the change and update the attributes stack.
void DoSetFont(const wxFont& font)
{
const Attr attr(&m_attrs.top(), font);
OnAttrStart(attr);
m_attrs.push(attr);
}
// Apply the given function to the font currently on top of the font stack,
// push the new font on the stack and call OnAttrStart() with it.
void DoChangeFont(wxFont (wxFont::*func)() const)
{
DoSetFont((GetFont().*func)());
}
void DoEndAttr()
{
const Attr attr(m_attrs.top());
m_attrs.pop();
OnAttrEnd(attr);
}
// A helper class used to apply the given function to a wxFont object
// depending on the value of an OptionalBool.
template <typename T>
struct FontModifier
{
FontModifier() { }
void operator()(wxMarkupSpanAttributes::OptionalBool isIt,
wxFont& font,
void (wxFont::*func)(T),
T noValue,
T yesValue)
{
switch ( isIt )
{
case wxMarkupSpanAttributes::Unspecified:
break;
case wxMarkupSpanAttributes::No:
(font.*func)(noValue);
break;
case wxMarkupSpanAttributes::Yes:
(font.*func)(yesValue);
break;
}
}
};
wxStack<Attr> m_attrs;
wxDECLARE_NO_COPY_CLASS(wxMarkupParserAttrOutput);
};
#endif // _WX_PRIVATE_MARKUPPARSERATTR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/uiaction.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/uiaction.h
// Purpose: wxUIActionSimulatorImpl declaration
// Author: Vadim Zeitlin
// Created: 2016-05-21
// Copyright: (c) 2016 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_UIACTION_H_
#define _WX_PRIVATE_UIACTION_H_
// ----------------------------------------------------------------------------
// Platform-specific implementation of wxUIActionSimulator
// ----------------------------------------------------------------------------
class wxUIActionSimulatorImpl
{
public:
wxUIActionSimulatorImpl() { }
virtual ~wxUIActionSimulatorImpl() { }
// Low level mouse methods which must be implemented in the derived class.
virtual bool MouseMove(long x, long y) = 0;
virtual bool MouseDown(int button = wxMOUSE_BTN_LEFT) = 0;
virtual bool MouseUp(int button = wxMOUSE_BTN_LEFT) = 0;
// Higher level mouse methods which have default implementation in the base
// class but can be overridden if necessary.
virtual bool MouseClick(int button = wxMOUSE_BTN_LEFT);
virtual bool MouseDblClick(int button = wxMOUSE_BTN_LEFT);
virtual bool MouseDragDrop(long x1, long y1, long x2, long y2,
int button = wxMOUSE_BTN_LEFT);
// The low-level port-specific function which really generates the key
// presses. It should generate exactly one key event with the given
// parameters.
virtual bool DoKey(int keycode, int modifiers, bool isDown) = 0;
private:
wxDECLARE_NO_COPY_CLASS(wxUIActionSimulatorImpl);
};
#endif // _WX_PRIVATE_UIACTION_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/socket.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/socket.h
// Purpose: wxSocketImpl and related declarations
// Authors: Guilhem Lavaux, Vadim Zeitlin
// Created: April 1997
// Copyright: (c) 1997 Guilhem Lavaux
// (c) 2008 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*
Brief overview of different socket classes:
- wxSocketBase is the public class representing a socket ("Base" here
refers to the fact that wxSocketClient and wxSocketServer are derived
from it and predates the convention of using "Base" for common base
classes for platform-specific classes in wxWidgets) with implementation
common to all platforms and forwarding methods whose implementation
differs between platforms to wxSocketImpl which it contains.
- wxSocketImpl is actually just an abstract base class having only code
common to all platforms, the concrete implementation classes derive from
it and are created by wxSocketImpl::Create().
- Some socket operations have different implementations in console-mode and
GUI applications. wxSocketManager class exists to abstract this in such
way that console applications (using wxBase) don't depend on wxNet. An
object of this class is made available via wxApp and GUI applications set
up a different kind of global socket manager from console ones.
TODO: it looks like wxSocketManager could be eliminated by providing
methods for registering/unregistering sockets directly in
wxEventLoop.
*/
#ifndef _WX_PRIVATE_SOCKET_H_
#define _WX_PRIVATE_SOCKET_H_
#include "wx/defs.h"
#if wxUSE_SOCKETS
#include "wx/socket.h"
#include "wx/private/sckaddr.h"
#include <stddef.h>
/*
Including sys/types.h under Cygwin results in the warnings about "fd_set
having been defined in sys/types.h" when winsock.h is included later and
doesn't seem to be necessary anyhow. It's not needed under Mac neither.
*/
#if !defined(__WXMAC__) && !defined(__WXMSW__)
#include <sys/types.h>
#endif
// include the header defining timeval: under Windows this struct is used only
// with sockets so we need to include winsock.h which we do via windows.h
#ifdef __WINDOWS__
#include "wx/msw/wrapwin.h"
#else
#include <sys/time.h> // for timeval
#endif
// 64 bit Cygwin can't use the standard struct timeval because it has long
// fields, which are supposed to be 32 bits in Win64 API, but long is 64 bits
// in 64 bit Cygwin, so we need to use its special __ms_timeval instead.
#if defined(__CYGWIN__) && defined(__LP64__)
typedef __ms_timeval wxTimeVal_t;
#else
typedef timeval wxTimeVal_t;
#endif
// these definitions are for MSW when we don't use configure, otherwise these
// symbols are defined by configure
#ifndef WX_SOCKLEN_T
#define WX_SOCKLEN_T int
#endif
#ifndef SOCKOPTLEN_T
#define SOCKOPTLEN_T int
#endif
// define some symbols which winsock.h defines but traditional BSD headers
// don't
#ifndef INVALID_SOCKET
#define INVALID_SOCKET (-1)
#endif
#ifndef SOCKET_ERROR
#define SOCKET_ERROR (-1)
#endif
typedef int wxSocketEventFlags;
class wxSocketImpl;
/*
Class providing hooks abstracting the differences between console and GUI
applications for socket code.
We also have different implementations of this class for different platforms
allowing us to keep more things in the common code but the main reason for
its existence is that we want the same socket code work differently
depending on whether it's used from a console or a GUI program. This is
achieved by implementing the virtual methods of this class differently in
the objects returned by wxConsoleAppTraits::GetSocketManager() and the same
method in wxGUIAppTraits.
*/
class wxSocketManager
{
public:
// set the manager to use, we don't take ownership of it
//
// this should be called before creating the first wxSocket object,
// otherwise the manager returned by wxAppTraits::GetSocketManager() will
// be used
static void Set(wxSocketManager *manager);
// return the manager to use
//
// this initializes the manager at first use
static wxSocketManager *Get()
{
if ( !ms_manager )
Init();
return ms_manager;
}
// called before the first wxSocket is created and should do the
// initializations needed in order to use the network
//
// return true if initialized successfully; if this returns false sockets
// can't be used at all
virtual bool OnInit() = 0;
// undo the initializations of OnInit()
virtual void OnExit() = 0;
// create the socket implementation object matching this manager
virtual wxSocketImpl *CreateSocket(wxSocketBase& wxsocket) = 0;
// these functions enable or disable monitoring of the given socket for the
// specified events inside the currently running event loop (but notice
// that both BSD and Winsock implementations actually use socket->m_server
// value to determine what exactly should be monitored so it needs to be
// set before calling these functions)
//
// the default event value is used just for the convenience of wxMSW
// implementation which doesn't use this parameter anyhow, it doesn't make
// sense to pass wxSOCKET_LOST for the Unix implementation which does use
// this parameter
virtual void Install_Callback(wxSocketImpl *socket,
wxSocketNotify event = wxSOCKET_LOST) = 0;
virtual void Uninstall_Callback(wxSocketImpl *socket,
wxSocketNotify event = wxSOCKET_LOST) = 0;
virtual ~wxSocketManager() { }
private:
// get the manager to use if we don't have it yet
static void Init();
static wxSocketManager *ms_manager;
};
/*
Base class for all socket implementations providing functionality common to
BSD and Winsock sockets.
Objects of this class are not created directly but only via the factory
function wxSocketManager::CreateSocket().
*/
class wxSocketImpl
{
public:
virtual ~wxSocketImpl();
// set various socket properties: all of those can only be called before
// creating the socket
void SetTimeout(unsigned long millisec);
void SetReusable() { m_reusable = true; }
void SetBroadcast() { m_broadcast = true; }
void DontDoBind() { m_dobind = false; }
void SetInitialSocketBuffers(int recv, int send)
{
m_initialRecvBufferSize = recv;
m_initialSendBufferSize = send;
}
wxSocketError SetLocal(const wxSockAddressImpl& address);
wxSocketError SetPeer(const wxSockAddressImpl& address);
// accessors
// ---------
bool IsServer() const { return m_server; }
const wxSockAddressImpl& GetLocal(); // non const as may update m_local
const wxSockAddressImpl& GetPeer() const { return m_peer; }
wxSocketError GetError() const { return m_error; }
bool IsOk() const { return m_error == wxSOCKET_NOERROR; }
// get the error code corresponding to the last operation
virtual wxSocketError GetLastError() const = 0;
// creating/closing the socket
// --------------------------
// notice that SetLocal() must be called before creating the socket using
// any of the functions below
//
// all of Create() functions return wxSOCKET_NOERROR if the operation
// completed successfully or one of:
// wxSOCKET_INVSOCK - the socket is in use.
// wxSOCKET_INVADDR - the local (server) or peer (client) address has not
// been set.
// wxSOCKET_IOERR - any other error.
// create a socket listening on the local address specified by SetLocal()
// (notice that DontDoBind() is ignored by this function)
wxSocketError CreateServer();
// create a socket connected to the peer address specified by SetPeer()
// (notice that DontDoBind() is ignored by this function)
//
// this function may return wxSOCKET_WOULDBLOCK in addition to the return
// values listed above if wait is false
wxSocketError CreateClient(bool wait);
// create (and bind unless DontDoBind() had been called) an UDP socket
// associated with the given local address
wxSocketError CreateUDP();
// may be called whether the socket was created or not, calls DoClose() if
// it was indeed created
void Close();
// shuts down the writing end of the socket and closes it, this is a more
// graceful way to close
//
// does nothing if the socket wasn't created
void Shutdown();
// IO operations
// -------------
// basic IO, work for both TCP and UDP sockets
//
// return the number of bytes read/written (possibly 0) or -1 on error
int Read(void *buffer, int size);
int Write(const void *buffer, int size);
// basically a wrapper for select(): returns the condition of the socket,
// blocking for not longer than timeout if it is specified (otherwise just
// poll without blocking at all)
//
// flags defines what kind of conditions we're interested in, the return
// value is composed of a (possibly empty) subset of the bits set in flags
wxSocketEventFlags Select(wxSocketEventFlags flags,
wxTimeVal_t *timeout = NULL);
// convenient wrapper calling Select() with our default timeout
wxSocketEventFlags SelectWithTimeout(wxSocketEventFlags flags)
{
return Select(flags, &m_timeout);
}
// just a wrapper for accept(): it is called to create a new wxSocketImpl
// corresponding to a new server connection represented by the given
// wxSocketBase, returns NULL on error (including immediately if there are
// no pending connections as our sockets are non-blocking)
wxSocketImpl *Accept(wxSocketBase& wxsocket);
// notifications
// -------------
// notify m_wxsocket about the given socket event by calling its (inaptly
// named) OnRequest() method
void NotifyOnStateChange(wxSocketNotify event);
// called after reading/writing the data from/to the socket and should
// enable back the wxSOCKET_INPUT/OUTPUT_FLAG notifications if they were
// turned off when this data was first detected
virtual void ReenableEvents(wxSocketEventFlags flags) = 0;
// TODO: make these fields protected and provide accessors for those of
// them that wxSocketBase really needs
//protected:
wxSOCKET_T m_fd;
int m_initialRecvBufferSize;
int m_initialSendBufferSize;
wxSockAddressImpl m_local,
m_peer;
wxSocketError m_error;
bool m_stream;
bool m_establishing;
bool m_reusable;
bool m_broadcast;
bool m_dobind;
wxTimeVal_t m_timeout;
protected:
wxSocketImpl(wxSocketBase& wxsocket);
// get the associated socket flags
wxSocketFlags GetSocketFlags() const { return m_wxsocket->GetFlags(); }
// true if we're a listening stream socket
bool m_server;
private:
// called by Close() if we have a valid m_fd
virtual void DoClose() = 0;
// put this socket into non-blocking mode and enable monitoring this socket
// as part of the event loop
virtual void UnblockAndRegisterWithEventLoop() = 0;
// check that the socket wasn't created yet and that the given address
// (either m_local or m_peer depending on the socket kind) is valid and
// set m_error and return false if this is not the case
bool PreCreateCheck(const wxSockAddressImpl& addr);
// set the given socket option: this just wraps setsockopt(SOL_SOCKET)
int SetSocketOption(int optname, int optval)
{
// although modern Unix systems use "const void *" for the 4th
// parameter here, old systems and Winsock still use "const char *"
return setsockopt(m_fd, SOL_SOCKET, optname,
reinterpret_cast<const char *>(&optval),
sizeof(optval));
}
// set the given socket option to true value: this is an even simpler
// wrapper for setsockopt(SOL_SOCKET) for boolean options
int EnableSocketOption(int optname)
{
return SetSocketOption(optname, 1);
}
// apply the options to the (just created) socket and register it with the
// event loop by calling UnblockAndRegisterWithEventLoop()
void PostCreation();
// update local address after binding/connecting
wxSocketError UpdateLocalAddress();
// functions used to implement Read/Write()
int RecvStream(void *buffer, int size);
int RecvDgram(void *buffer, int size);
int SendStream(const void *buffer, int size);
int SendDgram(const void *buffer, int size);
// set in ctor and never changed except that it's reset to NULL when the
// socket is shut down
wxSocketBase *m_wxsocket;
wxDECLARE_NO_COPY_CLASS(wxSocketImpl);
};
#if defined(__WINDOWS__)
#include "wx/msw/private/sockmsw.h"
#else
#include "wx/unix/private/sockunix.h"
#endif
#endif /* wxUSE_SOCKETS */
#endif /* _WX_PRIVATE_SOCKET_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/streamtempinput.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/streamtempinput.h
// Purpose: defines wxStreamTempInputBuffer which is used by Unix and MSW
// implementations of wxExecute; this file is only used by the
// library and never by the user code
// Author: Vadim Zeitlin
// Modified by: Rob Bresalier
// Created: 2013-05-04
// Copyright: (c) 2002 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_STREAMTEMPINPUT_H
#define _WX_PRIVATE_STREAMTEMPINPUT_H
#include "wx/private/pipestream.h"
// ----------------------------------------------------------------------------
// wxStreamTempInputBuffer
// ----------------------------------------------------------------------------
/*
wxStreamTempInputBuffer is a hack which we need to solve the problem of
executing a child process synchronously with IO redirecting: when we do
this, the child writes to a pipe we open to it but when the pipe buffer
(which has finite capacity, e.g. commonly just 4Kb) becomes full we have to
read data from it because the child blocks in its write() until then and if
it blocks we are never going to return from wxExecute() so we dead lock.
So here is the fix: we now read the output as soon as it appears into a temp
buffer (wxStreamTempInputBuffer object) and later just stuff it back into
the stream when the process terminates. See supporting code in wxExecute()
itself as well.
Note that this is horribly inefficient for large amounts of output (count
the number of times we copy the data around) and so a better API is badly
needed! However it's not easy to devise a way to do this keeping backwards
compatibility with the existing wxExecute(wxEXEC_SYNC)...
*/
class wxStreamTempInputBuffer
{
public:
wxStreamTempInputBuffer()
{
m_stream = NULL;
m_buffer = NULL;
m_size = 0;
}
// call to associate a stream with this buffer, otherwise nothing happens
// at all
void Init(wxPipeInputStream *stream)
{
wxASSERT_MSG( !m_stream, wxS("Can only initialize once") );
m_stream = stream;
}
// check for input on our stream and cache it in our buffer if any
//
// return true if anything was done
bool Update()
{
if ( !m_stream || !m_stream->CanRead() )
return false;
// realloc in blocks of 4Kb: this is the default (and minimal) buffer
// size of the Unix pipes so it should be the optimal step
//
// NB: don't use "static int" in this inline function, some compilers
// (e.g. IBM xlC) don't like it
enum { incSize = 4096 };
void *buf = realloc(m_buffer, m_size + incSize);
if ( !buf )
return false;
m_buffer = buf;
m_stream->Read((char *)m_buffer + m_size, incSize);
m_size += m_stream->LastRead();
return true;
}
// check if can continue reading from the stream, this is used to disable
// the callback once we can't read anything more
bool Eof() const
{
// If we have no stream, always return true as we can't read any more.
return !m_stream || m_stream->Eof();
}
// read everything remaining until the EOF, this should only be called once
// the child process terminates and we know that no more data is coming
bool ReadAll()
{
while ( !Eof() )
{
if ( !Update() )
return false;
}
return true;
}
// dtor puts the data buffered during this object lifetime into the
// associated stream
~wxStreamTempInputBuffer()
{
if ( m_buffer )
{
m_stream->Ungetch(m_buffer, m_size);
free(m_buffer);
}
}
const void *GetBuffer() const { return m_buffer; }
size_t GetSize() const { return m_size; }
private:
// the stream we're buffering, if NULL we don't do anything at all
wxPipeInputStream *m_stream;
// the buffer of size m_size (NULL if m_size == 0)
void *m_buffer;
// the size of the buffer
size_t m_size;
wxDECLARE_NO_COPY_CLASS(wxStreamTempInputBuffer);
};
#endif // _WX_PRIVATE_STREAMTEMPINPUT_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/sckaddr.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/sckaddr.h
// Purpose: wxSockAddressImpl
// Author: Vadim Zeitlin
// Created: 2008-12-28
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_SOCKADDR_H_
#define _WX_PRIVATE_SOCKADDR_H_
#ifdef __WINDOWS__
#include "wx/msw/wrapwin.h"
#if wxUSE_IPV6
#include <ws2tcpip.h>
#endif
#elif defined(__VMS__)
#include <socket.h>
struct sockaddr_un
{
u_char sun_len; /* sockaddr len including null */
u_char sun_family; /* AF_UNIX */
char sun_path[108]; /* path name (gag) */
};
#include <in.h>
#else // generic Unix
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/un.h>
#endif // platform
#include <stdlib.h> // for calloc()
// this is a wrapper for sockaddr_storage if it's available or just sockaddr
// otherwise
union wxSockAddressStorage
{
#if wxUSE_IPV6
sockaddr_storage addr_storage;
#endif
sockaddr addr;
};
// ----------------------------------------------------------------------------
// helpers for wxSockAddressImpl
// ----------------------------------------------------------------------------
// helper class mapping sockaddr_xxx types to corresponding AF_XXX values
template <class T> struct AddressFamily;
template <> struct AddressFamily<sockaddr_in> { enum { value = AF_INET }; };
#if wxUSE_IPV6
template <> struct AddressFamily<sockaddr_in6> { enum { value = AF_INET6 }; };
#endif // wxUSE_IPV6
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
template <> struct AddressFamily<sockaddr_un> { enum { value = AF_UNIX }; };
#endif // wxHAS_UNIX_DOMAIN_SOCKETS
// ----------------------------------------------------------------------------
// wxSockAddressImpl
// ----------------------------------------------------------------------------
// Represents a socket endpoint, e.g. an (address, port) pair for PF_INET
// sockets. It can be initialized from an existing sockaddr struct and also
// provides access to sockaddr stored internally so that it can be easily used
// with e.g. connect(2).
//
// This class also performs (synchronous, hence potentially long) name lookups
// if necessary, i.e. if the host name strings don't contain addresses in
// numerical form (quad dotted for IPv4 or standard hexadecimal for IPv6).
// Notice that internally the potentially Unicode host names are encoded as
// UTF-8 before being passed to the lookup function but the host names should
// really be ASCII anyhow.
class wxSockAddressImpl
{
public:
// as this is passed to socket() it should be a PF_XXX and not AF_XXX (even
// though they're the same in practice)
enum Family
{
FAMILY_INET = PF_INET,
#if wxUSE_IPV6
FAMILY_INET6 = PF_INET6,
#endif
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
FAMILY_UNIX = PF_UNIX,
#endif
FAMILY_UNSPEC = PF_UNSPEC
};
// default ctor creates uninitialized object, use one of CreateXXX() below
wxSockAddressImpl()
{
InitUnspec();
}
// ctor from an existing sockaddr
wxSockAddressImpl(const sockaddr& addr, int len)
{
switch ( addr.sa_family )
{
case PF_INET:
#if wxUSE_IPV6
case PF_INET6:
#endif
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
case PF_UNIX:
#endif
m_family = static_cast<Family>(addr.sa_family);
break;
default:
wxFAIL_MSG( "unsupported socket address family" );
InitUnspec();
return;
}
InitFromSockaddr(addr, len);
}
// copy ctor and assignment operators
wxSockAddressImpl(const wxSockAddressImpl& other)
{
InitFromOther(other);
}
wxSockAddressImpl& operator=(const wxSockAddressImpl& other)
{
if (this != &other)
{
free(m_addr);
InitFromOther(other);
}
return *this;
}
// dtor frees the memory used by m_addr
~wxSockAddressImpl()
{
free(m_addr);
}
// reset the address to the initial uninitialized state
void Clear()
{
free(m_addr);
InitUnspec();
}
// initialize the address to be of specific address family, it must be
// currently uninitialized (you may call Clear() to achieve this)
void CreateINET();
void CreateINET6();
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
void CreateUnix();
#endif // wxHAS_UNIX_DOMAIN_SOCKETS
void Create(Family family)
{
switch ( family )
{
case FAMILY_INET:
CreateINET();
break;
#if wxUSE_IPV6
case FAMILY_INET6:
CreateINET6();
break;
#endif // wxUSE_IPV6
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
case FAMILY_UNIX:
CreateUnix();
break;
#endif // wxHAS_UNIX_DOMAIN_SOCKETS
default:
wxFAIL_MSG( "unsupported socket address family" );
}
}
// simple accessors
Family GetFamily() const { return m_family; }
bool Is(Family family) const { return m_family == family; }
bool IsOk() const { return m_family != FAMILY_UNSPEC; }
const sockaddr *GetAddr() const { return m_addr; }
sockaddr *GetWritableAddr() { return m_addr; }
int GetLen() const { return m_len; }
// accessors for INET or INET6 address families
#if wxUSE_IPV6
#define CALL_IPV4_OR_6(func, args) \
Is(FAMILY_INET6) ? func##6(args) : func##4(args)
#define CALL_IPV4_OR_6_VOID(func) \
Is(FAMILY_INET6) ? func##6() : func##4()
#else
#define CALL_IPV4_OR_6(func, args) func##4(args)
#define CALL_IPV4_OR_6_VOID(func) func##4()
#endif // IPv6 support on/off
wxString GetHostName() const;
bool SetHostName(const wxString& name)
{
return CALL_IPV4_OR_6(SetHostName, (name));
}
wxUint16 GetPort() const { return CALL_IPV4_OR_6_VOID(GetPort); }
bool SetPort(wxUint16 port) { return CALL_IPV4_OR_6(SetPort, (port)); }
bool SetPortName(const wxString& name, const char *protocol);
bool SetToAnyAddress() { return CALL_IPV4_OR_6_VOID(SetToAnyAddress); }
#undef CALL_IPV4_OR_6
// accessors for INET addresses only
bool GetHostAddress(wxUint32 *address) const;
bool SetHostAddress(wxUint32 address);
bool SetToBroadcastAddress() { return SetHostAddress(INADDR_BROADCAST); }
// accessors for INET6 addresses only
#if wxUSE_IPV6
bool GetHostAddress(in6_addr *address) const;
bool SetHostAddress(const in6_addr& address);
#endif // wxUSE_IPV6
#ifdef wxHAS_UNIX_DOMAIN_SOCKETS
// methods valid for Unix address family addresses only
bool SetPath(const wxString& path);
wxString GetPath() const;
#endif // wxHAS_UNIX_DOMAIN_SOCKETS
private:
void DoAlloc(int len)
{
m_addr = static_cast<sockaddr *>(calloc(1, len));
m_len = len;
}
template <class T>
T *Alloc()
{
DoAlloc(sizeof(T));
return reinterpret_cast<T *>(m_addr);
}
template <class T>
T *Get() const
{
wxCHECK_MSG( static_cast<int>(m_family) == AddressFamily<T>::value,
NULL,
"socket address family mismatch" );
return reinterpret_cast<T *>(m_addr);
}
void InitUnspec()
{
m_family = FAMILY_UNSPEC;
m_addr = NULL;
m_len = 0;
}
void InitFromSockaddr(const sockaddr& addr, int len)
{
DoAlloc(len);
memcpy(m_addr, &addr, len);
}
void InitFromOther(const wxSockAddressImpl& other)
{
m_family = other.m_family;
if ( other.m_addr )
{
InitFromSockaddr(*other.m_addr, other.m_len);
}
else // no address to copy
{
m_addr = NULL;
m_len = 0;
}
}
// IPv4/6 implementations of public functions
bool SetHostName4(const wxString& name);
bool SetPort4(wxUint16 port);
wxUint16 GetPort4() const;
bool SetToAnyAddress4() { return SetHostAddress(INADDR_ANY); }
#if wxUSE_IPV6
bool SetHostName6(const wxString& name);
bool SetPort6(wxUint16 port);
wxUint16 GetPort6() const;
bool SetToAnyAddress6();
#endif // wxUSE_IPV6
Family m_family;
sockaddr *m_addr;
int m_len;
};
#endif // _WX_PRIVATE_SOCKADDR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/launchbrowser.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/launchbrowser.h
// Purpose: Helpers for wxLaunchDefaultBrowser() implementation.
// Author: Vadim Zeitlin
// Created: 2016-02-07
// Copyright: (c) 2016 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_LAUNCHBROWSER_H_
#define _WX_PRIVATE_LAUNCHBROWSER_H_
// ----------------------------------------------------------------------------
// wxLaunchBrowserParams: passed to wxDoLaunchDefaultBrowser()
// ----------------------------------------------------------------------------
struct wxLaunchBrowserParams
{
explicit wxLaunchBrowserParams(int f) : flags(f) { }
// Return either the URL or the file depending on our scheme.
const wxString& GetPathOrURL() const
{
return scheme == wxS("file") ? path : url;
}
// The URL is always specified and is the real URL, always with the scheme
// part, which can be "file://".
wxString url;
// The path is a local path which is only non-empty if the URL uses the
// "file://" scheme.
wxString path;
// The scheme of the URL, e.g. "file" or "http".
wxString scheme;
// The flags passed to wxLaunchDefaultBrowser().
int flags;
};
#endif // _WX_PRIVATE_LAUNCHBROWSER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fdiomanager.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fdiomanager.h
// Purpose: declaration of wxFDIOManager
// Author: Vadim Zeitlin
// Created: 2009-08-17
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_FDIOMANAGER_H_
#define _WX_PRIVATE_FDIOMANAGER_H_
#include "wx/private/fdiohandler.h"
// ----------------------------------------------------------------------------
// wxFDIOManager: register or unregister wxFDIOHandlers
// ----------------------------------------------------------------------------
// currently only used in wxGTK and wxMotif, see wx/unix/apptrait.h
class wxFDIOManager
{
public:
// identifies either input or output direction
//
// NB: the values of this enum shouldn't change
enum Direction
{
INPUT,
OUTPUT
};
// start or stop monitoring the events on the given file descriptor
virtual int AddInput(wxFDIOHandler *handler, int fd, Direction d) = 0;
virtual void RemoveInput(wxFDIOHandler *handler, int fd, Direction d) = 0;
// empty but virtual dtor for the base class
virtual ~wxFDIOManager() { }
};
#endif // _WX_PRIVATE_FDIOMANAGER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/private/fswatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fswatcher.h
// Purpose: File system watcher impl classes
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef WX_PRIVATE_FSWATCHER_H_
#define WX_PRIVATE_FSWATCHER_H_
#include "wx/sharedptr.h"
#ifdef wxHAS_INOTIFY
class wxFSWatchEntryUnix;
#define wxFSWatchEntry wxFSWatchEntryUnix
WX_DECLARE_STRING_HASH_MAP(wxSharedPtr<wxFSWatchEntry>,wxFSWatchEntries);
#include "wx/unix/private/fswatcher_inotify.h"
#elif defined(wxHAS_KQUEUE)
class wxFSWatchEntryKq;
#define wxFSWatchEntry wxFSWatchEntryKq
WX_DECLARE_STRING_HASH_MAP(wxSharedPtr<wxFSWatchEntry>,wxFSWatchEntries);
#include "wx/unix/private/fswatcher_kqueue.h"
#elif defined(__WINDOWS__)
class wxFSWatchEntryMSW;
#define wxFSWatchEntry wxFSWatchEntryMSW
WX_DECLARE_STRING_HASH_MAP(wxSharedPtr<wxFSWatchEntry>,wxFSWatchEntries);
#include "wx/msw/private/fswatcher.h"
#else
#define wxFSWatchEntry wxFSWatchEntryPolling
#endif
class wxFSWatcherImpl
{
public:
wxFSWatcherImpl(wxFileSystemWatcherBase* watcher) :
m_watcher(watcher)
{
}
virtual ~wxFSWatcherImpl()
{
(void) RemoveAll();
}
virtual bool Init() = 0;
virtual bool Add(const wxFSWatchInfo& winfo)
{
if ( m_watches.find(winfo.GetPath()) != m_watches.end() )
{
wxLogTrace(wxTRACE_FSWATCHER,
"Path '%s' is already watched", winfo.GetPath());
// This can happen if a dir is watched, then a parent tree added
return true;
}
// construct watch entry
wxSharedPtr<wxFSWatchEntry> watch(new wxFSWatchEntry(winfo));
if (!DoAdd(watch))
return false;
// add watch to our map (always succeedes, checked above)
wxFSWatchEntries::value_type val(watch->GetPath(), watch);
return m_watches.insert(val).second;
}
virtual bool Remove(const wxFSWatchInfo& winfo)
{
wxFSWatchEntries::iterator it = m_watches.find(winfo.GetPath());
if ( it == m_watches.end() )
{
wxLogTrace(wxTRACE_FSWATCHER,
"Path '%s' is not watched", winfo.GetPath());
// This can happen if a dir is watched, then a parent tree added
return true;
}
wxSharedPtr<wxFSWatchEntry> watch = it->second;
m_watches.erase(it);
return DoRemove(watch);
}
virtual bool RemoveAll()
{
bool ret = true;
for ( wxFSWatchEntries::iterator it = m_watches.begin();
it != m_watches.end();
++it )
{
if ( !DoRemove(it->second) )
ret = false;
}
m_watches.clear();
return ret;
}
// Check whether any filespec matches the file's ext (if present)
bool MatchesFilespec(const wxFileName& fn, const wxString& filespec) const
{
return filespec.empty() || wxMatchWild(filespec, fn.GetFullName());
}
protected:
virtual bool DoAdd(wxSharedPtr<wxFSWatchEntry> watch) = 0;
virtual bool DoRemove(wxSharedPtr<wxFSWatchEntry> watch) = 0;
wxFSWatchEntries m_watches;
wxFileSystemWatcherBase* m_watcher;
};
#endif /* WX_PRIVATE_FSWATCHER_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/metafile.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/metafile.h
// Purpose: wxMetaFile, wxMetaFileDC classes.
// This probably should be restricted to Windows platforms,
// but if there is an equivalent on your platform, great.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_METAFIILE_H_
#define _WX_METAFIILE_H_
#include "wx/dc.h"
#include "wx/gdiobj.h"
#if wxUSE_DATAOBJ
#include "wx/dataobj.h"
#endif
#include "wx/osx/dcclient.h"
/*
* Metafile and metafile device context classes
*
*/
#define wxMetaFile wxMetafile
#define wxMetaFileDC wxMetafileDC
class WXDLLIMPEXP_FWD_CORE wxMetafile;
class wxMetafileRefData ;
#define M_METAFILEDATA ((wxMetafileRefData *)m_refData)
class WXDLLIMPEXP_CORE wxMetafile : public wxGDIObject
{
public:
wxMetafile(const wxString& file = wxEmptyString);
virtual ~wxMetafile(void);
// After this is called, the metafile cannot be used for anything
// since it is now owned by the clipboard.
virtual bool SetClipboard(int width = 0, int height = 0);
virtual bool Play(wxDC *dc);
wxSize GetSize() const;
int GetWidth() const { return GetSize().x; }
int GetHeight() const { return GetSize().y; }
// Implementation
WXHMETAFILE GetHMETAFILE() const ;
void SetHMETAFILE(WXHMETAFILE mf) ;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
wxDECLARE_DYNAMIC_CLASS(wxMetafile);
};
class WXDLLIMPEXP_CORE wxMetafileDCImpl: public wxGCDCImpl
{
public:
wxMetafileDCImpl( wxDC *owner,
const wxString& filename,
int width, int height,
const wxString& description );
virtual ~wxMetafileDCImpl();
// Should be called at end of drawing
virtual wxMetafile *Close();
// Implementation
wxMetafile *GetMetaFile(void) const { return m_metaFile; }
void SetMetaFile(wxMetafile *mf) { m_metaFile = mf; }
protected:
virtual void DoGetSize(int *width, int *height) const;
wxMetafile* m_metaFile;
private:
wxDECLARE_CLASS(wxMetafileDCImpl);
wxDECLARE_NO_COPY_CLASS(wxMetafileDCImpl);
};
class WXDLLIMPEXP_CORE wxMetafileDC: public wxDC
{
public:
// the ctor parameters specify the filename (empty for memory metafiles),
// the metafile picture size and the optional description/comment
wxMetafileDC( const wxString& filename = wxEmptyString,
int width = 0, int height = 0,
const wxString& description = wxEmptyString ) :
wxDC( new wxMetafileDCImpl( this, filename, width, height, description) )
{ }
wxMetafile *GetMetafile() const
{ return ((wxMetafileDCImpl*)m_pimpl)->GetMetaFile(); }
wxMetafile *Close()
{ return ((wxMetafileDCImpl*)m_pimpl)->Close(); }
private:
wxDECLARE_CLASS(wxMetafileDC);
wxDECLARE_NO_COPY_CLASS(wxMetafileDC);
};
/*
* Pass filename of existing non-placeable metafile, and bounding box.
* Adds a placeable metafile header, sets the mapping mode to anisotropic,
* and sets the window origin and extent to mimic the wxMM_TEXT mapping mode.
*
*/
// No origin or extent
#define wxMakeMetaFilePlaceable wxMakeMetafilePlaceable
bool WXDLLIMPEXP_CORE wxMakeMetafilePlaceable(const wxString& filename, float scale = 1.0);
// Optional origin and extent
bool WXDLLIMPEXP_CORE wxMakeMetaFilePlaceable(const wxString& filename, int x1, int y1, int x2, int y2, float scale = 1.0, bool useOriginAndExtent = true);
// ----------------------------------------------------------------------------
// wxMetafileDataObject is a specialization of wxDataObject for metafile data
// ----------------------------------------------------------------------------
#if wxUSE_DATAOBJ
class WXDLLIMPEXP_CORE wxMetafileDataObject : public wxDataObjectSimple
{
public:
// ctors
wxMetafileDataObject()
: wxDataObjectSimple(wxDF_METAFILE) { }
wxMetafileDataObject(const wxMetafile& metafile)
: wxDataObjectSimple(wxDF_METAFILE), m_metafile(metafile) { }
// virtual functions which you may override if you want to provide data on
// demand only - otherwise, the trivial default versions will be used
virtual void SetMetafile(const wxMetafile& metafile)
{ m_metafile = metafile; }
virtual wxMetafile GetMetafile() const
{ return m_metafile; }
// 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);
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); }
protected:
wxMetafile m_metafile;
};
#endif
#endif
// _WX_METAFIILE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/fswatcher_fsevents.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/fswatcher_fsevents.h
// Purpose: File System watcher that uses the FSEvents API
// of OS X to efficiently watch trees
// Author: Roberto Perpuly
// Created: 2015-04-24
// Copyright: (c) 2015 Roberto Perpuly <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FSWATCHER_FSEVENTS_H_
#define _WX_FSWATCHER_FSEVENTS_H_
#include "wx/defs.h"
#if wxUSE_FSWATCHER
#include <CoreServices/CoreServices.h>
#include "wx/unix/fswatcher_kqueue.h"
WX_DECLARE_STRING_HASH_MAP(FSEventStreamRef, FSEventStreamRefMap);
/*
The FSEvents watcher uses the newer FSEvents service
that is available in OS X, the service allows for
efficient watching of entire directory hierarchies.
Note that adding a single file watch (or directory
watch) still use kqueue events.
We take care to only use this on OS X >= 10.7, as that
version introduced the ability to get file-level notifications.
See the following docs that outline the FSEvents API
https://developer.apple.com/library/mac/documentation/Darwin/Conceptual/FSEvents_ProgGuide/UsingtheFSEventsFramework/UsingtheFSEventsFramework.html
https://developer.apple.com/library/mac/documentation/Darwin/Reference/FSEvents_Ref/index.html
*/
class WXDLLIMPEXP_BASE wxFsEventsFileSystemWatcher :
public wxKqueueFileSystemWatcher
{
public:
wxFsEventsFileSystemWatcher();
wxFsEventsFileSystemWatcher(const wxFileName& path,
int events = wxFSW_EVENT_ALL);
~wxFsEventsFileSystemWatcher();
// reimplement adding a tree so that it does not use
// kqueue at all
bool AddTree(const wxFileName& path, int events = wxFSW_EVENT_ALL,
const wxString& filespec = wxEmptyString) wxOVERRIDE;
// reimplement removing a tree so that we
// cleanup the opened fs streams
bool RemoveTree(const wxFileName& path) wxOVERRIDE;
// reimplement remove all so that we cleanup
// watches from kqeueue and from FSEvents
bool RemoveAll() wxOVERRIDE;
// post an file change event to the owner
void PostChange(const wxFileName& oldFileName,
const wxFileName& newFileName, int event);
// post a warning event to the owner
void PostWarning(wxFSWWarningType warning, const wxString& msg);
// post an error event to the owner
void PostError(const wxString& msg);
// reimplement count to include the FS stream watches
int GetWatchedPathsCount() const;
// reimplement to include paths from FS stream watches
int GetWatchedPaths(wxArrayString* paths) const;
private:
// map of path => FSEventStreamRef
FSEventStreamRefMap m_streams;
};
#endif /* wxUSE_FSWATCHER */
#endif /* _WX_FSWATCHER_FSEVENTS_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/webview_webkit.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/osx/webkit.h
// Purpose: wxWebViewWebKit - embeddable web kit control,
// OS X implementation of web view component
// Author: Jethro Grassie / Kevin Ollivier / Marianne Gagnon
// Modified by:
// Created: 2004-4-16
// Copyright: (c) Jethro Grassie / Kevin Ollivier / Marianne Gagnon
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WEBKIT_H
#define _WX_WEBKIT_H
#include "wx/defs.h"
#if wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT && defined(__WXOSX__)
#include "wx/control.h"
#include "wx/webview.h"
#include "wx/osx/core/objcid.h"
// ----------------------------------------------------------------------------
// Web Kit Control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_WEBVIEW wxWebViewWebKit : public wxWebView
{
public:
wxDECLARE_DYNAMIC_CLASS(wxWebViewWebKit);
wxWebViewWebKit() {}
wxWebViewWebKit(wxWindow *parent,
wxWindowID winID = wxID_ANY,
const wxString& strURL = wxWebViewDefaultURLStr,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxWebViewNameStr)
{
Create(parent, winID, strURL, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID winID = wxID_ANY,
const wxString& strURL = wxWebViewDefaultURLStr,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxWebViewNameStr) wxOVERRIDE;
virtual ~wxWebViewWebKit();
virtual bool CanGoBack() const wxOVERRIDE;
virtual bool CanGoForward() const wxOVERRIDE;
virtual void GoBack() wxOVERRIDE;
virtual void GoForward() wxOVERRIDE;
virtual void Reload(wxWebViewReloadFlags flags = wxWEBVIEW_RELOAD_DEFAULT) wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual wxString GetPageSource() const wxOVERRIDE;
virtual wxString GetPageText() const wxOVERRIDE;
virtual void Print() wxOVERRIDE;
virtual void LoadURL(const wxString& url) wxOVERRIDE;
virtual wxString GetCurrentURL() const wxOVERRIDE;
virtual wxString GetCurrentTitle() const wxOVERRIDE;
virtual wxWebViewZoom GetZoom() const wxOVERRIDE;
virtual void SetZoom(wxWebViewZoom zoom) wxOVERRIDE;
virtual void SetZoomType(wxWebViewZoomType zoomType) wxOVERRIDE;
virtual wxWebViewZoomType GetZoomType() const wxOVERRIDE;
virtual bool CanSetZoomType(wxWebViewZoomType type) const wxOVERRIDE;
virtual bool IsBusy() const wxOVERRIDE { return m_busy; }
//History functions
virtual void ClearHistory() wxOVERRIDE;
virtual void EnableHistory(bool enable = true) wxOVERRIDE;
virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetBackwardHistory() wxOVERRIDE;
virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetForwardHistory() wxOVERRIDE;
virtual void LoadHistoryItem(wxSharedPtr<wxWebViewHistoryItem> item) wxOVERRIDE;
//Undo / redo functionality
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
//Find function
virtual long Find(const wxString& text, int flags = wxWEBVIEW_FIND_DEFAULT) wxOVERRIDE
{
wxUnusedVar(text);
wxUnusedVar(flags);
return wxNOT_FOUND;
}
//Clipboard functions
virtual bool CanCut() const wxOVERRIDE { return true; }
virtual bool CanCopy() const wxOVERRIDE { return true; }
virtual bool CanPaste() const wxOVERRIDE { return true; }
virtual void Cut() wxOVERRIDE;
virtual void Copy() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
//Editing functions
virtual void SetEditable(bool enable = true) wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
//Selection
virtual void DeleteSelection() wxOVERRIDE;
virtual bool HasSelection() const wxOVERRIDE;
virtual void SelectAll() wxOVERRIDE;
virtual wxString GetSelectedText() const wxOVERRIDE;
virtual wxString GetSelectedSource() const wxOVERRIDE;
virtual void ClearSelection() wxOVERRIDE;
bool RunScript(const wxString& javascript, wxString* output = NULL) wxOVERRIDE;
//Virtual Filesystem Support
virtual void RegisterHandler(wxSharedPtr<wxWebViewHandler> handler) wxOVERRIDE;
virtual void* GetNativeBackend() const wxOVERRIDE { return m_webView; }
// ---- methods not from the parent (common) interface
bool CanGetPageSource() const;
void SetScrollPos(int pos);
int GetScrollPos();
bool CanIncreaseTextSize() const;
void IncreaseTextSize();
bool CanDecreaseTextSize() const;
void DecreaseTextSize();
float GetWebkitZoom() const;
void SetWebkitZoom(float zoom);
// don't hide base class virtuals
virtual void SetScrollPos( int orient, int pos, bool refresh = true ) wxOVERRIDE
{ return wxControl::SetScrollPos(orient, pos, refresh); }
virtual int GetScrollPos( int orient ) const wxOVERRIDE
{ return wxControl::GetScrollPos(orient); }
//we need to resize the webview when the control size changes
void OnSize(wxSizeEvent &event);
void OnMove(wxMoveEvent &event);
void OnMouseEvents(wxMouseEvent &event);
bool m_busy;
bool m_nextNavigationIsNewWindow;
protected:
virtual void DoSetPage(const wxString& html, const wxString& baseUrl) wxOVERRIDE;
wxDECLARE_EVENT_TABLE();
void MacVisibilityChanged() wxOVERRIDE;
private:
wxWindow *m_parent;
wxWindowID m_windowID;
wxString m_pageTitle;
OSXWebViewPtr m_webView;
// we may use this later to setup our own mouse events,
// so leave it in for now.
void* m_webKitCtrlEventHandler;
//It should be WebView*, but WebView is an Objective-C class
//TODO: look into using DECLARE_WXCOCOA_OBJC_CLASS rather than this.
};
class WXDLLIMPEXP_WEBVIEW wxWebViewFactoryWebKit : public wxWebViewFactory
{
public:
virtual wxWebView* Create() { return new wxWebViewWebKit; }
virtual wxWebView* Create(wxWindow* parent,
wxWindowID id,
const wxString& url = wxWebViewDefaultURLStr,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxWebViewNameStr)
{ return new wxWebViewWebKit(parent, id, url, pos, size, style, name); }
};
#endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT
#endif // _WX_WEBKIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dcclient.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dcclient.h
// Purpose: wxClientDC, wxPaintDC and wxWindowDC classes
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCCLIENT_H_
#define _WX_DCCLIENT_H_
#include "wx/dc.h"
#include "wx/dcgraph.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxPaintDC;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_CORE wxWindowDCImpl: public wxGCDCImpl
{
public:
wxWindowDCImpl( wxDC *owner );
wxWindowDCImpl( wxDC *owner, wxWindow *window );
virtual ~wxWindowDCImpl();
virtual void DoGetSize( int *width, int *height ) const;
virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const;
protected:
bool m_release;
int m_width;
int m_height;
wxDECLARE_CLASS(wxWindowDCImpl);
wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
class WXDLLIMPEXP_CORE wxClientDCImpl: public wxWindowDCImpl
{
public:
wxClientDCImpl( wxDC *owner );
wxClientDCImpl( wxDC *owner, wxWindow *window );
virtual ~wxClientDCImpl();
private:
wxDECLARE_CLASS(wxClientDCImpl);
wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
class WXDLLIMPEXP_CORE wxPaintDCImpl: public wxWindowDCImpl
{
public:
wxPaintDCImpl( wxDC *owner );
wxPaintDCImpl( wxDC *owner, wxWindow *win );
virtual ~wxPaintDCImpl();
protected:
wxDECLARE_CLASS(wxPaintDCImpl);
wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
#endif
// _WX_DCCLIENT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/setup.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/setup.h
// Purpose: Configuration for the library
// Author: Stefan Csomor
// Modified by: Stefan Csomor
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
#ifdef __WXMAC_XCODE__
// while configure based builds have the flags prepended, we must do this here
// for xcode based builds
#include "wx/osx/config_xcode.h"
#endif
/* --- 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 OSX options --- */
// ----------------------------------------------------------------------------
// Unix-specific options settings
// ----------------------------------------------------------------------------
// use wxSelectDispatcher class
#define wxUSE_SELECT_DISPATCHER 1
// use wxEpollDispatcher class (Linux only)
#define wxUSE_EPOLL_DISPATCHER 0
/*
Use GStreamer for Unix.
Default is 0 as this requires a lot of dependencies which might not be
available.
Recommended setting: 1 (wxMediaCtrl won't work by default without it).
*/
#define wxUSE_GSTREAMER 0
// This is only used under Unix, but needs to be defined here as it's checked
// by wx/unix/chkconf.h.
#define wxUSE_XTEST 0
// ----------------------------------------------------------------------------
// Mac-specific settings
// ----------------------------------------------------------------------------
#undef wxUSE_GRAPHICS_CONTEXT
#define wxUSE_GRAPHICS_CONTEXT 1
// things not implemented under Mac
#undef wxUSE_STACKWALKER
#define wxUSE_STACKWALKER 0
// wxWebKit is a wrapper for Apple's WebKit framework, use it if you want to
// embed the Safari browser control
// 0 by default because of Jaguar compatibility problems
#define wxUSE_WEBKIT 1
// Set to 0 for no libmspack
#define wxUSE_LIBMSPACK 0
// native toolbar does support embedding controls, but not complex panels, please test
#define wxOSX_USE_NATIVE_TOOLBAR 1
// make sure we have the proper dispatcher for the console event loop
#define wxUSE_SELECT_DISPATCHER 1
#define wxUSE_EPOLL_DISPATCHER 0
// set to 1 if you have older code that still needs icon refs
#define wxOSX_USE_ICONREF 0
// set to 0 if you have code that has problems with the new bitmap implementation
#define wxOSX_BITMAP_NATIVE_ACCESS 1
/* --- end OSX options --- */
#endif
// _WX_SETUP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/datetimectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/datetimectrl.h
// Purpose: Declaration of wxOSX-specific wxDateTimePickerCtrl class.
// Author: Vadim Zeitlin
// Created: 2011-12-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_DATETIMECTRL_H_
#define _WX_OSX_DATETIMECTRL_H_
class wxDateTimeWidgetImpl;
// ----------------------------------------------------------------------------
// wxDateTimePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDateTimePickerCtrl : public wxDateTimePickerCtrlBase
{
public:
// Implement the base class pure virtuals.
virtual void SetValue(const wxDateTime& dt);
virtual wxDateTime GetValue() const;
// Implementation only.
virtual void OSXGenerateEvent(const wxDateTime& dt) = 0;
protected:
wxDateTimeWidgetImpl* GetDateTimePeer() const;
};
#endif // _WX_OSX_DATETIMECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/listctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/listctrl.h
// Purpose: wxListCtrl class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTCTRL_H_
#define _WX_LISTCTRL_H_
#include "wx/defs.h"
#include "wx/generic/listctrl.h"
#define wxMAC_ALWAYS_USE_GENERIC_LISTCTRL wxT("mac.listctrl.always_use_generic")
class wxMacDataBrowserListCtrlControl;
class wxListCtrlTextCtrlWrapper;
class wxListCtrlRenameTimer;
WX_DECLARE_EXPORTED_LIST(wxListItem, wxColumnList);
class WXDLLIMPEXP_CORE wxListCtrl: public wxListCtrlBase
{
wxDECLARE_DYNAMIC_CLASS(wxListCtrl);
public:
/*
* Public interface
*/
wxListCtrl() { Init(); }
wxListCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListCtrlNameStr)
{
Init();
Create(parent, id, pos, size, style, validator, name);
}
virtual ~wxListCtrl();
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListCtrlNameStr);
// Attributes
////////////////////////////////////////////////////////////////////////////
// Gets information about this column
bool GetColumn(int col, wxListItem& item) const;
// Sets information about this column
bool SetColumn(int col, const wxListItem& item) ;
// Gets the column width
int GetColumnWidth(int col) const;
// Sets the column width
bool SetColumnWidth(int col, int width) ;
// Gets the number of items that can fit vertically in the
// visible area of the list control (list or report view)
// or the total number of items in the list control (icon
// or small icon view)
int GetCountPerPage() const;
// Gets the edit control for editing labels.
wxTextCtrl* GetEditControl() const;
// Gets information about the item
bool GetItem(wxListItem& info) const ;
// Sets information about the item
bool SetItem(wxListItem& info) ;
// Sets a string field at a particular column
long SetItem(long index, int col, const wxString& label, int imageId = -1);
// Gets the item state
int GetItemState(long item, long stateMask) const ;
// Sets the item state
bool SetItemState(long item, long state, long stateMask) ;
void AssignImageList(wxImageList *imageList, int which);
// Sets the item image
bool SetItemImage(long item, int image, int selImage = -1) ;
bool SetItemColumnImage(long item, long column, int image);
// Gets the item text
wxString GetItemText(long item, int col = 0) const ;
// Sets the item text
void SetItemText(long item, const wxString& str) ;
void SetItemTextColour(long item, const wxColour& colour) ;
wxColour GetItemTextColour(long item) const;
void SetItemBackgroundColour(long item, const wxColour& colour) ;
wxColour GetItemBackgroundColour(long item) const;
void SetItemFont( long item, const wxFont &f);
wxFont GetItemFont( long item ) const;
// Gets the item data
long GetItemData(long item) const ;
// Sets the item data
bool SetItemPtrData(long item, wxUIntPtr data);
bool SetItemData(long item, long data) { return SetItemPtrData(item, data); }
// Gets the item rectangle
bool GetItemRect(long item, wxRect& rect, int code = wxLIST_RECT_BOUNDS) const ;
// Gets the item rectangle of a subitem
bool GetSubItemRect( long item, long subItem, wxRect& rect, int code = wxLIST_RECT_BOUNDS ) const;
// Gets the item position
bool GetItemPosition(long item, wxPoint& pos) const ;
// Sets the item position
bool SetItemPosition(long item, const wxPoint& pos) ;
// Gets the number of items in the list control
int GetItemCount() const;
// Gets the number of columns in the list control
int GetColumnCount() const;
void SetItemSpacing( int spacing, bool isSmall = false );
wxSize GetItemSpacing() const;
// Gets the number of selected items in the list control
int GetSelectedItemCount() const;
wxRect GetViewRect() const;
// Gets the text colour of the listview
wxColour GetTextColour() const;
// Sets the text colour of the listview
void SetTextColour(const wxColour& col);
// Gets the index of the topmost visible item when in
// list or report view
long GetTopItem() const ;
// Add or remove a single window style
void SetSingleStyle(long style, bool add = true) ;
// Set the whole window style
void SetWindowStyleFlag(long style) ;
// Searches for an item, starting from 'item'.
// item can be -1 to find the first item that matches the
// specified flags.
// Returns the item or -1 if unsuccessful.
long GetNextItem(long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE) const ;
// Gets one of the three image lists
wxImageList *GetImageList(int which) const ;
// Sets the image list
void SetImageList(wxImageList *imageList, int which) ;
// Operations
////////////////////////////////////////////////////////////////////////////
// Arranges the items
bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
// Deletes an item
bool DeleteItem(long item);
// Deletes all items
bool DeleteAllItems() ;
// Deletes a column
bool DeleteColumn(int col);
// Deletes all columns
bool DeleteAllColumns();
// Clears items, and columns if there are any.
void ClearAll();
// Edit the label
wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
// Ensures this item is visible
bool EnsureVisible(long item) ;
// Find an item whose label matches this string, starting from the item after 'start'
// or the beginning if 'start' is -1.
long FindItem(long start, const wxString& str, bool partial = false);
// Find an item whose data matches this data, starting from the item after 'start'
// or the beginning if 'start' is -1.
long FindItem(long start, long data);
// Find an item nearest this position in the specified direction, starting from
// the item after 'start' or the beginning if 'start' is -1.
long FindItem(long start, const wxPoint& pt, int direction);
// Determines which item (if any) is at the specified point,
// giving details in 'flags' (see wxLIST_HITTEST_... flags above)
// Request the subitem number as well at the given coordinate.
long HitTest(const wxPoint& point, int& flags, long* ptrSubItem = NULL) const;
// Inserts an item, returning the index of the new item if successful,
// -1 otherwise.
// TOD: Should also have some further convenience functions
// which don't require setting a wxListItem object
long InsertItem(wxListItem& info);
// Insert a string item
long InsertItem(long index, const wxString& label);
// Insert an image item
long InsertItem(long index, int imageIndex);
// Insert an image/string item
long InsertItem(long index, const wxString& label, int imageIndex);
// Scrolls the list control. If in icon, small icon or report view mode,
// x specifies the number of pixels to scroll. If in list view mode, x
// specifies the number of columns to scroll.
// If in icon, small icon or list view mode, y specifies the number of pixels
// to scroll. If in report view mode, y specifies the number of lines to scroll.
bool ScrollList(int dx, int dy);
// Sort items.
// fn is a function which takes 3 long arguments: item1, item2, data.
// item1 is the long data associated with a first item (NOT the index).
// item2 is the long data associated with a second item (NOT the index).
// data is the same value as passed to SortItems.
// The return value is a negative number if the first item should precede the second
// item, a positive number of the second item should precede the first,
// or zero if the two items are equivalent.
// data is arbitrary data to be passed to the sort function.
bool SortItems(wxListCtrlCompare fn, wxIntPtr data);
wxMacDataBrowserListCtrlControl* GetListPeer() const;
// these functions are only used for virtual list view controls, i.e. the
// ones with wxLC_VIRTUAL style
void SetItemCount(long count);
void RefreshItem(long item);
void RefreshItems(long itemFrom, long itemTo);
// return the text for the given column of the given item
virtual wxString OnGetItemText(long item, long column) const;
// return the icon for the given item. In report view, OnGetItemImage will
// only be called for the first column. See OnGetItemColumnImage for
// details.
virtual int OnGetItemImage(long item) const;
// return the icon for the given item and column.
virtual int OnGetItemColumnImage(long item, long column) const;
/* Why should we need this function? Leave for now.
* We might need it because item data may have changed,
* but the display needs refreshing (in string callback mode)
// Updates an item. If the list control has the wxLI_AUTO_ARRANGE style,
// the items will be rearranged.
bool Update(long item);
*/
void Command(wxCommandEvent& event) { ProcessCommand(event); }
wxListCtrlCompare GetCompareFunc() { return m_compareFunc; }
wxIntPtr GetCompareFuncData() { return m_compareFuncData; }
// public overrides needed for pimpl approach
virtual bool SetFont(const wxFont& font);
virtual bool SetForegroundColour(const wxColour& colour);
virtual bool SetBackgroundColour(const wxColour& colour);
virtual wxColour GetBackgroundColour() const;
virtual void Freeze ();
virtual void Thaw ();
virtual void Update ();
// functions for editing/timer
void OnRenameTimer();
bool OnRenameAccept(long itemEdit, const wxString& value);
void OnRenameCancelled(long itemEdit);
void ChangeCurrent(long current);
void ResetCurrent() { ChangeCurrent((long)-1); }
bool HasCurrent() const { return m_current != (long)-1; }
void OnLeftDown(wxMouseEvent& event);
void OnDblClick(wxMouseEvent& event);
void FinishEditing(wxTextCtrl *text)
{
delete text;
m_textctrlWrapper = NULL;
SetFocus();
}
virtual int GetScrollPos(int orient) const;
void OnRightDown(wxMouseEvent& event);
void OnMiddleDown(wxMouseEvent& event);
void OnChar(wxKeyEvent& event);
virtual void SetFocus();
void FireMouseEvent(wxEventType eventType, wxPoint position);
virtual void SetDropTarget( wxDropTarget *dropTarget );
virtual wxDropTarget* GetDropTarget() const;
// with CG, we need to get the context from an kEventControlDraw event
// unfortunately, the DataBrowser callbacks don't provide the context
// and we need it, so we need to set/remove it before and after draw
// events so we can access it in the callbacks.
void MacSetDrawingContext(void* context) { m_cgContext = context; }
void* MacGetDrawingContext() { return m_cgContext; }
virtual wxVisualAttributes GetDefaultAttributes() const
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
// Implement base class pure virtual methods.
long DoInsertColumn(long col, const wxListItem& info);
// protected overrides needed for pimpl approach
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
long m_current;
wxListCtrlTextCtrlWrapper *m_textctrlWrapper;
wxListCtrlRenameTimer *m_renameTimer;
// common part of all ctors
void Init();
wxGenericListCtrl* m_genericImpl; // allow use of the generic impl.
wxMacDataBrowserListCtrlControl* m_dbImpl;
void* m_macListCtrlEventHandler;
void* m_cgContext;
wxListCtrlCompare m_compareFunc;
wxIntPtr m_compareFuncData;
wxTextCtrl* m_textCtrl; // The control used for editing a label
wxImageList * m_imageListNormal; // The image list for normal icons
wxImageList * m_imageListSmall; // The image list for small icons
wxImageList * m_imageListState; // The image list state icons (not implemented yet)
wxColumnList m_colsInfo; // for storing info about each column
wxColour m_textColor;
wxColour m_bgColor;
// keep track of whether or not we should delete the image list ourselves.
bool m_ownsImageListNormal,
m_ownsImageListSmall,
m_ownsImageListState;
long m_baseStyle; // Basic Windows style flags, for recreation purposes
int m_colCount; // Windows doesn't have GetColumnCount so must
// keep track of inserted/deleted columns
int m_count; // for virtual lists, store item count
private:
int CalcColumnAutoWidth(int col) const;
};
#endif
// _WX_LISTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/font.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/font.h
// Purpose: wxFont class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONT_H_
#define _WX_FONT_H_
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
// font styles
enum wxOSXSystemFont
{
wxOSX_SYSTEM_FONT_NONE = 0,
wxOSX_SYSTEM_FONT_NORMAL,
wxOSX_SYSTEM_FONT_BOLD,
wxOSX_SYSTEM_FONT_SMALL,
wxOSX_SYSTEM_FONT_SMALL_BOLD,
wxOSX_SYSTEM_FONT_MINI,
wxOSX_SYSTEM_FONT_MINI_BOLD,
wxOSX_SYSTEM_FONT_LABELS,
wxOSX_SYSTEM_FONT_VIEWS
};
class WXDLLIMPEXP_CORE wxFont : public wxFontBase
{
public:
// ctors and such
wxFont() { }
wxFont(const wxFontInfo& info);
wxFont( wxOSXSystemFont systemFont );
wxFont(CTFontRef font);
#if wxOSX_USE_COCOA
wxFont(WX_NSFont nsfont);
#endif
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);
wxFont(const wxNativeFontInfo& info)
{
(void)Create(info);
}
wxFont(const wxString& fontDesc);
bool Create(const wxNativeFontInfo& info);
virtual ~wxFont();
// implement base class pure virtuals
virtual float GetFractionalPointSize() const wxOVERRIDE;
virtual wxSize GetPixelSize() const wxOVERRIDE;
virtual wxFontStyle GetStyle() const wxOVERRIDE;
virtual int GetNumericWeight() const wxOVERRIDE;
virtual bool GetUnderlined() const wxOVERRIDE;
virtual bool GetStrikethrough() const wxOVERRIDE;
virtual wxString GetFaceName() const wxOVERRIDE;
virtual wxFontEncoding GetEncoding() const wxOVERRIDE;
virtual const wxNativeFontInfo *GetNativeFontInfo() const wxOVERRIDE;
virtual bool IsFixedWidth() const wxOVERRIDE;
virtual void SetFractionalPointSize(float pointSize) wxOVERRIDE;
virtual void SetFamily(wxFontFamily family) wxOVERRIDE;
virtual void SetStyle(wxFontStyle style) wxOVERRIDE;
virtual void SetNumericWeight(int weight) wxOVERRIDE;
virtual bool SetFaceName(const wxString& faceName) wxOVERRIDE;
virtual void SetUnderlined(bool underlined) wxOVERRIDE;
virtual void SetStrikethrough(bool strikethrough) wxOVERRIDE;
virtual void SetEncoding(wxFontEncoding encoding) wxOVERRIDE;
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);
// implementation only from now on
// -------------------------------
virtual bool RealizeResource();
// Mac-specific, risks to change, don't use in portable code
#if wxOSX_USE_COCOA_OR_CARBON
CGFontRef OSXGetCGFont() const;
#endif
CTFontRef OSXGetCTFont() const;
CFDictionaryRef OSXGetCTFontAttributes() const;
#if wxOSX_USE_COCOA
WX_NSFont OSXGetNSFont() const;
#endif
#if wxOSX_USE_IPHONE
WX_UIFont OSXGetUIFont() const;
#endif
protected:
virtual void DoSetNativeFontInfo(const wxNativeFontInfo& info) wxOVERRIDE;
virtual wxFontFamily DoGetFamily() const wxOVERRIDE;
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxFont);
};
#endif // _WX_FONT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/config_xcode.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/config_xcode.h
// Purpose: configurations for xcode builds
// Author: Stefan Csomor
// Modified by:
// Created: 29.04.04
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// from config.log confdefs
#define HAVE_SSIZE_T 1
#define STDC_HEADERS 1
#ifdef __BIG_ENDIAN__
#define WORDS_BIGENDIAN 1
#endif
#define wxUSE_UNIX 1
#define __UNIX__ 1
#define __BSD__ 1
#define __DARWIN__ 1
#define wx_USE_NANOX 0
#define HAVE_VA_COPY 1
#define HAVE_VARIADIC_MACROS 1
#define HAVE_STD_WSTRING 1
#if __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 2 )
#if !defined(__has_include)
#define HAVE_TR1_UNORDERED_MAP 1
#define HAVE_TR1_UNORDERED_SET 1
#define HAVE_TR1_TYPE_TRAITS 1
#endif
#define HAVE_GCC_ATOMIC_BUILTINS 1
#endif
#define HAVE_VISIBILITY 1
#define wxHAVE_PTHREAD_CLEANUP 1
#define CONST_COMPATIBILITY 0
#define WX_TIMEZONE timezone
#define WX_SOCKLEN_T socklen_t
#define SOCKOPTLEN_T socklen_t
#define WX_STATFS_T struct statfs
#define wxTYPE_SA_HANDLER int
#define WX_GMTOFF_IN_TM 1
#define HAVE_PW_GECOS 1
#define HAVE_DLOPEN 1
#define HAVE_CXA_DEMANGLE 1
#define HAVE_GETTIMEOFDAY 1
#define HAVE_FSYNC 1
#define HAVE_ROUND 1
#define HAVE_SCHED_YIELD 1
#define HAVE_PTHREAD_MUTEXATTR_T 1
#define HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL 1
#define HAVE_PTHREAD_CANCEL 1
#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1
#define HAVE_SNPRINTF 1
#define HAVE_SNPRINTF_DECL 1
#define HAVE_UNIX98_PRINTF 1
#define HAVE_STATFS 1
#define HAVE_STATFS_DECL 1
#define HAVE_STRNLEN 1
#define HAVE_STRPTIME 1
#define HAVE_STRPTIME_DECL 1
#define HAVE_STRTOULL 1
#define HAVE_THREAD_PRIORITY_FUNCTIONS 1
#define HAVE_VSNPRINTF 1
#define HAVE_VSNPRINTF_DECL 1
#define HAVE_VSSCANF 1
#define HAVE_VSSCANF_DECL 1
#define HAVE_USLEEP 1
#define HAVE_WCSCASECMP 1
#define HAVE_WCSDUP 1
#define HAVE_WCSLEN 1
#define HAVE_WCSNCASECMP 1
#define HAVE_WCSNLEN 1
#define SIZEOF_WCHAR_T 4
#define SIZEOF_SHORT 2
#define SIZEOF_INT 4
#ifdef __LP64__
#define SIZEOF_VOID_P 8
#define SIZEOF_LONG 8
#define SIZEOF_SIZE_T 8
#else
#define SIZEOF_VOID_P 4
#define SIZEOF_LONG 4
#define SIZEOF_SIZE_T 4
#endif
#define SIZEOF_LONG_LONG 8
#define wxSIZE_T_IS_ULONG 1
#define wxWCHAR_T_IS_REAL_TYPE 1
#define HAVE_DLERROR 1
#define HAVE_FCNTL 1
#define HAVE_GETHOSTBYNAME 1
#define HAVE_GETSERVBYNAME 1
#define HAVE_GMTIME_R 1
#define HAVE_INET_ADDR 1
#define HAVE_INET_ATON 1
#define HAVE_LOCALTIME_R 1
#define HAVE_MKSTEMP 1
#define HAVE_SETENV 1
/* #define HAVE_PUTENV 1 */
#define HAVE_STRTOK_R 1
#define HAVE_UNAME 1
#define HAVE_USLEEP 1
#define HAVE_X11_XKBLIB_H 1
#define HAVE_SCHED_H 1
#define HAVE_UNISTD_H 1
#define HAVE_WCHAR_H 1
/* better to use the built-in CF conversions, also avoid iconv versioning problems */
/* #undef HAVE_ICONV */
#define ICONV_CONST
#define HAVE_LANGINFO_H 1
#define HAVE_WCSRTOMBS 1
#define HAVE_FPUTWS 1
#define HAVE_WPRINTF 1
#define HAVE_VSWPRINTF 1
#define HAVE_VSWSCANF 1
#define HAVE_FSEEKO 1
#define HAVE_SYS_SELECT_H 1
#define HAVE_FDOPEN 1
#define HAVE_SYSCONF 1
#define HAVE_GETPWUID_R 1
#define HAVE_GETGRGID_R 1
#define HAVE_LOCALE_T 1
#define HAVE_XLOCALE_H 1
#define wxHAS_KQUEUE 1
#define PACKAGE_BUGREPORT "[email protected]"
#define PACKAGE_NAME "wxWidgets"
#define PACKAGE_STRING "wxWidgets 3.1.2"
#define PACKAGE_TARNAME "wxwidgets"
#define PACKAGE_VERSION "3.1.2"
// for regex
#define WX_NO_REGEX_ADVANCED 1
// for jpeg
#define HAVE_STDLIB_H 1
// OBSOLETE ?
#define HAVE_COS 1
#define HAVE_FLOOR 1
#define HAVE_INTTYPES_H 1
#define HAVE_MEMORY_H 1
#define HAVE_REGCOMP 1
#define HAVE_STRINGS_H 1
#define HAVE_STRING_H 1
#define HAVE_SYS_STAT_H 1
#define HAVE_SYS_TYPES_H 1
#define HAVE_X11_XLIB_H 1
#define SOCKLEN_T socklen_t
#define _FILE_OFFSET_BITS 64
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/nonownedwnd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/nonownedwnd.h
// Purpose: declares wxNonOwnedWindow class
// Author: Stefan Csomor
// Modified by:
// Created: 2008-03-24
// Copyright: (c) 2008 Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_NONOWNEDWND_H_
#define _WX_MAC_NONOWNEDWND_H_
#include "wx/window.h"
#include "wx/graphics.h"
#if wxUSE_SYSTEM_OPTIONS
#define wxMAC_WINDOW_PLAIN_TRANSITION wxT("mac.window-plain-transition")
#endif
//-----------------------------------------------------------------------------
// wxNonOwnedWindow
//-----------------------------------------------------------------------------
// This class represents "non-owned" window. A window is owned by another
// window if it has a parent and is positioned within the parent. For example,
// wxFrame is non-owned, because even though it can have a parent, it's
// location is independent of it. This class is for internal use only, it's
// the base class for wxTopLevelWindow and wxPopupWindow.
class wxNonOwnedWindowImpl;
class WXDLLIMPEXP_CORE wxNonOwnedWindow : public wxNonOwnedWindowBase
{
public:
// constructors and such
wxNonOwnedWindow() { Init(); }
wxNonOwnedWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
Init();
(void)Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
bool Create(wxWindow *parent, WXWindow nativeWindow);
virtual ~wxNonOwnedWindow();
virtual void SubclassWin(WXWindow nativeWindow);
virtual void UnsubclassWin();
virtual wxPoint GetClientAreaOrigin() const;
// implement base class pure virtuals
virtual bool SetTransparent(wxByte alpha);
virtual bool CanSetTransparent();
virtual bool SetBackgroundStyle(wxBackgroundStyle style);
virtual void Update();
WXWindow GetWXWindow() const ;
static wxNonOwnedWindow* GetFromWXWindow( WXWindow win );
// implementation from now on
// --------------------------
// These accessors are Mac-specific and don't exist in other ports.
const wxRegion& GetShape() const { return m_shape; }
#if wxUSE_GRAPHICS_CONTEXT
const wxGraphicsPath& GetShapePath() { return m_shapePath; }
#endif // wxUSE_GRAPHICS_CONTEXT
// activation hooks only necessary for MDI Implementation
static void MacDelayedDeactivation(long timestamp);
virtual void MacActivate( long timestamp , bool inIsActivating ) ;
virtual void SetWindowStyleFlag(long flags);
virtual void Raise();
virtual void Lower();
virtual bool Show( bool show = true );
virtual void SetExtraStyle(long exStyle) ;
virtual bool SetBackgroundColour( const wxColour &colour );
wxNonOwnedWindowImpl* GetNonOwnedPeer() const { return m_nowpeer; }
#if wxOSX_USE_COCOA_OR_IPHONE
// override the base class method to return an NSWindow instead of NSView
virtual void *OSXGetViewOrWindow() const;
#endif // Cocoa
// osx specific event handling common for all osx-ports
virtual void HandleActivated( double timestampsec, bool didActivate );
virtual void HandleResized( double timestampsec );
virtual void HandleMoved( double timestampsec );
virtual void HandleResizing( double timestampsec, wxRect* rect );
void OSXHandleMiniaturize(double WXUNUSED(timestampsec), bool miniaturized);
void OSXSetIgnoreResizing(bool value) { m_ignoreResizing = value; }
void WindowWasPainted();
virtual bool Destroy();
protected:
// common part of all ctors
void Init();
virtual void DoGetPosition( int *x, int *y ) const;
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual void DoGetClientSize(int *width, int *height) const;
virtual bool OSXShowWithEffect(bool show,
wxShowEffect effect,
unsigned timeout);
virtual bool DoClearShape();
virtual bool DoSetRegionShape(const wxRegion& region);
#if wxUSE_GRAPHICS_CONTEXT
virtual bool DoSetPathShape(const wxGraphicsPath& path);
#endif // wxUSE_GRAPHICS_CONTEXT
virtual void WillBeDestroyed();
wxNonOwnedWindowImpl* m_nowpeer ;
// wxWindowMac* m_macFocus ;
static wxNonOwnedWindow *s_macDeactivateWindow;
private :
static clock_t s_lastFlush;
wxRegion m_shape;
#if wxUSE_GRAPHICS_CONTEXT
wxGraphicsPath m_shapePath;
#endif // wxUSE_GRAPHICS_CONTEXT
bool m_ignoreResizing;
};
// list of all frames and modeless dialogs
extern WXDLLIMPEXP_DATA_CORE(wxWindowList) wxModelessWindows;
#endif // _WX_MAC_NONOWNEDWND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/activityindicator.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/activityindicator.h
// Purpose: Declaration of wxActivityIndicator for wxOSX (Cocoa only).
// Author: Vadim Zeitlin
// Created: 2015-03-08
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_ACTIVITYINDICATOR_H_
#define _WX_OSX_ACTIVITYINDICATOR_H_
// ----------------------------------------------------------------------------
// wxActivityIndicator: implementation using GtkSpinner.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxActivityIndicator : public wxActivityIndicatorBase
{
public:
wxActivityIndicator()
{
Init();
}
explicit
wxActivityIndicator(wxWindow* parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxActivityIndicatorNameStr)
{
Init();
Create(parent, winid, pos, size, style, name);
}
bool Create(wxWindow* parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxActivityIndicatorNameStr);
virtual void Start() wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual bool IsRunning() const wxOVERRIDE;
private:
// Common part of all ctors.
void Init() { m_isRunning = false; }
bool m_isRunning;
wxDECLARE_DYNAMIC_CLASS(wxActivityIndicator);
wxDECLARE_NO_COPY_CLASS(wxActivityIndicator);
};
#endif // _WX_OSX_ACTIVITYINDICATOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/app.h
// Purpose: wxApp class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_APP_H_
#define _WX_APP_H_
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/gdicmn.h"
#include "wx/event.h"
class WXDLLIMPEXP_FWD_CORE wxFrame;
class WXDLLIMPEXP_FWD_CORE wxWindowMac;
class WXDLLIMPEXP_FWD_CORE wxApp ;
class WXDLLIMPEXP_FWD_CORE wxKeyEvent;
class WXDLLIMPEXP_FWD_BASE wxLog;
class WXDLLIMPEXP_FWD_CORE wxMacAutoreleasePool;
// Force an exit from main loop
void WXDLLIMPEXP_CORE wxExit();
// Yield to other apps/messages
bool WXDLLIMPEXP_CORE wxYield();
// Represents the application. Derive OnInit and declare
// a new App object to start application
class WXDLLIMPEXP_CORE wxApp: public wxAppBase
{
wxDECLARE_DYNAMIC_CLASS(wxApp);
wxApp();
virtual ~wxApp();
virtual void WakeUpIdle() wxOVERRIDE;
virtual void SetPrintMode(int mode) wxOVERRIDE { m_printMode = mode; }
virtual int GetPrintMode() const { return m_printMode; }
// calling OnInit with an auto-release pool ready ...
virtual bool CallOnInit() wxOVERRIDE;
#if wxUSE_GUI
// setting up all MacOS Specific Event-Handlers etc
virtual bool OnInitGui() wxOVERRIDE;
#endif // wxUSE_GUI
virtual int OnRun() wxOVERRIDE;
virtual bool ProcessIdle() wxOVERRIDE;
// implementation only
void OnIdle(wxIdleEvent& event);
void OnEndSession(wxCloseEvent& event);
void OnQueryEndSession(wxCloseEvent& event);
protected:
int m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
wxMacAutoreleasePool* m_macPool;
public:
static bool sm_isEmbedded;
// Implementation
virtual bool Initialize(int& argc, wxChar **argv) wxOVERRIDE;
virtual void CleanUp() wxOVERRIDE;
// the installed application event handler
WXEVENTHANDLERREF MacGetEventHandler() { return m_macEventHandler ; }
WXEVENTHANDLERREF MacGetCurrentEventHandlerCallRef() { return m_macCurrentEventHandlerCallRef ; }
void MacSetCurrentEvent( WXEVENTREF event , WXEVENTHANDLERCALLREF handler )
{ m_macCurrentEvent = event ; m_macCurrentEventHandlerCallRef = handler ; }
// adding a CFType object to be released only at the end of the current event cycle (increases the
// refcount of the object passed), needed in case we are in the middle of an event concering an object
// we want to delete and cannot do it immediately
// TODO change semantics to be in line with cocoa (make autrelease NOT increase the count)
void MacAddToAutorelease( void* cfrefobj );
void MacReleaseAutoreleasePool();
public:
static wxWindow* s_captureWindow ;
static long s_lastModifiers ;
int m_nCmdShow;
// mac specifics
protected:
#if wxOSX_USE_COCOA
// override for support of custom app controllers
virtual WX_NSObject OSXCreateAppController();
#endif
private:
virtual bool DoInitGui();
virtual void DoCleanUp();
WXEVENTHANDLERREF m_macEventHandler ;
WXEVENTHANDLERCALLREF m_macCurrentEventHandlerCallRef ;
WXEVENTREF m_macCurrentEvent ;
public:
static long s_macAboutMenuItemId ;
static long s_macPreferencesMenuItemId ;
static long s_macExitMenuItemId ;
static wxString s_macHelpMenuTitleName ;
static wxString s_macWindowMenuTitleName ;
WXEVENTREF MacGetCurrentEvent() { return m_macCurrentEvent ; }
// For embedded use. By default does nothing.
virtual void MacHandleUnhandledEvent( WXEVENTREF ev );
bool MacSendKeyDownEvent( wxWindow* focus , long keyval , long modifiers , long when , wxChar uniChar ) ;
bool MacSendKeyUpEvent( wxWindow* focus , long keyval , long modifiers , long when , wxChar uniChar ) ;
bool MacSendCharEvent( wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar ) ;
void MacCreateKeyEvent( wxKeyEvent& event, wxWindow* focus , long keymessage , long modifiers , long when , wxChar uniChar ) ;
// in response of an openFiles message with Cocoa and an
// open-document apple event
virtual void MacOpenFiles(const wxArrayString &fileNames) ;
// called by MacOpenFiles for each file.
virtual void MacOpenFile(const wxString &fileName) ;
// in response of a get-url apple event
virtual void MacOpenURL(const wxString &url) ;
// in response of a print-document apple event
virtual void MacPrintFiles(const wxArrayString &fileNames) ;
// called by MacPrintFiles for each file
virtual void MacPrintFile(const wxString &fileName) ;
// in response of a open-application apple event
virtual void MacNewFile() ;
// in response of a reopen-application apple event
virtual void MacReopenApp() ;
// override this to return false from a non-bundled console app in order to stay in background ...
virtual bool OSXIsGUIApplication() { return true; }
#if wxOSX_USE_COCOA_OR_IPHONE
// immediately before the native event loop launches
virtual void OSXOnWillFinishLaunching();
// immediately when the native event loop starts, no events have been served yet
virtual void OSXOnDidFinishLaunching();
// OS asks to terminate app, return no to stay running
virtual bool OSXOnShouldTerminate();
// before application terminates
virtual void OSXOnWillTerminate();
private:
bool m_onInitResult;
bool m_inited;
wxArrayString m_openFiles;
wxArrayString m_printFiles;
wxString m_getURL;
public:
bool OSXInitWasCalled() { return m_inited; }
void OSXStoreOpenFiles(const wxArrayString &files ) { m_openFiles = files ; }
void OSXStorePrintFiles(const wxArrayString &files ) { m_printFiles = files ; }
void OSXStoreOpenURL(const wxString &url ) { m_getURL = url ; }
#endif
// Hide the application windows the same as the system hide command would do it.
void MacHideApp();
wxDECLARE_EVENT_TABLE();
};
#endif
// _WX_APP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dcmemory.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dcmemory.h
// Purpose: wxMemoryDC class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCMEMORY_H_
#define _WX_DCMEMORY_H_
#include "wx/osx/dcclient.h"
class WXDLLIMPEXP_CORE wxMemoryDCImpl: public wxPaintDCImpl
{
public:
wxMemoryDCImpl( wxMemoryDC *owner );
wxMemoryDCImpl( wxMemoryDC *owner, wxBitmap& bitmap );
wxMemoryDCImpl( wxMemoryDC *owner, wxDC *dc );
virtual ~wxMemoryDCImpl();
virtual void DoGetSize( int *width, int *height ) const;
virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const
{ return subrect == NULL ? GetSelectedBitmap() : GetSelectedBitmap().GetSubBitmap(*subrect); }
virtual void DoSelect(const wxBitmap& bitmap);
virtual const wxBitmap& GetSelectedBitmap() const
{ return m_selected; }
virtual wxBitmap& GetSelectedBitmap()
{ return m_selected; }
private:
void Init();
wxBitmap m_selected;
wxDECLARE_CLASS(wxMemoryDCImpl);
wxDECLARE_NO_COPY_CLASS(wxMemoryDCImpl);
};
#endif
// _WX_DCMEMORY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/anybutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: anybutton.h
// Purpose: wxAnyButton class
// Author: Stefan Csomor
// Created: 1998-01-01 (extracted from button.h)
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_ANYBUTTON_H_
#define _WX_OSX_ANYBUTTON_H_
// Any button
class WXDLLIMPEXP_CORE wxAnyButton : public wxAnyButtonBase
{
public:
wxAnyButton() {}
static wxSize GetDefaultSize();
virtual void SetLabel(const wxString& label) wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
void OnEnterWindow( wxMouseEvent& event);
void OnLeaveWindow( wxMouseEvent& event);
virtual wxBitmap DoGetBitmap(State which) const wxOVERRIDE;
virtual void DoSetBitmap(const wxBitmap& bitmap, State which) wxOVERRIDE;
virtual void DoSetBitmapPosition(wxDirection dir) wxOVERRIDE;
virtual void DoSetBitmapMargins(int x, int y) wxOVERRIDE
{
m_marginX = x;
m_marginY = y;
InvalidateBestSize();
}
#if wxUSE_MARKUP && wxOSX_USE_COCOA
virtual bool DoSetLabelMarkup(const wxString& markup) wxOVERRIDE;
#endif // wxUSE_MARKUP && wxOSX_USE_COCOA
// the margins around the bitmap
int m_marginX;
int m_marginY;
// the bitmaps for the different state of the buttons, all of them may be
// invalid and the button only shows a bitmap at all if State_Normal bitmap
// is valid
wxBitmap m_bitmaps[State_Max];
wxDECLARE_NO_COPY_CLASS(wxAnyButton);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_OSX_ANYBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/toplevel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/toplevel.h
// Purpose: wxTopLevelWindowMac is the Mac implementation of wxTLW
// Author: Stefan Csomor
// Modified by:
// Created: 20.09.01
// Copyright: (c) 2001 Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TOPLEVEL_H_
#define _WX_MSW_TOPLEVEL_H_
// ----------------------------------------------------------------------------
// wxTopLevelWindowMac
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindowMac : public wxTopLevelWindowBase
{
public:
// constructors and such
wxTopLevelWindowMac() { Init(); }
wxTopLevelWindowMac(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();
(void)Create(parent, id, title, pos, size, style, name);
}
virtual ~wxTopLevelWindowMac();
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);
bool Create(wxWindow *parent, WXWindow nativeWindow);
virtual bool Destroy() wxOVERRIDE;
virtual wxPoint GetClientAreaOrigin() const wxOVERRIDE;
// Attracts the users attention to this window if the application is
// inactive (should be called when a background event occurs)
virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO) wxOVERRIDE;
// implement base class pure virtuals
virtual void Maximize(bool maximize = true) wxOVERRIDE;
virtual bool IsMaximized() const wxOVERRIDE;
virtual void Iconize(bool iconize = true) wxOVERRIDE;
virtual bool IsIconized() const wxOVERRIDE;
virtual void Restore() wxOVERRIDE;
virtual bool IsActive() wxOVERRIDE;
virtual void ShowWithoutActivating() wxOVERRIDE;
bool EnableFullScreenView(bool enable = true) wxOVERRIDE;
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) wxOVERRIDE;
virtual bool IsFullScreen() const wxOVERRIDE;
// implementation from now on
// --------------------------
virtual void SetTitle( const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
// EnableCloseButton(false) used to disable the "Close"
// button on the title bar
virtual bool EnableCloseButton(bool enable = true) wxOVERRIDE;
virtual bool EnableMaximizeButton(bool enable = true) wxOVERRIDE;
virtual bool EnableMinimizeButton(bool enable = true) wxOVERRIDE;
virtual void SetLabel(const wxString& label) wxOVERRIDE { SetTitle( label ); }
virtual wxString GetLabel() const wxOVERRIDE { return GetTitle(); }
virtual void OSXSetModified(bool modified) wxOVERRIDE;
virtual bool OSXIsModified() const wxOVERRIDE;
virtual void SetRepresentedFilename(const wxString& filename) wxOVERRIDE;
// do *not* call this to iconize the frame, this is a private function!
void OSXSetIconizeState(bool iconic);
protected:
// common part of all ctors
void Init();
// is the frame currently iconized?
bool m_iconized;
// should the frame be maximized when it will be shown? set by Maximize()
// when it is called while the frame is hidden
bool m_maximizeOnShow;
private :
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_MSW_TOPLEVEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/sound.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/sound.h
// Purpose: wxSound class (loads and plays short Windows .wav files).
// Optional on non-Windows platforms.
// Author: Ryan Norton, Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Ryan Norton, Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SOUND_H_
#define _WX_SOUND_H_
#if wxUSE_SOUND
#include "wx/object.h"
class WXDLLIMPEXP_FWD_CORE wxSoundTimer;
class WXDLLIMPEXP_CORE wxSoundData
{
public :
wxSoundData();
virtual ~wxSoundData();
virtual bool Play(unsigned int flags) = 0;
// stops the sound and deletes the optional timer
virtual void Stop();
// mark this to be deleted
virtual void MarkForDeletion();
virtual bool IsMarkedForDeletion() const { return m_markedForDeletion; }
// does the true work of stopping and cleaning up
virtual void DoStop() = 0;
protected:
unsigned int m_flags;
bool m_markedForDeletion;
} ;
class WXDLLIMPEXP_CORE wxSound : public wxSoundBase
{
public:
wxSound();
wxSound(const wxString& fileName, bool isResource = false);
wxSound(size_t size, const void* data);
virtual ~wxSound();
// Create from resource or file
bool Create(const wxString& fileName, bool isResource = false);
// Create from data
bool Create(size_t size, const void* data);
bool IsOk() const { return m_data != NULL; }
// Stop playing any sound
static void Stop();
// Returns true if a sound is being played
static bool IsPlaying();
// Notification when a sound has stopped
static void SoundStopped(const wxSoundData* data);
protected:
bool DoPlay(unsigned flags) const;
void Init();
private:
// data of this object
class wxSoundData *m_data;
wxDECLARE_NO_COPY_CLASS(wxSound);
};
#endif
#endif
// _WX_SOUND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/tooltip.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/tooltip.h
// Purpose: wxToolTip class - tooltip control
// Author: Stefan Csomor
// Modified by:
// Created: 31.01.99
// Copyright: (c) 1999 Robert Roebling, Vadim Zeitlin, Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_TOOLTIP_H_
#define _WX_MAC_TOOLTIP_H_
#include "wx/string.h"
#include "wx/event.h"
class WXDLLIMPEXP_CORE wxToolTip : public wxObject
{
public:
// ctor & dtor
wxToolTip(const wxString &tip);
virtual ~wxToolTip();
// accessors
// tip text
void SetTip(const wxString& tip);
const wxString& GetTip() const { return m_text; }
// the window we're associated with
void SetWindow(wxWindow *win);
wxWindow *GetWindow() const { return m_window; }
// controlling tooltip behaviour: globally change tooltip parameters
// enable or disable the tooltips globally
static void Enable(bool flag);
// set the delay after which the tooltip appears
static void SetDelay(long milliseconds);
// set the delay after which the tooltip disappears or how long the tooltip remains visible
static void SetAutoPop(long milliseconds);
// set the delay between subsequent tooltips to appear
static void SetReshow(long milliseconds);
static void NotifyWindowDelete( WXHWND win ) ;
// implementation only from now on
// -------------------------------
// should be called in response to mouse events
static void RelayEvent(wxWindow *win , wxMouseEvent &event);
static void RemoveToolTips();
private:
wxString m_text; // tooltip text
wxWindow *m_window; // window we're associated with
wxDECLARE_ABSTRACT_CLASS(wxToolTip);
};
#endif // _WX_MAC_TOOLTIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/stattext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/stattext.h
// Purpose: wxStaticText class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATTEXT_H_
#define _WX_STATTEXT_H_
class WXDLLIMPEXP_CORE wxStaticText: public wxStaticTextBase
{
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);
// accessors
void SetLabel( const wxString &str ) ;
bool SetFont( const wxFont &font );
virtual bool AcceptsFocus() const { return false; }
protected :
virtual wxString DoGetLabel() const;
virtual void DoSetLabel(const wxString& str);
virtual wxSize DoGetBestSize() const ;
#if wxUSE_MARKUP && wxOSX_USE_COCOA
virtual bool DoSetLabelMarkup(const wxString& markup);
#endif // wxUSE_MARKUP && wxOSX_USE_COCOA
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticText);
};
#endif
// _WX_STATTEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/statusbr.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/statusbr.h
// Purpose: native implementation of wxStatusBar.
// Optional: can use generic version instead.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATBAR_H_
#define _WX_STATBAR_H_
class WXDLLIMPEXP_CORE wxStatusBarMac : public wxStatusBarGeneric
{
public:
wxStatusBarMac();
wxStatusBarMac(wxWindow *parent, wxWindowID id = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr);
virtual ~wxStatusBarMac();
bool Create(wxWindow *parent, wxWindowID id = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr);
// Implementation
virtual void MacHiliteChanged() wxOVERRIDE;
void OnPaint(wxPaintEvent& event);
protected:
virtual void DrawFieldText(wxDC& dc, const wxRect& rc, int i, int textHeight) wxOVERRIDE;
virtual void DrawField(wxDC& dc, int i, int textHeight) wxOVERRIDE;
virtual void DoUpdateStatusText(int number = 0) wxOVERRIDE;
virtual void InitColours() wxOVERRIDE;
private:
wxColour m_textActive, m_textInactive,
m_bgActiveFrom, m_bgActiveTo,
m_borderActive, m_borderInactive;
wxDECLARE_DYNAMIC_CLASS(wxStatusBarMac);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_STATBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/webviewhistoryitem_webkit.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/osx/webviewhistoryitem.h
// Purpose: wxWebViewHistoryItem header for OSX
// Author: Steven Lamerton
// Copyright: (c) 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_WEBVIEWHISTORYITEM_H_
#define _WX_OSX_WEBVIEWHISTORYITEM_H_
#include "wx/defs.h"
#if wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT && defined(__WXOSX__)
#include "wx/osx/core/objcid.h"
class WXDLLIMPEXP_WEBVIEW wxWebViewHistoryItem
{
public:
wxWebViewHistoryItem(const wxString& url, const wxString& title) :
m_url(url), m_title(title) {}
wxString GetUrl() { return m_url; }
wxString GetTitle() { return m_title; }
friend class wxWebViewWebKit;
private:
wxString m_url, m_title;
wxObjCID m_histItem;
};
#endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT
#endif // _WX_OSX_WEBVIEWHISTORYITEM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/radiobut.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/radiobut.h
// Purpose: wxRadioButton class
// Author: Stefan Csomor
// Modified by:
// Created: 01/02/97
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBUT_H_
#define _WX_RADIOBUT_H_
class WXDLLIMPEXP_CORE wxRadioButton: public wxControl
{
wxDECLARE_DYNAMIC_CLASS(wxRadioButton);
public:
wxRadioButton() {}
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);
}
virtual ~wxRadioButton();
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 ;
// implementation
void Command(wxCommandEvent& event);
wxRadioButton *AddInCycle(wxRadioButton *cycle);
void RemoveFromCycle();
wxRadioButton *NextInCycle() {return m_cycle;}
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec );
protected:
wxRadioButton *m_cycle;
};
// Not implemented
#if 0
class WXDLLIMPEXP_FWD_CORE wxBitmap ;
WXDLLIMPEXP_DATA_CORE(extern const wxChar) wxBitmapRadioButtonNameStr[];
class WXDLLIMPEXP_CORE wxBitmapRadioButton: public wxRadioButton
{
wxDECLARE_DYNAMIC_CLASS(wxBitmapRadioButton);
protected:
wxBitmap *theButtonBitmap;
public:
wxBitmapRadioButton() { theButtonBitmap = NULL; }
wxBitmapRadioButton(wxWindow *parent, wxWindowID id,
const wxBitmap *label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxBitmapRadioButtonNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxBitmap *label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxBitmapRadioButtonNameStr);
virtual void SetLabel(const wxBitmap *label);
virtual void SetValue(bool val) ;
virtual bool GetValue() const ;
};
#endif
#endif
// _WX_RADIOBUT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/radiobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/radiobox.h
// Purpose: wxRadioBox class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBOX_H_
#define _WX_RADIOBOX_H_
#include "wx/containr.h"
// List box item
class WXDLLIMPEXP_FWD_CORE wxBitmap ;
class WXDLLIMPEXP_FWD_CORE wxRadioButton ;
class WXDLLIMPEXP_CORE wxRadioBox: public wxNavigationEnabled<wxControl>, public wxRadioBoxBase
{
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
public:
// Constructors & destructor
wxRadioBox();
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)
{
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)
{
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) wxOVERRIDE;
virtual bool Enable(unsigned int item, bool enable = true) wxOVERRIDE;
virtual bool IsItemEnabled(unsigned int item) const wxOVERRIDE;
// Showing
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Show(unsigned int item, bool show = true) wxOVERRIDE;
virtual bool IsItemShown(unsigned int item) const wxOVERRIDE;
// Specific functions (in wxWidgets2 reference)
virtual void SetSelection(int item) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual unsigned int GetCount() const wxOVERRIDE { return m_noItems; }
virtual wxString GetString(unsigned int item) const wxOVERRIDE;
virtual void SetString(unsigned int item, const wxString& label) wxOVERRIDE;
virtual wxString GetLabel() const wxOVERRIDE;
virtual void SetLabel(const wxString& label) wxOVERRIDE;
// protect native font of box
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
// Other external functions
void Command(wxCommandEvent& event) wxOVERRIDE;
void SetFocus() wxOVERRIDE;
// Other variable access functions
int GetNumberOfRowsOrCols() const { return m_noRowsOrCols; }
void SetNumberOfRowsOrCols(int n) { m_noRowsOrCols = n; }
void OnRadioButton( wxCommandEvent& event ) ;
protected:
// resolve ambiguity in base classes
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxRadioBoxBase::GetDefaultBorder(); }
wxRadioButton *m_radioButtonCycle;
unsigned int m_noItems;
int m_noRowsOrCols;
// Internal functions
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
wxDECLARE_EVENT_TABLE();
};
#endif
// _WX_RADIOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/checklst.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/checklst.h
// Purpose: wxCheckListBox class - a listbox with checkable items
// Note: this is an optional class.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_CHECKLST_H_
#define _WX_MAC_CHECKLST_H_
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)
{
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 nStrings = 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 wxOVERRIDE;
void Check(unsigned int uiIndex, bool bCheck = true) wxOVERRIDE;
// data callbacks
virtual void GetValueCallback( unsigned int n, wxListWidgetColumn* col , wxListWidgetCellValue& value ) wxOVERRIDE;
virtual void SetValueCallback( unsigned int n, wxListWidgetColumn* col , wxListWidgetCellValue& value ) wxOVERRIDE;
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;
// the array containing the checked status of the items
wxArrayInt m_checks;
wxListWidgetColumn* m_checkColumn ;
void Init();
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxCheckListBox);
};
#endif // _WX_MAC_CHECKLST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/listbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/listbox.h
// Purpose: wxListBox class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTBOX_H_
#define _WX_LISTBOX_H_
// ----------------------------------------------------------------------------
// simple types
// ----------------------------------------------------------------------------
#include "wx/dynarray.h"
#include "wx/arrstr.h"
// forward decl for GetSelections()
class wxArrayInt;
// forward decl for wxListWidgetImpl implementation type.
class wxListWidgetImpl;
// List box item
WX_DEFINE_ARRAY( char* , wxListDataArray );
// ----------------------------------------------------------------------------
// List box control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxListWidgetColumn;
class WXDLLIMPEXP_FWD_CORE wxListWidgetCellValue;
class WXDLLIMPEXP_CORE wxListBox : public wxListBoxBase
{
public:
// ctors and such
wxListBox();
wxListBox(
wxWindow *parent,
wxWindowID winid,
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, winid, pos, size, n, choices, style, validator, name);
}
wxListBox(
wxWindow *parent,
wxWindowID winid,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Create(parent, winid, pos, size, choices, style, validator, name);
}
bool Create(
wxWindow *parent,
wxWindowID winid,
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 winid,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
virtual ~wxListBox();
// implement base class pure virtuals
virtual void Refresh(bool eraseBack = true, const wxRect *rect = NULL) 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;
// data callbacks
virtual void GetValueCallback( unsigned int n, wxListWidgetColumn* col , wxListWidgetCellValue& value );
virtual void SetValueCallback( unsigned int n, wxListWidgetColumn* col , wxListWidgetCellValue& value );
virtual bool IsSelected(int n) const wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual int GetSelections(wxArrayInt& aSelections) const wxOVERRIDE;
virtual void EnsureVisible(int n) wxOVERRIDE;
virtual int GetTopItem() const wxOVERRIDE;
virtual int GetCountPerPage() const wxOVERRIDE;
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
// wxCheckListBox support
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
wxListWidgetImpl* GetListPeer() const;
virtual void HandleLineEvent( unsigned int n, bool doubleClick );
// This is called by wxNSTableView
void MacHandleSelectionChange(int row);
protected:
// callback for derived classes which may have to insert additional data
// at a certain line - which cannot be predetermined for sorted list data
virtual void OnItemInserted(unsigned int pos);
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
// from wxItemContainer
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;
// from wxListBoxBase
virtual void DoSetSelection(int n, bool select) wxOVERRIDE;
virtual void DoSetFirstItem(int n) wxOVERRIDE;
virtual int DoListHitTest(const wxPoint& point) const wxOVERRIDE;
// free memory (common part of Clear() and dtor)
// prevent collision with some BSD definitions of macro Free()
void FreeData();
virtual wxSize DoGetBestSize() const wxOVERRIDE;
bool m_blockEvents;
wxListWidgetColumn* m_textColumn;
// data storage (copied from univ)
// the array containing all items (it is sorted if the listbox has
// wxLB_SORT style)
union
{
wxArrayString *unsorted;
wxSortedArrayString *sorted;
} m_strings;
// and this one the client data (either void or wxClientData)
wxArrayPtrVoid m_itemsClientData;
private:
wxDECLARE_DYNAMIC_CLASS(wxListBox);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_LISTBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/textentry.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/textentry.h
// Purpose: wxTextEntry class
// Author: Stefan Csomor
// Modified by: Kevin Ollivier
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_TEXTENTRY_H_
#define _WX_OSX_TEXTENTRY_H_
#if wxUSE_SYSTEM_OPTIONS
// set this to 'true' if you want to use the 'classic' MLTE-based implementation
// instead of the HIView-based implementation in 10.3 and upwards, the former
// has more features (backgrounds etc.), but may show redraw artefacts and other
// problems depending on your usage; hence, the default is 'false'.
#define wxMAC_TEXTCONTROL_USE_MLTE wxT("mac.textcontrol-use-mlte")
// set this to 'true' if you want editable text controls to have spell checking turned
// on by default, you can change this setting individually on a control using MacCheckSpelling
#define wxMAC_TEXTCONTROL_USE_SPELL_CHECKER wxT("mac.textcontrol-use-spell-checker")
#endif
#include "wx/control.h"
// forward decl for wxListWidgetImpl implementation type.
class WXDLLIMPEXP_FWD_CORE wxTextWidgetImpl;
class WXDLLIMPEXP_CORE wxTextEntry: public wxTextEntryBase
{
public:
wxTextEntry();
virtual ~wxTextEntry();
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 Remove(long from, long to);
// set the max number of characters which may be entered
// in a single line text control
virtual void SetMaxLength(unsigned long len);
virtual void ForceUpper();
// writing text inserts it at the current position;
// appending always inserts it at the end
virtual void WriteText(const wxString& text);
// Clipboard operations
virtual void Copy();
virtual void Cut();
virtual void Paste();
virtual bool CanCopy() const;
virtual bool CanCut() const;
virtual bool CanPaste() const;
// 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 bool SendMaxLenEvent();
// set the grayed out hint text
virtual bool SetHint(const wxString& hint);
virtual wxString GetHint() const;
// Implementation
// --------------
virtual wxTextWidgetImpl * GetTextPeer() const;
wxTextCompleter *OSXGetCompleter() const { return m_completer; }
protected:
virtual wxString DoGetValue() const;
virtual bool DoAutoCompleteStrings(const wxArrayString& choices);
virtual bool DoAutoCompleteCustom(wxTextCompleter *completer);
// The object providing auto-completions or NULL if none.
wxTextCompleter *m_completer;
bool m_editable;
// need to make this public because of the current implementation via callbacks
unsigned long m_maxLength;
private:
wxString m_hintString;
};
#endif // _WX_OSX_TEXTENTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/fontdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/fontdlg.h
// Purpose: wxFontDialog class using fonts window services (10.2+).
// Author: Ryan Norton
// Modified by:
// Created: 2004-09-25
// Copyright: (c) Ryan Norton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONTDLG_H_
#define _WX_FONTDLG_H_
#include "wx/dialog.h"
/*
* Font dialog
*/
/*
* support old notation
*/
#ifdef wxMAC_USE_EXPERIMENTAL_FONTDIALOG
#define wxOSX_USE_EXPERIMENTAL_FONTDIALOG wxMAC_USE_EXPERIMENTAL_FONTDIALOG
#endif
#ifndef wxOSX_USE_EXPERIMENTAL_FONTDIALOG
#define wxOSX_USE_EXPERIMENTAL_FONTDIALOG 1
#endif
#if wxOSX_USE_EXPERIMENTAL_FONTDIALOG
class WXDLLIMPEXP_CORE wxFontDialog : public wxDialog
{
public:
wxFontDialog();
wxFontDialog(wxWindow *parent);
wxFontDialog(wxWindow *parent, const wxFontData& data);
virtual ~wxFontDialog();
bool Create(wxWindow *parent);
bool Create(wxWindow *parent, const wxFontData& data);
int ShowModal();
wxFontData& GetFontData() { return m_fontData; }
protected:
wxFontData m_fontData;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxFontDialog);
};
extern "C" int RunMixedFontDialog(wxFontDialog* dialog) ;
#else // wxOSX_USE_EXPERIMENTAL_FONTDIALOG
#if !USE_NATIVE_FONT_DIALOG_FOR_MACOSX
/*!
* Forward declarations
*/
class wxFontColourSwatchCtrl;
class wxFontPreviewCtrl;
class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
class WXDLLIMPEXP_FWD_CORE wxSpinEvent;
class WXDLLIMPEXP_FWD_CORE wxListBox;
class WXDLLIMPEXP_FWD_CORE wxChoice;
class WXDLLIMPEXP_FWD_CORE wxButton;
class WXDLLIMPEXP_FWD_CORE wxStaticText;
class WXDLLIMPEXP_FWD_CORE wxCheckBox;
/*!
* Control identifiers
*/
#define wxID_FONTDIALOG_FACENAME 20001
#define wxID_FONTDIALOG_FONTSIZE 20002
#define wxID_FONTDIALOG_BOLD 20003
#define wxID_FONTDIALOG_ITALIC 20004
#define wxID_FONTDIALOG_UNDERLINED 20005
#define wxID_FONTDIALOG_COLOUR 20006
#define wxID_FONTDIALOG_PREVIEW 20007
#endif
// !USE_NATIVE_FONT_DIALOG_FOR_MACOSX
class WXDLLIMPEXP_CORE wxFontDialog: public wxDialog
{
wxDECLARE_DYNAMIC_CLASS(wxFontDialog);
#if !USE_NATIVE_FONT_DIALOG_FOR_MACOSX
wxDECLARE_EVENT_TABLE();
#endif
public:
wxFontDialog();
wxFontDialog(wxWindow *parent, const wxFontData& data);
virtual ~wxFontDialog();
bool Create(wxWindow *parent, const wxFontData& data);
int ShowModal();
wxFontData& GetFontData() { return m_fontData; }
bool IsShown() const;
void OnPanelClose();
void SetData(const wxFontData& data);
#if !USE_NATIVE_FONT_DIALOG_FOR_MACOSX
/// Creates the controls and sizers
void CreateControls();
/// Initialize font
void InitializeFont();
/// Set controls according to current font
void InitializeControls();
/// Respond to font change
void ChangeFont();
/// Respond to colour change
void OnColourChanged(wxCommandEvent& event);
/// wxEVT_LISTBOX event handler for wxID_FONTDIALOG_FACENAME
void OnFontdialogFacenameSelected( wxCommandEvent& event );
/// wxEVT_SPINCTRL event handler for wxID_FONTDIALOG_FONTSIZE
void OnFontdialogFontsizeUpdated( wxSpinEvent& event );
/// wxEVT_TEXT event handler for wxID_FONTDIALOG_FONTSIZE
void OnFontdialogFontsizeTextUpdated( wxCommandEvent& event );
/// wxEVT_CHECKBOX event handler for wxID_FONTDIALOG_BOLD
void OnFontdialogBoldClick( wxCommandEvent& event );
/// wxEVT_CHECKBOX event handler for wxID_FONTDIALOG_ITALIC
void OnFontdialogItalicClick( wxCommandEvent& event );
/// wxEVT_CHECKBOX event handler for wxID_FONTDIALOG_UNDERLINED
void OnFontdialogUnderlinedClick( wxCommandEvent& event );
/// wxEVT_BUTTON event handler for wxID_OK
void OnOkClick( wxCommandEvent& event );
/// Should we show tooltips?
static bool ShowToolTips();
wxListBox* m_facenameCtrl;
wxSpinCtrl* m_sizeCtrl;
wxCheckBox* m_boldCtrl;
wxCheckBox* m_italicCtrl;
wxCheckBox* m_underlinedCtrl;
wxFontColourSwatchCtrl* m_colourCtrl;
wxFontPreviewCtrl* m_previewCtrl;
wxFont m_dialogFont;
bool m_suppressUpdates;
#endif
// !USE_NATIVE_FONT_DIALOG_FOR_MACOSX
protected:
wxWindow* m_dialogParent;
wxFontData m_fontData;
void* m_pEventHandlerRef;
};
#endif
#endif
// _WX_FONTDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/filedlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/filedlg.h
// Purpose: wxFileDialog class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FILEDLG_H_
#define _WX_FILEDLG_H_
class WXDLLIMPEXP_FWD_CORE wxChoice;
//-------------------------------------------------------------------------
// wxFileDialog
//-------------------------------------------------------------------------
// set this system option to 1 in order to always show the filetypes popup in
// file open dialogs if possible
#define wxOSX_FILEDIALOG_ALWAYS_SHOW_TYPES wxT("osx.openfiledialog.always-show-types")
class WXDLLIMPEXP_CORE wxFileDialog: public wxFileDialogBase
{
wxDECLARE_DYNAMIC_CLASS(wxFileDialog);
protected:
wxArrayString m_fileNames;
wxArrayString m_paths;
public:
wxFileDialog() { Init(); }
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)
{
Init();
Create(parent,message,defaultDir,defaultFile,wildCard,style,pos,sz,name);
}
void Create(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);
#if wxOSX_USE_COCOA
~wxFileDialog();
#endif
virtual void GetPaths(wxArrayString& paths) const { paths = m_paths; }
virtual void GetFilenames(wxArrayString& files) const { files = m_fileNames ; }
virtual int ShowModal();
#if wxOSX_USE_COCOA
virtual void ShowWindowModal();
virtual void ModalFinishedCallback(void* panel, int resultCode);
#endif
virtual bool SupportsExtraControl() const;
// implementation only
#if wxOSX_USE_COCOA
// returns true if the file can be shown as active
bool CheckFile( const wxString& filename );
#endif
protected:
// not supported for file dialog, RR
virtual void DoSetSize(int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(sizeFlags) = wxSIZE_AUTO) {}
void SetupExtraControls(WXWindow nativeWindow);
#if wxOSX_USE_COCOA
virtual wxWindow* CreateFilterPanel(wxWindow *extracontrol);
void DoOnFilterSelected(int index);
virtual void OnFilterSelected(wxCommandEvent &event);
wxArrayString m_filterExtensions;
wxArrayString m_filterNames;
wxChoice* m_filterChoice;
wxWindow* m_filterPanel;
bool m_useFileTypeFilter;
int m_firstFileTypeFilter;
wxArrayString m_currentExtensions;
WX_NSObject m_delegate;
WX_NSObject m_sheetDelegate;
#endif
private:
// Common part of all ctors.
void Init();
};
#endif // _WX_FILEDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/spinbutt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/spinbutt.h
// Purpose: wxSpinButton class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SPINBUTT_H_
#define _WX_SPINBUTT_H_
#include "wx/control.h"
#include "wx/event.h"
/*
The wxSpinButton is like a small scrollbar than is often placed next
to a text control.
wxSP_HORIZONTAL: horizontal spin button
wxSP_VERTICAL: vertical spin button (the default)
wxSP_ARROW_KEYS: arrow keys increment/decrement value
wxSP_WRAP: value wraps at either end
*/
class WXDLLIMPEXP_CORE wxSpinButton : public wxSpinButtonBase
{
public:
// construction
wxSpinButton();
wxSpinButton(wxWindow *parent,
wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxT("wxSpinButton"))
{
Create(parent, id, pos, size, style, name);
}
virtual ~wxSpinButton();
bool Create(wxWindow *parent,
wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxT("wxSpinButton"));
// accessors
virtual void SetRange(int minVal, int maxVal);
virtual int GetValue() const ;
virtual void SetValue(int val);
// implementation
virtual void TriggerScrollEvent( wxEventType scrollEvent ) ;
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec );
protected:
void SendThumbTrackEvent() ;
virtual wxSize DoGetBestSize() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxSpinButton);
};
#endif
// _WX_SPINBUTT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/srchctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/srchctrl.h
// Purpose: mac carbon wxSearchCtrl class
// Author: Vince Harron
// Created: 2006-02-19
// Copyright: Vince Harron
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SEARCHCTRL_H_
#define _WX_SEARCHCTRL_H_
#if wxUSE_SEARCHCTRL
class wxSearchWidgetImpl;
class WXDLLIMPEXP_CORE wxSearchCtrl : public wxSearchCtrlBase
{
public:
// creation
// --------
wxSearchCtrl();
wxSearchCtrl(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSearchCtrlNameStr);
virtual ~wxSearchCtrl();
bool Create(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSearchCtrlNameStr);
#if wxUSE_MENUS
// get/set search button menu
// --------------------------
virtual void SetMenu( wxMenu* menu ) wxOVERRIDE;
virtual wxMenu* GetMenu() wxOVERRIDE;
#endif // wxUSE_MENUS
// get/set search options
// ----------------------
virtual void ShowSearchButton( bool show ) wxOVERRIDE;
virtual bool IsSearchButtonVisible() const wxOVERRIDE;
virtual void ShowCancelButton( bool show ) wxOVERRIDE;
virtual bool IsCancelButtonVisible() const wxOVERRIDE;
virtual void SetDescriptiveText(const wxString& text) wxOVERRIDE;
virtual wxString GetDescriptiveText() const wxOVERRIDE;
virtual bool HandleSearchFieldSearchHit() ;
virtual bool HandleSearchFieldCancelHit() ;
wxSearchWidgetImpl * GetSearchPeer() const;
protected:
wxSize DoGetBestSize() const wxOVERRIDE;
void Init();
#if wxUSE_MENUS
wxMenu *m_menu;
#endif // wxUSE_MENUS
wxString m_descriptiveText;
private:
wxDECLARE_DYNAMIC_CLASS(wxSearchCtrl);
wxDECLARE_EVENT_TABLE();
};
#endif // wxUSE_SEARCHCTRL
#endif // _WX_SEARCHCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/statbmp.h | #ifndef _WX_STATBMP_H_
#define _WX_STATBMP_H_
#include "wx/statbmp.h"
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
public:
wxStaticBitmap() {}
wxStaticBitmap(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr)
{
Create(parent, id, bitmap, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual void SetBitmap(const wxBitmap& bitmap) wxOVERRIDE;
virtual wxBitmap GetBitmap() const wxOVERRIDE { return m_bitmap; }
virtual void SetIcon(const wxIcon& icon) wxOVERRIDE
{
wxBitmap bmp;
bmp.CopyFromIcon(icon);
SetBitmap(bmp);
}
#if defined(__WXGTK20__) || defined(__WXMAC__)
// icons and bitmaps are really the same thing in wxGTK and wxMac
wxIcon GetIcon() const wxOVERRIDE { return (const wxIcon &)m_bitmap; }
#endif
virtual void SetScaleMode(ScaleMode scaleMode) wxOVERRIDE;
virtual ScaleMode GetScaleMode() const wxOVERRIDE { return m_scaleMode; }
private:
wxSize GetBitmapSize()
{
return m_bitmap.IsOk() ? m_bitmap.GetScaledSize()
: wxSize(16, 16); // this is completely arbitrary
}
void OnPaint(wxPaintEvent& event);
wxBitmap m_bitmap;
ScaleMode m_scaleMode;
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
};
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/slider.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/slider.h
// Purpose: wxSlider class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SLIDER_H_
#define _WX_SLIDER_H_
#include "wx/compositewin.h"
#include "wx/stattext.h"
// Slider
class WXDLLIMPEXP_CORE wxSlider: public wxCompositeWindow<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 wxOVERRIDE;
virtual void SetValue(int) wxOVERRIDE;
void SetRange(int minValue, int maxValue) wxOVERRIDE;
int GetMin() const wxOVERRIDE { return m_rangeMin; }
int GetMax() const wxOVERRIDE { return m_rangeMax; }
void SetMin(int minValue) { SetRange(minValue, m_rangeMax); }
void SetMax(int maxValue) { SetRange(m_rangeMin, maxValue); }
// For trackbars only
int GetTickFreq() const wxOVERRIDE { return m_tickFreq; }
void SetPageSize(int pageSize) wxOVERRIDE;
int GetPageSize() const wxOVERRIDE;
void ClearSel() wxOVERRIDE;
void ClearTicks() wxOVERRIDE;
void SetLineSize(int lineSize) wxOVERRIDE;
int GetLineSize() const wxOVERRIDE;
int GetSelEnd() const wxOVERRIDE;
int GetSelStart() const wxOVERRIDE;
void SetSelection(int minPos, int maxPos) wxOVERRIDE;
void SetThumbLength(int len) wxOVERRIDE;
int GetThumbLength() const wxOVERRIDE;
void SetTick(int tickPos) wxOVERRIDE;
void Command(wxCommandEvent& event) wxOVERRIDE;
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec ) wxOVERRIDE;
virtual void TriggerScrollEvent( wxEventType scrollEvent ) wxOVERRIDE;
protected:
// Platform-specific implementation of SetTickFreq
virtual void DoSetTickFreq(int freq) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual void DoSetSize(int x, int y, int w, int h, int sizeFlags) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int w, int h) wxOVERRIDE;
// set min/max size of the slider
virtual void DoSetSizeHints( int minW, int minH,
int maxW, int maxH,
int incW, int incH) wxOVERRIDE;
// Common processing to invert slider values based on wxSL_INVERSE
virtual int ValueInvertOrNot(int value) const wxOVERRIDE;
wxStaticText* m_macMinimumStatic ;
wxStaticText* m_macMaximumStatic ;
wxStaticText* m_macValueStatic ;
int m_rangeMin;
int m_rangeMax;
int m_pageSize;
int m_lineSize;
int m_tickFreq;
private :
virtual wxWindowList GetCompositeWindowParts() const wxOVERRIDE
{
wxWindowList parts;
parts.push_back(m_macMinimumStatic);
parts.push_back(m_macMaximumStatic);
parts.push_back(m_macValueStatic);
return parts;
}
wxDECLARE_EVENT_TABLE();
};
#endif
// _WX_SLIDER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/menuitem.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/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 _MENUITEM_H
#define _MENUITEM_H
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/defs.h"
#include "wx/bitmap.h"
// ----------------------------------------------------------------------------
// wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxMenuItemImpl ;
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
virtual void SetItemLabel(const wxString& strName);
virtual void Enable(bool bDoEnable = true);
virtual void Check(bool bDoCheck = true);
virtual void SetBitmap(const wxBitmap& bitmap) ;
virtual const wxBitmap& GetBitmap() const { return m_bitmap; }
// Implementation only from now on.
// update the os specific representation
void UpdateItemBitmap() ;
void UpdateItemText() ;
void UpdateItemStatus() ;
wxMenuItemImpl* GetPeer() { return m_peer; }
private:
void UncheckRadio() ;
wxBitmap m_bitmap; // Bitmap for menuitem, if any
wxMenuItemImpl* m_peer;
wxDECLARE_DYNAMIC_CLASS(wxMenuItem);
};
#endif //_MENUITEM_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/taskbarosx.h | /////////////////////////////////////////////////////////////////////////
// File: wx/mac/taskbarosx.h
// Purpose: Defines wxTaskBarIcon class for OSX
// Author: Ryan Norton
// Modified by:
// Created: 04/04/2003
// Copyright: (c) Ryan Norton, 2003
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////
#ifndef _TASKBAR_H_
#define _TASKBAR_H_
class WXDLLIMPEXP_FWD_CORE wxIcon;
class WXDLLIMPEXP_FWD_CORE wxMenu;
class WXDLLIMPEXP_ADV wxTaskBarIcon : public wxTaskBarIconBase
{
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTaskBarIcon);
public:
wxTaskBarIcon(wxTaskBarIconType iconType = wxTBI_DEFAULT_TYPE);
virtual ~wxTaskBarIcon();
// returns true if the taskbaricon is in the global menubar
#if wxOSX_USE_COCOA
bool OSXIsStatusItem();
#else
bool OSXIsStatusItem() { return false; }
#endif
bool IsOk() const { return true; }
bool IsIconInstalled() const;
bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxEmptyString);
bool RemoveIcon();
bool PopupMenu(wxMenu *menu);
protected:
wxTaskBarIconType m_type;
class wxTaskBarIconImpl* m_impl;
friend class wxTaskBarIconImpl;
};
#endif
// _TASKBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/toolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/toolbar.h
// Purpose: wxToolBar class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOOLBAR_H_
#define _WX_TOOLBAR_H_
#if wxUSE_TOOLBAR
#include "wx/tbarbase.h"
#include "wx/dynarray.h"
class WXDLLIMPEXP_CORE wxToolBar: public wxToolBarBase
{
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
public:
/*
* Public interface
*/
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);
}
virtual ~wxToolBar();
bool Create(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr);
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
virtual bool Destroy() wxOVERRIDE;
// override/implement base class virtuals
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const wxOVERRIDE;
#ifndef __WXOSX_IPHONE__
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool IsShown() const wxOVERRIDE;
#endif
virtual bool Realize() wxOVERRIDE;
virtual void SetToolBitmapSize(const wxSize& size) wxOVERRIDE;
virtual wxSize GetToolSize() const wxOVERRIDE;
virtual void SetRows(int nRows) wxOVERRIDE;
virtual void SetToolNormalBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolDisabledBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
#ifndef __WXOSX_IPHONE__
// Add all the buttons
virtual wxString MacGetToolTipString( wxPoint &where ) wxOVERRIDE;
void OnPaint(wxPaintEvent& event) ;
void OnMouse(wxMouseEvent& event) ;
virtual void MacSuperChangedPosition() wxOVERRIDE;
#endif
#if wxOSX_USE_NATIVE_TOOLBAR
// make all tools selectable
void OSXSetSelectableTools(bool set);
void OSXSelectTool(int toolId);
bool MacInstallNativeToolbar(bool usesNative);
void MacUninstallNativeToolbar();
bool MacWantsNativeToolbar();
bool MacTopLevelHasNativeToolbar(bool *ownToolbarInstalled) const;
#endif
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled = wxNullBitmap,
wxItemKind kind = wxITEM_NORMAL,
wxObject *clientData = NULL,
const wxString& shortHelp = wxEmptyString,
const wxString& longHelp = wxEmptyString) wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
void DoLayout();
void DoSetSize(int x, int y, int width, int height, int sizeFlags) wxOVERRIDE;
#ifndef __WXOSX_IPHONE__
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
#endif
#ifdef __WXOSX_COCOA__
virtual void DoGetPosition(int*x, int *y) const wxOVERRIDE;
#endif
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;
wxDECLARE_EVENT_TABLE();
#if wxOSX_USE_NATIVE_TOOLBAR
bool m_macUsesNativeToolbar ;
void* m_macToolbar ;
#endif
#ifdef __WXOSX_IPHONE__
WX_UIView m_macToolbar;
#endif
};
#endif // wxUSE_TOOLBAR
#endif
// _WX_TOOLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/gauge.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/gauge.h
// Purpose: wxGauge class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GAUGE_H_
#define _WX_GAUGE_H_
#include "wx/control.h"
// Group box
class WXDLLIMPEXP_CORE wxGauge: public wxGaugeBase
{
public:
wxGauge() { }
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);
// set gauge range/value
virtual void SetRange(int range);
virtual void SetValue(int pos);
virtual int GetValue() const ;
void Pulse();
protected:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxGauge);
};
#endif
// _WX_GAUGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/region.h | #if wxOSX_USE_COCOA_OR_CARBON
#include "wx/osx/carbon/region.h"
#else
#define wxRegionGeneric wxRegion
#define wxRegionIteratorGeneric wxRegionIterator
#include "wx/generic/region.h"
#endif
| h |
Subsets and Splits