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/Linux/include/wx/qt/statbmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/statbmp.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_STATBMP_H_
#define _WX_QT_STATBMP_H_
class QLabel;
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
public:
wxStaticBitmap();
wxStaticBitmap( wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr );
bool Create( wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual void SetIcon(const wxIcon& icon);
virtual void SetBitmap(const wxBitmap& bitmap);
virtual wxBitmap GetBitmap() const;
virtual wxIcon GetIcon() const;
virtual QWidget *GetHandle() const;
protected:
private:
QLabel *m_qtLabel;
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
};
#endif // _WX_QT_STATBMP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/slider.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/slider.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_SLIDER_H_
#define _WX_QT_SLIDER_H_
class QSlider;
class WXDLLIMPEXP_CORE wxSlider : public wxSliderBase
{
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);
bool Create(wxWindow *parent,
wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
virtual int GetValue() const;
virtual void SetValue(int value);
virtual void SetRange(int minValue, int maxValue);
virtual int GetMin() const;
virtual int GetMax() const;
virtual void DoSetTickFreq(int freq);
virtual int GetTickFreq() const;
virtual void SetLineSize(int lineSize);
virtual void SetPageSize(int pageSize);
virtual int GetLineSize() const;
virtual int GetPageSize() const;
virtual void SetThumbLength(int lenPixels);
virtual int GetThumbLength() const;
virtual QWidget *GetHandle() const;
private:
QSlider *m_qtSlider;
wxDECLARE_DYNAMIC_CLASS( wxSlider );
};
#endif // _WX_QT_SLIDER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/menuitem.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/menuitem.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_MENUITEM_H_
#define _WX_QT_MENUITEM_H_
#include "wx/menuitem.h"
#include "wx/bitmap.h"
class QAction;
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxMenu;
class WXDLLIMPEXP_CORE wxMenuItem : public wxMenuItemBase
{
public:
wxMenuItem(wxMenu *parentMenu = NULL,
int id = wxID_SEPARATOR,
const wxString& text = wxEmptyString,
const wxString& help = wxEmptyString,
wxItemKind kind = wxITEM_NORMAL,
wxMenu *subMenu = NULL);
virtual void SetItemLabel(const wxString& str);
virtual void SetCheckable(bool checkable);
virtual void Enable(bool enable = true);
virtual bool IsEnabled() const;
virtual void Check(bool check = true);
virtual bool IsChecked() const;
virtual void SetBitmap(const wxBitmap& bitmap);
virtual const wxBitmap& GetBitmap() const { return m_bitmap; };
virtual QAction *GetHandle() const;
private:
// Qt is using an action instead of a menu item.
QAction *m_qtAction;
wxBitmap m_bitmap;
wxDECLARE_DYNAMIC_CLASS( wxMenuItem );
};
#endif // _WX_QT_MENUITEM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/calctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/calctrl.h
// Purpose: wxCalendarCtrl control implementation for wxQt
// Author: Kolya Kosenko
// Created: 2010-05-12
// Copyright: (c) 2010 Kolya Kosenko
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CALCTRL_H_
#define _WX_QT_CALCTRL_H_
#include "wx/calctrl.h"
class QCalendarWidget;
class WXDLLIMPEXP_ADV wxCalendarCtrl : public wxCalendarCtrlBase
{
public:
wxCalendarCtrl() { Init(); }
wxCalendarCtrl(wxWindow *parent,
wxWindowID id,
const wxDateTime& date = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAL_SHOW_HOLIDAYS,
const wxString& name = wxCalendarNameStr)
{
Init();
Create(parent, id, date, pos, size, style, name);
}
virtual ~wxCalendarCtrl();
bool Create(wxWindow *parent,
wxWindowID id,
const wxDateTime& date = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAL_SHOW_HOLIDAYS,
const wxString& name = wxCalendarNameStr);
virtual bool SetDate(const wxDateTime& date);
virtual wxDateTime GetDate() const;
virtual bool SetDateRange(const wxDateTime& lowerdate = wxDefaultDateTime,
const wxDateTime& upperdate = wxDefaultDateTime);
virtual bool GetDateRange(wxDateTime *lowerdate, wxDateTime *upperdate) const;
virtual bool EnableMonthChange(bool enable = true);
virtual void Mark(size_t day, bool mark);
// holidays colours
virtual void SetHoliday(size_t day);
virtual void SetHolidayColours(const wxColour& colFg, const wxColour& colBg);
virtual const wxColour& GetHolidayColourFg() const { return m_colHolidayFg; }
virtual const wxColour& GetHolidayColourBg() const { return m_colHolidayBg; }
// header colours
virtual void SetHeaderColours(const wxColour& colFg, const wxColour& colBg);
virtual const wxColour& GetHeaderColourFg() const { return m_colHeaderFg; }
virtual const wxColour& GetHeaderColourBg() const { return m_colHeaderBg; }
// day attributes
virtual wxCalendarDateAttr *GetAttr(size_t day) const;
virtual void SetAttr(size_t day, wxCalendarDateAttr *attr);
virtual void ResetAttr(size_t day) { SetAttr(day, NULL); }
virtual void SetWindowStyleFlag(long style);
using wxCalendarCtrlBase::GenerateAllChangeEvents;
virtual QWidget *GetHandle() const;
protected:
virtual void RefreshHolidays();
private:
void Init();
void UpdateStyle();
QCalendarWidget *m_qtCalendar;
wxColour m_colHeaderFg,
m_colHeaderBg,
m_colHolidayFg,
m_colHolidayBg;
wxCalendarDateAttr *m_attrs[31];
wxDECLARE_DYNAMIC_CLASS(wxCalendarCtrl);
};
#endif // _WX_QT_CALCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/toolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/toolbar.h
// Author: Sean D'Epagnier, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
class QToolBar;
#ifndef _WX_QT_TOOLBAR_H_
#define _WX_QT_TOOLBAR_H_
class QActionGroup;
class wxQtToolBar;
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
wxToolBar() { Init(); }
wxToolBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE | wxNO_BORDER,
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 | wxNO_BORDER,
const wxString& name = wxToolBarNameStr);
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual QToolBar *GetQToolBar() const { return m_qtToolBar; }
virtual void SetWindowStyleFlag( long style ) wxOVERRIDE;
virtual void SetToolShortHelp(int id, const wxString& helpString) wxOVERRIDE;
virtual void SetToolNormalBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolDisabledBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(int toolid,
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;
QWidget *GetHandle() const wxOVERRIDE;
protected:
QActionGroup* GetActionGroup(size_t pos);
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;
private:
void Init();
long GetButtonStyle();
QToolBar *m_qtToolBar;
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
};
#endif // _WX_QT_TOOLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/gauge.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/gauge.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_GAUGE_H_
#define _WX_QT_GAUGE_H_
class QProgressBar;
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);
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);
virtual QWidget *GetHandle() const;
// set/get the control range
virtual void SetRange(int range);
virtual int GetRange() const;
virtual void SetValue(int pos);
virtual int GetValue() const;
private:
QProgressBar *m_qtProgressBar;
wxDECLARE_DYNAMIC_CLASS(wxGauge);
};
#endif // _WX_QT_GAUGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/spinctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/spinctrl.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_SPINCTRL_H_
#define _WX_QT_SPINCTRL_H_
class QSpinBox;
class QDoubleSpinBox;
// Take advantage of the Qt compile time polymorphy and use a template to avoid
// copy&paste code for the usage of QSpinBox/QDoubleSpinBox.
template < typename T, typename Widget >
class WXDLLIMPEXP_CORE wxSpinCtrlQt : public wxSpinCtrlBase
{
public:
wxSpinCtrlQt();
wxSpinCtrlQt( wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size, long style,
T min, T max, T initial, T inc,
const wxString& name );
bool Create( wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size, long style,
T min, T max, T initial, T inc,
const wxString& name );
virtual void SetValue(const wxString&) {}
virtual void SetSnapToTicks(bool snap_to_ticks);
virtual bool GetSnapToTicks() const;
virtual void SetSelection(long from, long to);
virtual void SetValue(T val);
void SetRange(T minVal, T maxVal);
void SetIncrement(T inc);
T GetValue() const;
T GetMin() const;
T GetMax() const;
T GetIncrement() const;
virtual QWidget *GetHandle() const;
protected:
Widget *m_qtSpinBox;
};
class WXDLLIMPEXP_CORE wxSpinCtrl : public wxSpinCtrlQt< int, QSpinBox >
{
public:
wxSpinCtrl();
wxSpinCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
int min = 0, int max = 100, int initial = 0,
const wxString& name = wxT("wxSpinCtrl"));
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
int min = 0, int max = 100, int initial = 0,
const wxString& name = wxT("wxSpinCtrl"));
virtual int GetBase() const wxOVERRIDE { return m_base; }
virtual bool SetBase(int base) wxOVERRIDE;
virtual void SetValue(const wxString & val);
virtual void SetValue(int val) { wxSpinCtrlQt<int,QSpinBox>::SetValue(val); }
private:
// Common part of all ctors.
void Init()
{
m_base = 10;
}
int m_base;
wxDECLARE_DYNAMIC_CLASS(wxSpinCtrl);
};
class WXDLLIMPEXP_CORE wxSpinCtrlDouble : public wxSpinCtrlQt< double, QDoubleSpinBox >
{
public:
wxSpinCtrlDouble();
wxSpinCtrlDouble(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
double min = 0, double max = 100, double initial = 0,
double inc = 1,
const wxString& name = wxT("wxSpinCtrlDouble"));
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
double min = 0, double max = 100, double initial = 0,
double inc = 1,
const wxString& name = wxT("wxSpinCtrlDouble"));
void SetDigits(unsigned digits);
unsigned GetDigits() const;
virtual int GetBase() const wxOVERRIDE { return 10; }
virtual bool SetBase(int WXUNUSED(base)) wxOVERRIDE { return false; }
virtual void SetValue(const wxString & val);
virtual void SetValue(double val) { wxSpinCtrlQt<double,QDoubleSpinBox>::SetValue(val); }
private:
wxDECLARE_DYNAMIC_CLASS( wxSpinCtrlDouble );
};
#endif // _WX_QT_SPINCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/region.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/region.h
// Purpose: header for wxRegion
// Author: Peter Most, Javier Torres
// Copyright: (c) Peter Most, Javier Torres
// Licence: wxWindows Licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_REGION_H_
#define _WX_QT_REGION_H_
class QRegion;
class QRect;
template<class T> class QVector;
class WXDLLIMPEXP_CORE wxRegion : public wxRegionBase
{
public:
wxRegion();
wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
wxRegion(const wxRect& rect);
wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
wxRegion(const wxBitmap& bmp);
wxRegion(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
virtual bool IsEmpty() const;
virtual void Clear();
virtual const QRegion &GetHandle() const;
virtual void QtSetRegion(QRegion region); // Hangs on to this region
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual bool DoIsEqual(const wxRegion& region) const;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const;
virtual wxRegionContain DoContainsRect(const wxRect& rect) const;
virtual bool DoOffset(wxCoord x, wxCoord y);
virtual bool DoUnionWithRect(const wxRect& rect);
virtual bool DoUnionWithRegion(const wxRegion& region);
virtual bool DoIntersect(const wxRegion& region);
virtual bool DoSubtract(const wxRegion& region);
virtual bool DoXor(const wxRegion& region);
};
class WXDLLIMPEXP_CORE wxRegionIterator: public wxObject
{
public:
wxRegionIterator();
wxRegionIterator(const wxRegion& region);
wxRegionIterator(const wxRegionIterator& ri);
~wxRegionIterator();
wxRegionIterator& operator=(const wxRegionIterator& ri);
void Reset();
void Reset(const wxRegion& region);
bool HaveRects() const;
operator bool () const;
wxRegionIterator& operator ++ ();
wxRegionIterator operator ++ (int);
wxCoord GetX() const;
wxCoord GetY() const;
wxCoord GetW() const;
wxCoord GetWidth() const;
wxCoord GetH() const;
wxCoord GetHeight() const;
wxRect GetRect() const;
private:
QVector < QRect > *m_qtRects;
int m_pos;
};
#endif // _WX_QT_REGION_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/evtloop.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/evtloop.h
// Author: Peter Most, Javier Torres, Mariano Reingart, Sean D'Epagnier
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_EVTLOOP_H_
#define _WX_QT_EVTLOOP_H_
class QTimer;
class WXDLLIMPEXP_CORE wxQtEventLoopBase : public wxEventLoopBase
{
public:
wxQtEventLoopBase();
~wxQtEventLoopBase();
virtual int DoRun();
virtual void ScheduleExit(int rc = 0);
virtual bool Pending() const;
virtual bool Dispatch();
virtual int DispatchTimeout(unsigned long timeout);
virtual void WakeUp();
virtual void DoYieldFor(long eventsToProcess);
#if wxUSE_EVENTLOOP_SOURCE
virtual wxEventLoopSource *AddSourceForFD(int fd, wxEventLoopSourceHandler *handler, int flags);
#endif // wxUSE_EVENTLOOP_SOURCE
protected:
private:
QTimer *m_qtIdleTimer;
wxDECLARE_NO_COPY_CLASS(wxQtEventLoopBase);
};
#if wxUSE_GUI
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxQtEventLoopBase
{
public:
wxGUIEventLoop();
};
#endif // wxUSE_GUI
#endif // _WX_QT_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/palette.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/palette.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_PALETTE_H_
#define _WX_QT_PALETTE_H_
class WXDLLIMPEXP_CORE wxPalette : public wxPaletteBase
{
public:
wxPalette();
wxPalette(int n, unsigned char *red, unsigned char *green, unsigned char *blue);
bool Create(int n, unsigned char *red, unsigned char *green, unsigned char *blue);
bool GetRGB(int pixel, unsigned char *red, unsigned char *green, unsigned char *blue) const;
int GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
};
#endif // _WX_QT_PALETTE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/menu.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/menu.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_MENU_H_
#define _WX_QT_MENU_H_
class QMenu;
class QMenuBar;
class WXDLLIMPEXP_CORE wxMenu : public wxMenuBase
{
public:
wxMenu(long style = 0);
wxMenu(const wxString& title, long style = 0);
virtual QMenu *GetHandle() const;
protected:
virtual wxMenuItem *DoAppend(wxMenuItem *item);
virtual wxMenuItem *DoInsert(size_t pos, wxMenuItem *item);
virtual wxMenuItem *DoRemove(wxMenuItem *item);
private:
QMenu *m_qtMenu;
wxDECLARE_DYNAMIC_CLASS(wxMenu);
};
class WXDLLIMPEXP_CORE wxMenuBar : public wxMenuBarBase
{
public:
wxMenuBar();
wxMenuBar(long style);
wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style = 0);
virtual bool Append(wxMenu *menu, const wxString& title);
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title);
virtual wxMenu *Remove(size_t pos);
virtual void EnableTop(size_t pos, bool enable);
virtual bool IsEnabledTop(size_t pos) const wxOVERRIDE;
virtual void SetMenuLabel(size_t pos, const wxString& label);
virtual wxString GetMenuLabel(size_t pos) const;
QMenuBar *GetQMenuBar() const { return m_qtMenuBar; }
virtual QWidget *GetHandle() const;
virtual void Attach(wxFrame *frame);
virtual void Detach();
private:
QMenuBar *m_qtMenuBar;
wxDECLARE_DYNAMIC_CLASS(wxMenuBar);
};
#endif // _WX_QT_MENU_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/colour.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/colour.h
// Purpose: wxColour class implementation for wxQt
// Author: Kolya Kosenko
// Created: 2010-05-12
// Copyright: (c) 2010 Kolya Kosenko
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_COLOUR_H_
#define _WX_QT_COLOUR_H_
class QColor;
class WXDLLIMPEXP_CORE wxColour : public wxColourBase
{
public:
DEFINE_STD_WXCOLOUR_CONSTRUCTORS
wxColour(const QColor& color);
virtual bool IsOk() const { return m_valid; }
ChannelType Red() const { return m_red; }
ChannelType Green() const { return m_green; }
ChannelType Blue() const { return m_blue; }
ChannelType Alpha() const { return m_alpha; }
bool operator==(const wxColour& color) const;
bool operator!=(const wxColour& color) const;
int GetPixel() const;
QColor GetQColor() const;
protected:
void Init();
virtual void InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a);
private:
ChannelType m_red, m_green, m_blue, m_alpha;
bool m_valid;
wxDECLARE_DYNAMIC_CLASS(wxColour);
};
#endif // _WX_QT_COLOUR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/checkbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/checkbox.h
// Author: Peter Most, Sean D'Epagnier, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CHECKBOX_H_
#define _WX_QT_CHECKBOX_H_
class QCheckBox;
class WXDLLIMPEXP_CORE wxCheckBox : public wxCheckBoxBase
{
public:
wxCheckBox();
wxCheckBox( wxWindow *parent, wxWindowID id, const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr );
virtual void SetValue(bool value);
virtual bool GetValue() const;
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual wxString GetLabel() const wxOVERRIDE;
virtual QWidget *GetHandle() const;
protected:
virtual void DoSet3StateValue(wxCheckBoxState state);
virtual wxCheckBoxState DoGet3StateValue() const;
private:
QCheckBox *m_qtCheckBox;
wxDECLARE_DYNAMIC_CLASS(wxCheckBox);
};
#endif // _WX_QT_CHECKBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/bmpbuttn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/bmpbuttn.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_BMPBUTTN_H_
#define _WX_QT_BMPBUTTN_H_
class WXDLLIMPEXP_CORE wxBitmapButton : public wxBitmapButtonBase
{
public:
wxBitmapButton();
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
protected:
wxDECLARE_DYNAMIC_CLASS(wxBitmapButton);
private:
// We re-use wxButton
};
#endif // _WX_QT_BMPBUTTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/mdi.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/mdi.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_MDI_H_
#define _WX_QT_MDI_H_
class WXDLLIMPEXP_CORE wxMDIParentFrame : public wxMDIParentFrameBase
{
public:
wxMDIParentFrame();
wxMDIParentFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr);
// override/implement base class [pure] virtual methods
// ----------------------------------------------------
static bool IsTDI() { return false; }
virtual void ActivateNext();
virtual void ActivatePrevious();
protected:
private:
wxDECLARE_DYNAMIC_CLASS(wxMDIParentFrame);
};
class WXDLLIMPEXP_CORE wxMDIChildFrame : public wxMDIChildFrameBase
{
public:
wxMDIChildFrame();
wxMDIChildFrame(wxMDIParentFrame *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(wxMDIParentFrame *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 Activate();
};
class WXDLLIMPEXP_CORE wxMDIClientWindow : public wxMDIClientWindowBase
{
public:
wxMDIClientWindow();
virtual bool CreateClient(wxMDIParentFrame *parent, long style = wxVSCROLL | wxHSCROLL);
};
#endif // _WX_QT_MDI_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/dataview.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dataview.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DATAVIEW_H_
#define _WX_QT_DATAVIEW_H_
class WXDLLIMPEXP_ADV wxDataViewColumn: public wxDataViewColumnBase
{
public:
wxDataViewColumn( const wxString &title, wxDataViewRenderer *renderer,
unsigned int model_column, int width = wxDVC_DEFAULT_WIDTH,
wxAlignment align = wxALIGN_CENTER,
int flags = wxDATAVIEW_COL_RESIZABLE );
wxDataViewColumn( const wxBitmap &bitmap, wxDataViewRenderer *renderer,
unsigned int model_column, int width = wxDVC_DEFAULT_WIDTH,
wxAlignment align = wxALIGN_CENTER,
int flags = wxDATAVIEW_COL_RESIZABLE );
// setters:
virtual void SetTitle( const wxString &title );
virtual void SetBitmap( const wxBitmap &bitmap );
virtual void SetOwner( wxDataViewCtrl *owner );
virtual void SetAlignment( wxAlignment align );
virtual void SetSortable( bool sortable );
virtual void SetSortOrder( bool ascending );
virtual void SetAsSortKey(bool sort = true);
virtual void SetResizeable( bool resizeable );
virtual void SetHidden( bool hidden );
virtual void SetMinWidth( int minWidth );
virtual void SetWidth( int width );
virtual void SetReorderable( bool reorderable );
virtual void SetFlags(int flags);
// getters:
virtual wxString GetTitle() const;
virtual wxAlignment GetAlignment() const;
virtual bool IsSortable() const;
virtual bool IsSortOrderAscending() const;
virtual bool IsSortKey() const;
virtual bool IsResizeable() const;
virtual bool IsHidden() const;
virtual int GetWidth() const;
virtual int GetMinWidth() const;
virtual bool IsReorderable() const;
virtual int GetFlags() const;
};
class WXDLLIMPEXP_ADV wxDataViewCtrl: public wxDataViewCtrlBase
{
public:
wxDataViewCtrl();
wxDataViewCtrl( wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator );
virtual ~wxDataViewCtrl();
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator );
virtual bool AssociateModel( wxDataViewModel *model );
virtual bool PrependColumn( wxDataViewColumn *col );
virtual bool AppendColumn( wxDataViewColumn *col );
virtual bool InsertColumn( unsigned int pos, wxDataViewColumn *col );
virtual unsigned int GetColumnCount() const;
virtual wxDataViewColumn* GetColumn( unsigned int pos ) const;
virtual bool DeleteColumn( wxDataViewColumn *column );
virtual bool ClearColumns();
virtual int GetColumnPosition( const wxDataViewColumn *column ) const;
virtual wxDataViewColumn *GetSortingColumn() const;
virtual wxDataViewItem GetSelection() const;
virtual int GetSelections( wxDataViewItemArray & sel ) const;
virtual void SetSelections( const wxDataViewItemArray & sel );
virtual void Select( const wxDataViewItem & item );
virtual void Unselect( const wxDataViewItem & item );
virtual bool IsSelected( const wxDataViewItem & item ) const;
virtual void SelectAll();
virtual void UnselectAll();
virtual void EnsureVisible( const wxDataViewItem& item,
const wxDataViewColumn *column = NULL );
virtual void HitTest( const wxPoint &point,
wxDataViewItem &item,
wxDataViewColumn *&column ) const;
virtual wxRect GetItemRect( const wxDataViewItem &item,
const wxDataViewColumn *column = NULL ) const;
virtual void Expand( const wxDataViewItem & item );
virtual void Collapse( const wxDataViewItem & item );
virtual bool IsExpanded( const wxDataViewItem & item ) const;
virtual bool EnableDragSource( const wxDataFormat &format );
virtual bool EnableDropTarget( const wxDataFormat &format );
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
wxWindow *GetMainWindow() { return (wxWindow*) this; }
virtual void OnInternalIdle();
protected:
virtual void DoSetExpanderColumn();
virtual void DoSetIndent();
private:
virtual wxDataViewItem DoGetCurrentItem() const;
virtual void DoSetCurrentItem(const wxDataViewItem& item);
};
#endif // _WX_QT_DATAVIEW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/accel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/accel.h
// Purpose: wxAcceleratorTable class
// Author: Peter Most, Javier Torres, Mariano Reingart
// Copyright: (c) 2009 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_ACCEL_H_
#define _WX_QT_ACCEL_H_
/* wxQt accelerators implementation:
*
* Storing:
* QShortcuts are stored in wxWindow (m_qtShortcuts) to allow to delete them
* when the accelerator table is changed, and also because we need to specify
* a not-null parent from them, which is unknown at the moment of creating the
* accelerator table. So, the accelerator table only contains a list of
* wxAcceleratorEntries, which are converted to a list of QShortcuts when
* the table is fixed to a wxWindow.
*
* Passing keypresses to accelerators:
* The accelerators are implemented using QShortcut's. As there is no easy way
* to call them, we must pass all keypress events through the QApplication
* notify() function (which is the one that checks if the keypress match any
* shortcut.
*
* Executing commands when a QShortcut is triggered:
* Each QShortcut has a property ("wxQt_Command") set with the number of the
* wx command it is associated to. Then, its activated() signal is connected to
* a small handler (wxQtShortcutHandler in window_qt.h) which calls the main
* handler (wxWindow::QtHandleShortcut) passing the command extracted from the
* QShortcut. This handler will finally create and send the appropriate wx
* event to the window. */
class QShortcut;
template < class T > class QList;
class WXDLLIMPEXP_CORE wxAcceleratorTable : public wxObject
{
public:
wxAcceleratorTable();
wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]);
// Implementation
QList < QShortcut* > *ConvertShortcutTable( QWidget *parent ) const;
bool Ok() const { return IsOk(); }
bool IsOk() const;
protected:
// ref counting code
virtual wxObjectRefData *CreateRefData() const;
virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
private:
wxDECLARE_DYNAMIC_CLASS(wxAcceleratorTable);
};
#endif // _WX_QT_ACCEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/dvrenderer.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dvrenderer.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DVRENDERER_H_
#define _WX_QT_DVRENDERER_H_
// ----------------------------------------------------------------------------
// wxDataViewRenderer
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewRenderer: public wxDataViewRendererBase
{
public:
wxDataViewRenderer( const wxString &varianttype,
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT );
virtual void SetMode( wxDataViewCellMode mode );
virtual wxDataViewCellMode GetMode() const;
virtual void SetAlignment( int align );
virtual int GetAlignment() const;
virtual void EnableEllipsize(wxEllipsizeMode mode = wxELLIPSIZE_MIDDLE);
virtual wxEllipsizeMode GetEllipsizeMode() const;
};
#endif // _WX_QT_DVRENDERER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/scrolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/scrolbar.h
// Author: Peter Most, Javier Torres, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_SCROLBAR_H_
#define _WX_QT_SCROLBAR_H_
#include "wx/scrolbar.h"
class QScrollBar;
class WXDLLIMPEXP_FWD_CORE wxQtScrollBar;
class WXDLLIMPEXP_CORE wxScrollBar : public wxScrollBarBase
{
public:
wxScrollBar();
wxScrollBar( wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr );
bool Create( wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr );
virtual int GetThumbPosition() const;
virtual int GetThumbSize() const;
virtual int GetPageSize() const;
virtual int GetRange() const;
virtual void SetThumbPosition(int viewStart);
virtual void SetScrollbar(int position, int thumbSize,
int range, int pageSize,
bool refresh = true);
QScrollBar *GetQScrollBar() const { return m_qtScrollBar; }
QWidget *GetHandle() const;
private:
QScrollBar *m_qtScrollBar;
wxDECLARE_DYNAMIC_CLASS(wxScrollBar);
};
#endif // _WX_QT_SCROLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/dirdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dirdlg.h
// Author: Sean D'Epagnier
// Copyright: (c) 2014 Sean D'Epagnier
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DIRDLG_H_
#define _WX_QT_DIRDLG_H_
class QFileDialog;
class WXDLLIMPEXP_CORE wxDirDialog : public wxDirDialogBase
{
public:
wxDirDialog() { }
wxDirDialog(wxWindow *parent,
const wxString& message = wxDirSelectorPromptStr,
const wxString& defaultPath = wxEmptyString,
long style = wxDD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxDirDialogNameStr);
bool Create(wxWindow *parent,
const wxString& message = wxDirSelectorPromptStr,
const wxString& defaultPath = wxEmptyString,
long style = wxDD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxDirDialogNameStr);
public: // overrides from wxGenericDirDialog
wxString GetPath() const wxOVERRIDE;
void SetPath(const wxString& path) wxOVERRIDE;
private:
virtual QFileDialog *GetQFileDialog() const;
wxDECLARE_DYNAMIC_CLASS(wxDirDialog);
};
#endif // _WX_QT_DIRDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/choice.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/choice.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CHOICE_H_
#define _WX_QT_CHOICE_H_
class QComboBox;
class WXDLLIMPEXP_CORE wxChoice : public wxChoiceBase
{
public:
wxChoice();
wxChoice( wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr );
wxChoice( wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr );
bool Create( wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr );
bool Create( wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr );
virtual wxSize DoGetBestSize() const;
virtual unsigned int GetCount() const;
virtual wxString GetString(unsigned int n) const;
virtual void SetString(unsigned int n, const wxString& s);
virtual void SetSelection(int n);
virtual int GetSelection() const;
virtual QWidget *GetHandle() const;
protected:
virtual int DoInsertItems(const wxArrayStringsAdapter & items,
unsigned int pos,
void **clientData,
wxClientDataType type);
virtual int DoInsertOneItem(const wxString& item, unsigned int pos);
virtual void DoSetItemClientData(unsigned int n, void *clientData);
virtual void *DoGetItemClientData(unsigned int n) const;
virtual void DoClear();
virtual void DoDeleteOneItem(unsigned int pos);
QComboBox *m_qtComboBox;
private:
wxDECLARE_DYNAMIC_CLASS(wxChoice);
};
#endif // _WX_QT_CHOICE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/bitmap.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/bitmap.h
// Author: Peter Most, Javier Torres, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_BITMAP_H_
#define _WX_QT_BITMAP_H_
class WXDLLIMPEXP_FWD_CORE wxPixelDataBase;
class WXDLLIMPEXP_FWD_CORE wxImage;
class WXDLLIMPEXP_FWD_CORE wxCursor;
class QImage;
class QPixmap;
class QBitmap;
class WXDLLIMPEXP_CORE wxBitmap : public wxBitmapBase
{
public:
wxBitmap();
wxBitmap(QPixmap pix);
wxBitmap(const wxBitmap& bmp);
wxBitmap(const char bits[], int width, int height, int depth = 1);
wxBitmap(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
wxBitmap(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH);
wxBitmap(const char* const* bits);
wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM);
wxBitmap(const wxImage& image, int depth = wxBITMAP_SCREEN_DEPTH, double scale = 1.0);
// Convert from wxIcon / wxCursor
wxBitmap(const wxIcon& icon) { CopyFromIcon(icon); }
explicit wxBitmap(const wxCursor& cursor);
static void InitStandardHandlers();
virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
virtual bool Create(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH);
virtual bool Create(int width, int height, const wxDC& WXUNUSED(dc));
virtual int GetHeight() const;
virtual int GetWidth() const;
virtual int GetDepth() const;
#if wxUSE_IMAGE
virtual wxImage ConvertToImage() const;
#endif // wxUSE_IMAGE
virtual wxMask *GetMask() const;
virtual void SetMask(wxMask *mask);
virtual wxBitmap GetSubBitmap(const wxRect& rect) const;
virtual bool SaveFile(const wxString &name, wxBitmapType type,
const wxPalette *palette = NULL) const;
virtual bool LoadFile(const wxString &name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
#if wxUSE_PALETTE
virtual wxPalette *GetPalette() const;
virtual void SetPalette(const wxPalette& palette);
#endif // wxUSE_PALETTE
// copies the contents and mask of the given (colour) icon to the bitmap
virtual bool CopyFromIcon(const wxIcon& icon);
// implementation:
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED(virtual void SetHeight(int height));
wxDEPRECATED(virtual void SetWidth(int width));
wxDEPRECATED(virtual void SetDepth(int depth));
#endif
void *GetRawData(wxPixelDataBase& data, int bpp);
void UngetRawData(wxPixelDataBase& data);
// these functions are internal and shouldn't be used, they risk to
// disappear in the future
bool HasAlpha() const;
QPixmap *GetHandle() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
wxDECLARE_DYNAMIC_CLASS(wxBitmap);
};
class WXDLLIMPEXP_CORE wxMask : public wxMaskBase
{
public:
wxMask();
// Copy constructor
wxMask(const wxMask &mask);
wxMask& operator=(const wxMask &mask);
// Construct a mask from a bitmap and a colour indicating the transparent
// area
wxMask(const wxBitmap& bitmap, const wxColour& colour);
// Construct a mask from a bitmap and a palette index indicating the
// transparent area
wxMask(const wxBitmap& bitmap, int paletteIndex);
// Construct a mask from a mono bitmap (copies the bitmap).
wxMask(const wxBitmap& bitmap);
virtual ~wxMask();
// Implementation
QBitmap *GetHandle() const;
protected:
// this function is called from Create() to free the existing mask data
void FreeData();
// by the public wrappers
bool InitFromColour(const wxBitmap& bitmap, const wxColour& colour);
bool InitFromMonoBitmap(const wxBitmap& bitmap);
wxBitmap GetBitmap() const;
protected:
wxDECLARE_DYNAMIC_CLASS(wxMask);
private:
QBitmap *m_qtBitmap;
};
#endif // _WX_QT_BITMAP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/printqt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/printqt.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_PRINTQT_H_
#define _WX_QT_PRINTQT_H_
#include "wx/prntbase.h"
class WXDLLIMPEXP_CORE wxQtPrinter : public wxPrinterBase
{
public:
wxQtPrinter( wxPrintDialogData *data = NULL );
virtual bool Setup(wxWindow *parent);
virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true);
virtual wxDC* PrintDialog(wxWindow *parent);
private:
};
class WXDLLIMPEXP_CORE wxQtPrintPreview : public wxPrintPreviewBase
{
public:
wxQtPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting = NULL,
wxPrintDialogData *data = NULL);
wxQtPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting,
wxPrintData *data);
virtual bool Print(bool interactive);
virtual void DetermineScaling();
protected:
};
#endif // _WX_QT_PRINTQT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/ctrlsub.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/ctrlsub.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CTRLSUB_H_
#define _WX_QT_CTRLSUB_H_
class WXDLLIMPEXP_CORE wxControlWithItems : public wxControlWithItemsBase
{
public:
wxControlWithItems();
protected:
private:
wxDECLARE_ABSTRACT_CLASS(wxControlWithItems);
};
#endif // _WX_QT_CTRLSUB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/taskbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/taskbar.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_TASKBAR_H_
#define _WX_QT_TASKBAR_H_
class QSystemTrayIcon;
class WXDLLIMPEXP_ADV wxTaskBarIcon : public wxTaskBarIconBase
{
public:
wxTaskBarIcon(wxTaskBarIconType iconType = wxTBI_DEFAULT_TYPE);
virtual ~wxTaskBarIcon();
// Accessors
bool IsOk() const { return false; }
bool IsIconInstalled() const { return false; }
// Operations
virtual bool SetIcon(const wxIcon& icon,
const wxString& tooltip = wxEmptyString);
virtual bool RemoveIcon();
virtual bool PopupMenu(wxMenu *menu);
private:
QSystemTrayIcon *m_qtSystemTrayIcon;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTaskBarIcon);
};
#endif // _WX_QT_TASKBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/minifram.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/minifram.h
// Purpose: wxMiniFrame class
// Author: Mariano Reingart
// Copyright: (c) 2014 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MINIFRAM_H_
#define _WX_MINIFRAM_H_
#include "wx/frame.h"
class WXDLLIMPEXP_CORE wxMiniFrame : public wxFrame
{
public:
wxMiniFrame() { }
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAPTION | wxCLIP_CHILDREN | wxRESIZE_BORDER,
const wxString& name = wxFrameNameStr)
{
return wxFrame::Create(parent, id, title, pos, size,
style | wxFRAME_TOOL_WINDOW | wxFRAME_NO_TASKBAR,
name);
}
wxMiniFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAPTION | wxCLIP_CHILDREN | wxRESIZE_BORDER,
const wxString& name = wxFrameNameStr)
{
Create(parent, id, title, pos, size, style, name);
}
protected:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMiniFrame);
};
#endif
// _WX_MINIFRAM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/pen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/pen.h
// Author: Peter Most, Javier Torres
// Copyright: (c) Peter Most, Javier Torres
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_PEN_H_
#define _WX_QT_PEN_H_
class QPen;
class WXDLLIMPEXP_CORE wxPen : public wxPenBase
{
public:
wxPen();
wxPen( const wxColour &colour, int width = 1, wxPenStyle style = wxPENSTYLE_SOLID );
wxDEPRECATED_MSG("use wxPENSTYLE_XXX constants")
wxPen(const wxColour& col, int width, int style);
bool operator==(const wxPen& pen) const;
bool operator!=(const wxPen& pen) const;
virtual void SetColour(const wxColour& col);
virtual void SetColour(unsigned char r, unsigned char g, unsigned char b);
virtual void SetWidth(int width);
virtual void SetStyle(wxPenStyle style);
virtual void SetStipple(const wxBitmap& stipple);
virtual void SetDashes(int nb_dashes, const wxDash *dash);
virtual void SetJoin(wxPenJoin join);
virtual void SetCap(wxPenCap cap);
virtual wxColour GetColour() const;
virtual wxBitmap *GetStipple() const;
virtual wxPenStyle GetStyle() const;
virtual wxPenJoin GetJoin() const;
virtual wxPenCap GetCap() const;
virtual int GetWidth() const;
virtual int GetDashes(wxDash **ptr) const;
wxDEPRECATED_MSG("use wxPENSTYLE_XXX constants")
void SetStyle(int style) { SetStyle((wxPenStyle)style); }
QPen GetHandle() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
};
#endif // _WX_QT_PEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/dialog.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dialog.h
// Author: Peter Most, Javier Torres, Mariano Reingart, Sean D'Epagnier
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DIALOG_H_
#define _WX_QT_DIALOG_H_
#include "wx/dialog.h"
class QDialog;
class WXDLLIMPEXP_CORE wxDialog : public wxDialogBase
{
public:
wxDialog();
wxDialog( wxWindow *parent, wxWindowID id,
const wxString &title,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString &name = wxDialogNameStr );
virtual ~wxDialog();
bool Create( wxWindow *parent, wxWindowID id,
const wxString &title,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString &name = wxDialogNameStr );
virtual int ShowModal();
virtual void EndModal(int retCode);
virtual bool IsModal() const;
QDialog *GetDialogHandle() const;
private:
wxDECLARE_DYNAMIC_CLASS( wxDialog );
};
#endif // _WX_QT_DIALOG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/dataobj2.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dataobj2.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DATAOBJ2_H_
#define _WX_QT_DATAOBJ2_H_
class WXDLLIMPEXP_CORE wxBitmapDataObject : public wxBitmapDataObjectBase
{
public:
wxBitmapDataObject();
wxBitmapDataObject(const wxBitmap& bitmap);
protected:
private:
};
class WXDLLIMPEXP_CORE wxFileDataObject : public wxFileDataObjectBase
{
public:
wxFileDataObject();
void AddFile( const wxString &filename );
};
#endif // _WX_QT_DATAOBJ2_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/cursor.h | /////////////////////////////////////////////////////////////////////////////
// Name: cursor.h
// Author: Sean D'Epagnier
// Copyright: (c) Sean D'Epagnier 2014
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CURSOR_H_
#define _WX_QT_CURSOR_H_
#include "wx/image.h"
class QCursor;
class WXDLLIMPEXP_CORE wxCursor : public wxCursorBase
{
public:
wxCursor() { }
wxCursor(wxStockCursor id) { InitFromStock(id); }
#if WXWIN_COMPATIBILITY_2_8
wxCursor(int id) { InitFromStock((wxStockCursor)id); }
#endif
#if wxUSE_IMAGE
wxCursor( const wxImage & image );
wxCursor(const wxString& name,
wxBitmapType type = wxCURSOR_DEFAULT_TYPE,
int hotSpotX = 0, int hotSpotY = 0);
#endif
virtual wxPoint GetHotSpot() const;
QCursor &GetHandle() const;
protected:
void InitFromStock( wxStockCursor cursorId );
#if wxUSE_IMAGE
void InitFromImage( const wxImage & image );
#endif
private:
void Init();
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
wxDECLARE_DYNAMIC_CLASS(wxCursor);
};
#endif // _WX_QT_CURSOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/dnd.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/dnd.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DND_H_
#define _WX_QT_DND_H_
#define wxDROP_ICON(name) wxICON(name)
class WXDLLIMPEXP_CORE wxDropTarget : public wxDropTargetBase
{
public:
wxDropTarget(wxDataObject *dataObject = NULL );
virtual bool OnDrop(wxCoord x, wxCoord y);
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
virtual bool GetData();
wxDataFormat GetMatchingPair();
protected:
private:
};
class WXDLLIMPEXP_CORE wxDropSource: public wxDropSourceBase
{
public:
wxDropSource( wxWindow *win = NULL,
const wxIcon © = wxNullIcon,
const wxIcon &move = wxNullIcon,
const wxIcon &none = wxNullIcon);
wxDropSource( wxDataObject& data,
wxWindow *win,
const wxIcon © = wxNullIcon,
const wxIcon &move = wxNullIcon,
const wxIcon &none = wxNullIcon);
virtual wxDragResult DoDragDrop(int flags = wxDrag_CopyOnly);
};
#endif // _WX_QT_DND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/popupwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/popupwin.h
// Author: Peter Most
// Copyright: (c) Peter Most
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_POPUPWIN_H_
#define _WX_QT_POPUPWIN_H_
class WXDLLIMPEXP_CORE wxPopupWindow : public wxPopupWindowBase
{
public:
wxPopupWindow();
wxPopupWindow(wxWindow *parent, int flags = wxBORDER_NONE);
protected:
private:
wxDECLARE_DYNAMIC_CLASS(wxPopupWindow);
};
#endif // _WX_QT_POPUPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/dataform.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/toolbar.h
// Author: Sean D'Epagnier
// Copyright: (c) Sean D'Epagnier 2014
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_DATAFORM_H_
#define _WX_QT_DATAFORM_H_
class QString;
class WXDLLIMPEXP_CORE wxDataFormat
{
public:
wxDataFormat();
wxDataFormat( wxDataFormatId formatId );
wxDataFormat(const wxString &id);
wxDataFormat(const QString &id);
wxDataFormat(const wxChar *id);
void SetId( const wxChar *id );
bool operator==(wxDataFormatId format) const;
bool operator!=(wxDataFormatId format) const;
bool operator==(const wxDataFormat& format) const;
bool operator!=(const wxDataFormat& format) const;
// string ids are used for custom types - this SetId() must be used for
// application-specific formats
wxString GetId() const;
void SetId( const wxString& id );
// implementation
wxDataFormatId GetType() const;
void SetType( wxDataFormatId type );
wxString m_MimeType;
};
#endif // _WX_QT_DATAFORM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/brush.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/brush.h
// Author: Peter Most, Javier Torres, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_BRUSH_H_
#define _WX_QT_BRUSH_H_
class QBrush;
class WXDLLIMPEXP_CORE wxBrush : public wxBrushBase
{
public:
wxBrush();
wxBrush(const wxColour& col, wxBrushStyle style = wxBRUSHSTYLE_SOLID);
wxDEPRECATED_MSG("use wxBRUSHSTYLE_XXX constants")
wxBrush(const wxColour& col, int style);
wxBrush(const wxBitmap& stipple);
virtual void SetColour(const wxColour& col);
virtual void SetColour(unsigned char r, unsigned char g, unsigned char b);
virtual void SetStyle(wxBrushStyle style);
virtual void SetStipple(const wxBitmap& stipple);
bool operator==(const wxBrush& brush) const;
bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
virtual wxColour GetColour() const;
virtual wxBrushStyle GetStyle() const;
virtual wxBitmap *GetStipple() const;
wxDEPRECATED_MSG("use wxBRUSHSTYLE_XXX constants")
void SetStyle(int style) { SetStyle((wxBrushStyle)style); }
QBrush GetHandle() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
};
#endif // _WX_QT_BRUSH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/clipbrd.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/toolbar.h
// Author: Sean D'Epagnier
// Copyright: (c) Sean D'Epagnier 2014
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_CLIPBRD_H_
#define _WX_QT_CLIPBRD_H_
#include "wx/weakref.h"
class QtClipBoardSignalHandler;
class WXDLLIMPEXP_CORE wxClipboard : public wxClipboardBase
{
public:
wxClipboard();
~wxClipboard();
virtual bool Open();
virtual void Close();
virtual bool IsOpened() const;
virtual bool AddData( wxDataObject *data );
virtual bool SetData( wxDataObject *data );
virtual bool GetData( wxDataObject& data );
virtual void Clear();
virtual bool IsSupported( const wxDataFormat& format );
virtual bool IsSupportedAsync(wxEvtHandler *sink);
private:
friend class QtClipBoardSignalHandler;
int Mode();
QtClipBoardSignalHandler *m_SignalHandler;
wxEvtHandlerRef m_sink;
bool m_open;
wxDECLARE_DYNAMIC_CLASS(wxClipboard);
};
#endif // _WX_QT_CLIPBRD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/qt/tglbtn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/qt/tglbtn.h
// Author: Peter Most, Mariano Reingart
// Copyright: (c) 2010 wxWidgets dev team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_QT_TGLBTN_H_
#define _WX_QT_TGLBTN_H_
#include "wx/tglbtn.h"
extern WXDLLIMPEXP_DATA_CORE(const char) wxCheckBoxNameStr[];
class WXDLLIMPEXP_CORE wxBitmapToggleButton: public wxToggleButtonBase
{
public:
wxBitmapToggleButton();
wxBitmapToggleButton(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 = wxCheckBoxNameStr);
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 = wxCheckBoxNameStr);
virtual void SetValue(bool state);
virtual bool GetValue() const;
virtual QWidget *GetHandle() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxBitmapToggleButton);
};
class WXDLLIMPEXP_CORE wxToggleButton : public wxToggleButtonBase
{
public:
wxToggleButton();
wxToggleButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
virtual void SetValue(bool state);
virtual bool GetValue() const;
virtual QWidget *GetHandle() const;
private:
};
#endif // _WX_QT_TGLBTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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/Linux/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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.