repo_name
stringclasses 10
values | file_path
stringlengths 29
222
| content
stringlengths 24
926k
| extention
stringclasses 5
values |
|---|---|---|---|
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dataform.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dataform.h
// Purpose: declaration of the wxDataFormat class
// Author: Robert Roebling
// Modified by:
// Created: 19.10.99 (extracted from motif/dataobj.h)
// Copyright: (c) 1999 Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_DATAFORM_H
#define _WX_MOTIF_DATAFORM_H
class WXDLLIMPEXP_CORE wxDataFormat
{
public:
// the clipboard formats under Xt are Atoms
typedef Atom NativeFormat;
wxDataFormat();
wxDataFormat( wxDataFormatId type );
wxDataFormat( const wxString &id );
wxDataFormat( NativeFormat format );
wxDataFormat& operator=(NativeFormat format)
{ SetId(format); return *this; }
// comparison (must have both versions)
bool operator==(NativeFormat format) const
{ return m_format == (NativeFormat)format; }
bool operator!=(NativeFormat format) const
{ return m_format != (NativeFormat)format; }
bool operator==(wxDataFormatId format) const
{ return m_type == (wxDataFormatId)format; }
bool operator!=(wxDataFormatId format) const
{ return m_type != (wxDataFormatId)format; }
// explicit and implicit conversions to NativeFormat which is one of
// standard data types (implicit conversion is useful for preserving the
// compatibility with old code)
NativeFormat GetFormatId() const { return m_format; }
operator NativeFormat() const { return m_format; }
void SetId( NativeFormat format );
// 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;
private:
wxDataFormatId m_type;
NativeFormat m_format;
void PrepareFormats();
void SetType( wxDataFormatId type );
};
#endif // _WX_MOTIF_DATAFORM_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/clipbrd.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/clipbrd.h
// Purpose: Clipboard functionality.
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CLIPBRD_H_
#define _WX_CLIPBRD_H_
#if wxUSE_CLIPBOARD
class WXDLLIMPEXP_FWD_CORE wxDataObject;
struct wxDataIdToDataObject;
#include "wx/list.h"
WX_DECLARE_LIST(wxDataObject, wxDataObjectList);
WX_DECLARE_LIST(wxDataIdToDataObject, wxDataIdToDataObjectList);
WXDLLIMPEXP_CORE bool wxOpenClipboard();
WXDLLIMPEXP_CORE bool wxClipboardOpen();
WXDLLIMPEXP_CORE bool wxCloseClipboard();
WXDLLIMPEXP_CORE bool wxEmptyClipboard();
WXDLLIMPEXP_CORE bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat);
WXDLLIMPEXP_CORE bool wxSetClipboardData(wxDataFormat dataFormat, wxObject *obj, int width = 0, int height = 0);
WXDLLIMPEXP_CORE wxObject* wxGetClipboardData(wxDataFormat dataFormat, long *len = NULL);
WXDLLIMPEXP_CORE wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat);
WXDLLIMPEXP_CORE wxDataFormat wxRegisterClipboardFormat(char *formatName);
WXDLLIMPEXP_CORE bool wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName, int maxCount);
//-----------------------------------------------------------------------------
// wxClipboard
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClipboard : public wxClipboardBase
{
public:
wxClipboard();
virtual ~wxClipboard();
// open the clipboard before SetData() and GetData()
virtual bool Open();
// close the clipboard after SetData() and GetData()
virtual void Close();
// opened?
virtual bool IsOpened() const { return m_open; }
// replaces the data on the clipboard with data
virtual bool SetData( wxDataObject *data );
// adds data to the clipboard
virtual bool AddData( wxDataObject *data );
// format available on the clipboard ?
virtual bool IsSupported( const wxDataFormat& format );
// fill data with data on the clipboard (if available)
virtual bool GetData( wxDataObject& data );
// clears wxTheClipboard and the system's clipboard if possible
virtual void Clear();
// implementation from now on
bool m_open;
wxDataObjectList m_data;
wxDataIdToDataObjectList m_idToObject;
private:
wxDECLARE_DYNAMIC_CLASS(wxClipboard);
};
#endif // wxUSE_CLIPBOARD
#endif // _WX_CLIPBRD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/tglbtn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/tglbtn.h
// Purpose: Declaration of the wxToggleButton class, which implements a
// toggle button under wxMotif.
// Author: Mattia Barbon
// Modified by:
// Created: 10.02.03
// Copyright: (c) 2003 Mattia Barbon
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOGGLEBUTTON_H_
#define _WX_TOGGLEBUTTON_H_
#include "wx/checkbox.h"
class WXDLLIMPEXP_CORE wxToggleButton : public wxCheckBox
{
public:
wxToggleButton() { Init(); }
wxToggleButton( wxWindow* parent, wxWindowID id, const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr )
{
Init();
Create( parent, id, label, pos, size, style, val, name );
}
bool Create( wxWindow* parent, wxWindowID id, const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& val = wxDefaultValidator,
const wxString &name = wxCheckBoxNameStr );
protected:
virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
private:
wxDECLARE_DYNAMIC_CLASS(wxToggleButton);
// common part of all constructors
void Init()
{
m_evtType = wxEVT_TOGGLEBUTTON;
}
};
#endif // _WX_TOGGLEBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dcscreen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dcscreen.h
// Purpose: wxScreenDCImpl class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCSCREEN_H_
#define _WX_DCSCREEN_H_
#include "wx/motif/dcclient.h"
class WXDLLIMPEXP_CORE wxScreenDCImpl : public wxWindowDCImpl
{
public:
// Create a DC representing the whole screen
wxScreenDCImpl(wxScreenDC *owner);
virtual ~wxScreenDCImpl();
// Compatibility with X's requirements for
// drawing on top of all windows
static bool StartDrawingOnTop(wxWindow* window);
static bool StartDrawingOnTop(wxRect* rect = NULL);
static bool EndDrawingOnTop();
private:
static WXWindow sm_overlayWindow;
// If we have started transparent drawing at a non-(0,0) point
// then we will have to adjust the device origin in the
// constructor.
static int sm_overlayWindowX;
static int sm_overlayWindowY;
wxDECLARE_DYNAMIC_CLASS(wxScreenDCImpl);
};
#endif // _WX_DCSCREEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/combobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/combobox.h
// Purpose: wxComboBox class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COMBOBOX_H_
#define _WX_COMBOBOX_H_
#include "wx/choice.h"
#include "wx/textentry.h"
// Combobox item
class WXDLLIMPEXP_CORE wxComboBox : public wxChoice,
public wxTextEntry
{
public:
wxComboBox() { m_inSetSelection = false; }
virtual ~wxComboBox();
inline wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
m_inSetSelection = false;
Create(parent, id, value, pos, size, n, choices,
style, validator, name);
}
inline wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
m_inSetSelection = false;
Create(parent, id, value, pos, size, choices,
style, validator, name);
}
bool Create(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);
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);
// See wxComboBoxBase discussion of IsEmpty().
bool IsListEmpty() const { return wxItemContainer::IsEmpty(); }
bool IsTextEmpty() const { return wxTextEntry::IsEmpty(); }
// resolve ambiguities among virtual functions inherited from both base
// classes
virtual void Clear();
virtual wxString GetValue() const { return wxTextEntry::GetValue(); }
virtual void SetValue(const wxString& value);
virtual wxString GetStringSelection() const
{ return wxChoice::GetStringSelection(); }
virtual void SetSelection(long from, long to)
{ wxTextEntry::SetSelection(from, to); }
virtual void GetSelection(long *from, long *to) const
{ wxTextEntry::GetSelection(from, to); }
// implementation of wxControlWithItems
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual void DoDeleteOneItem(unsigned int n);
virtual int GetSelection() const ;
virtual void SetSelection(int n);
virtual int FindString(const wxString& s, bool bCase = false) const;
virtual wxString GetString(unsigned int n) const ;
virtual void SetString(unsigned int n, const wxString& s);
// Implementation
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
WXWidget GetTopWidget() const { return m_mainWidget; }
WXWidget GetMainWidget() const { return m_mainWidget; }
//Copied from wxComboBoxBase because for wxMOTIF wxComboBox does not inherit from it.
virtual void Popup() { wxFAIL_MSG( wxT("Not implemented") ); }
virtual void Dismiss() { wxFAIL_MSG( wxT("Not implemented") ); }
protected:
virtual wxSize DoGetBestSize() const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
// implement wxTextEntry pure virtual methods
virtual wxWindow *GetEditableWindow() { return this; }
virtual WXWidget GetTextWidget() const;
private:
// only implemented for native combo box
void AdjustDropDownListSize();
// implementation detail, should really be private
public:
bool m_inSetSelection;
wxDECLARE_DYNAMIC_CLASS(wxComboBox);
};
#endif // _WX_COMBOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/window.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/window.h
// Purpose: wxWindow class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WINDOW_H_
#define _WX_WINDOW_H_
#include "wx/region.h"
// ----------------------------------------------------------------------------
// wxWindow class for Motif - see also wxWindowBase
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindow : public wxWindowBase
{
friend class WXDLLIMPEXP_FWD_CORE wxDC;
friend class WXDLLIMPEXP_FWD_CORE wxWindowDC;
public:
wxWindow() { Init(); }
wxWindow(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
virtual ~wxWindow();
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
// implement base class pure virtuals
virtual void SetLabel(const wxString& label);
virtual wxString GetLabel() const;
virtual void Raise();
virtual void Lower();
virtual bool Show( bool show = true );
virtual bool Enable( bool enable = true );
virtual void SetFocus();
virtual void WarpPointer(int x, int y);
virtual void Refresh( bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL );
virtual bool SetBackgroundColour( const wxColour &colour );
virtual bool SetForegroundColour( const wxColour &colour );
virtual bool SetCursor( const wxCursor &cursor );
virtual bool SetFont( const wxFont &font );
virtual int GetCharHeight() const;
virtual int GetCharWidth() const;
virtual void SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh = true );
virtual void SetScrollPos( int orient, int pos, bool refresh = true );
virtual int GetScrollPos( int orient ) const;
virtual int GetScrollThumb( int orient ) const;
virtual int GetScrollRange( int orient ) const;
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = NULL );
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
#endif // wxUSE_DRAG_AND_DROP
// Accept files for dragging
virtual void DragAcceptFiles(bool accept);
// Get the unique identifier of a window
virtual WXWidget GetHandle() const { return GetMainWidget(); }
// implementation from now on
// --------------------------
// accessors
// ---------
// Get main widget for this window, e.g. a text widget
virtual WXWidget GetMainWidget() const;
// Get the widget that corresponds to the label (for font setting,
// label setting etc.)
virtual WXWidget GetLabelWidget() const;
// Get the client widget for this window (something we can create other
// windows on)
virtual WXWidget GetClientWidget() const;
// Get the top widget for this window, e.g. the scrolled widget parent of a
// multi-line text widget. Top means, top in the window hierarchy that
// implements this window.
virtual WXWidget GetTopWidget() const;
// Get the underlying X window and display
WXWindow GetClientXWindow() const;
WXWindow GetXWindow() const;
WXDisplay *GetXDisplay() const;
void SetLastClick(int button, long timestamp)
{ m_lastButton = button; m_lastTS = timestamp; }
int GetLastClickedButton() const { return m_lastButton; }
long GetLastClickTime() const { return m_lastTS; }
// Gives window a chance to do something in response to a size message,
// e.g. arrange status bar, toolbar etc.
virtual bool PreResize();
// Generates a paint event
virtual void DoPaint();
// update rectangle/region manipulation
// (for wxWindowDC and Motif callbacks only)
// -----------------------------------------
// Adds a recangle to the updates list
void AddUpdateRect(int x, int y, int w, int h);
void ClearUpdateRegion() { m_updateRegion.Clear(); }
void SetUpdateRegion(const wxRegion& region) { m_updateRegion = region; }
// post-creation activities
void PostCreation();
// pre-creation activities
void PreCreation();
protected:
// Responds to colour changes: passes event on to children.
void OnSysColourChanged(wxSysColourChangedEvent& event);
// Motif-specific
void SetMainWidget(WXWidget w) { m_mainWidget = w; }
// See src/motif/window.cpp, near the top, for an explanation
// why this is necessary
void CanvasSetSizeIntr(int x, int y, int width, int height,
int sizeFlags, bool fromCtor);
void DoSetSizeIntr(int x, int y,
int width, int height,
int sizeFlags, bool fromCtor);
// for DoMoveWindowIntr flags
enum
{
wxMOVE_X = 1,
wxMOVE_Y = 2,
wxMOVE_WIDTH = 4,
wxMOVE_HEIGHT = 8
};
void DoMoveWindowIntr(int x, int y, int width, int height,
int flags);
// helper function, to remove duplicate code, used in wxScrollBar
WXWidget DoCreateScrollBar(WXWidget parent, wxOrientation orientation,
void (*callback)());
public:
WXPixmap GetBackingPixmap() const { return m_backingPixmap; }
void SetBackingPixmap(WXPixmap pixmap) { m_backingPixmap = pixmap; }
int GetPixmapWidth() const { return m_pixmapWidth; }
int GetPixmapHeight() const { return m_pixmapHeight; }
void SetPixmapWidth(int w) { m_pixmapWidth = w; }
void SetPixmapHeight(int h) { m_pixmapHeight = h; }
// Change properties
// Change to the current font (often overridden)
virtual void ChangeFont(bool keepOriginalSize = true);
// Change background and foreground colour using current background colour
// setting (Motif generates foreground based on background)
virtual void ChangeBackgroundColour();
// Change foreground colour using current foreground colour setting
virtual void ChangeForegroundColour();
protected:
// Adds the widget to the hash table and adds event handlers.
bool AttachWidget(wxWindow* parent, WXWidget mainWidget,
WXWidget formWidget, int x, int y, int width, int height);
bool DetachWidget(WXWidget widget);
// How to implement accelerators. If we find a key event, translate to
// wxWidgets wxKeyEvent form. Find a widget for the window. Now find a
// wxWindow for the widget. If there isn't one, go up the widget hierarchy
// trying to find one. Once one is found, call ProcessAccelerator for the
// window. If it returns true (processed the event), skip the X event,
// otherwise carry on up the wxWidgets window hierarchy calling
// ProcessAccelerator. If all return false, process the X event as normal.
// Eventually we can implement OnCharHook the same way, but concentrate on
// accelerators for now. ProcessAccelerator must look at the current
// accelerator table, and try to find what menu id or window (beneath it)
// has this ID. Then construct an appropriate command
// event and send it.
public:
virtual bool ProcessAccelerator(wxKeyEvent& event);
protected:
// unmanage and destroy an X widget f it's !NULL (passing NULL is ok)
void UnmanageAndDestroy(WXWidget widget);
// map or unmap an X widget (passing NULL is ok),
// returns true if widget was mapped/unmapped
bool MapOrUnmap(WXWidget widget, bool map);
// scrolling stuff
// ---------------
// create/destroy window scrollbars
void CreateScrollbar(wxOrientation orientation);
void DestroyScrollbar(wxOrientation orientation);
// get either hor or vert scrollbar widget
WXWidget GetScrollbar(wxOrientation orient) const
{ return orient == wxHORIZONTAL ? m_hScrollBar : m_vScrollBar; }
// set the scroll pos
void SetInternalScrollPos(wxOrientation orient, int pos)
{
if ( orient == wxHORIZONTAL )
m_scrollPosX = pos;
else
m_scrollPosY = pos;
}
// Motif-specific flags
// --------------------
bool m_needsRefresh:1; // repaint backing store?
// For double-click detection
long m_lastTS; // last timestamp
unsigned m_lastButton:2; // last pressed button
protected:
WXWidget m_mainWidget;
WXWidget m_hScrollBar;
WXWidget m_vScrollBar;
WXWidget m_borderWidget;
WXWidget m_scrolledWindow;
WXWidget m_drawingArea;
bool m_winCaptured:1;
WXPixmap m_backingPixmap;
int m_pixmapWidth;
int m_pixmapHeight;
int m_pixmapOffsetX;
int m_pixmapOffsetY;
// Store the last scroll pos, since in wxWin the pos isn't set
// automatically by system
int m_scrollPosX;
int m_scrollPosY;
// implement the base class pure virtuals
virtual void DoGetTextExtent(const wxString& string,
int *x, int *y,
int *descent = NULL,
int *externalLeading = NULL,
const wxFont *font = NULL) const;
virtual void DoClientToScreen( int *x, int *y ) const;
virtual void DoScreenToClient( int *x, int *y ) const;
virtual void DoGetPosition( int *x, int *y ) const;
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoGetClientSize( int *width, int *height ) const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoSetClientSize(int width, int height);
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual bool DoPopupMenu(wxMenu *menu, int x, int y);
virtual void DoCaptureMouse();
virtual void DoReleaseMouse();
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip );
#endif // wxUSE_TOOLTIPS
private:
// common part of all ctors
void Init();
wxDECLARE_DYNAMIC_CLASS(wxWindow);
wxDECLARE_NO_COPY_CLASS(wxWindow);
wxDECLARE_EVENT_TABLE();
};
// ----------------------------------------------------------------------------
// A little class to switch off `size optimization' while an instance of the
// object exists: this may be useful to temporarily disable the optimisation
// which consists to do nothing when the new size is equal to the old size -
// although quite useful usually to avoid flicker, sometimes it leads to
// undesired effects.
//
// Usage: create an instance of this class on the stack to disable the size
// optimisation, it will be reenabled as soon as the object goes out
// from scope.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNoOptimize
{
public:
wxNoOptimize() { ms_count++; }
~wxNoOptimize() { ms_count--; }
static bool CanOptimize() { return ms_count == 0; }
protected:
static int ms_count;
};
#endif // _WX_WINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dc.h
// Purpose: wxMotifDCImpl class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DC_H_
#define _WX_DC_H_
#include "wx/dc.h"
// ----------------------------------------------------------------------------
// wxMotifDCImpl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMotifDCImpl : public wxDCImpl
{
public:
wxMotifDCImpl(wxDC *owner);
virtual wxSize GetPPI() const;
protected:
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 DoSetClippingRegion(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetSizeMM(int* width, int* height) const;
public:
// implementation
wxCoord XDEV2LOG(wxCoord x) const { return DeviceToLogicalX(x); }
wxCoord XDEV2LOGREL(wxCoord x) const { return DeviceToLogicalXRel(x); }
wxCoord YDEV2LOG(wxCoord y) const { return DeviceToLogicalY(y); }
wxCoord YDEV2LOGREL(wxCoord y) const { return DeviceToLogicalYRel(y); }
wxCoord XLOG2DEV(wxCoord x) const { return LogicalToDeviceX(x); }
wxCoord XLOG2DEVREL(wxCoord x) const { return LogicalToDeviceXRel(x); }
wxCoord YLOG2DEV(wxCoord y) const { return LogicalToDeviceY(y); }
wxCoord YLOG2DEVREL(wxCoord y) const { return LogicalToDeviceYRel(y); }
// Without device translation, for backing pixmap purposes
wxCoord XLOG2DEV_2(wxCoord x) const
{
return wxRound((double)(x - m_logicalOriginX) * m_scaleX) * m_signX;
}
wxCoord YLOG2DEV_2(wxCoord y) const
{
return wxRound((double)(y - m_logicalOriginY) * m_scaleY) * m_signY;
}
wxDECLARE_DYNAMIC_CLASS(wxMotifDCImpl);
};
#endif // _WX_DC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/msgdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/msgdlg.h
// Purpose: wxMessageDialog class. Use generic version if no
// platform-specific implementation.
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSGBOXDLG_H_
#define _WX_MSGBOXDLG_H_
// ----------------------------------------------------------------------------
// Message box dialog
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMessageDialog : public wxMessageDialogBase
{
public:
wxMessageDialog(wxWindow *parent,
const wxString& message,
const wxString& caption = wxMessageBoxCaptionStr,
long style = wxOK | wxCENTRE,
const wxPoint& WXUNUSED(pos) = wxDefaultPosition)
: wxMessageDialogBase(parent, message, caption, style)
{
}
virtual int ShowModal();
// implementation only from now on
// called by the Motif callback
void SetResult(long result) { m_result = result; }
protected:
long m_result;
wxDECLARE_DYNAMIC_CLASS(wxMessageDialog);
};
#endif // _WX_MSGBOXDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/print.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/print.h
// Purpose: wxPrinter, wxPrintPreview classes
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRINT_H_
#define _WX_PRINT_H_
#include "wx/prntbase.h"
/*
* Represents the printer: manages printing a wxPrintout object
*/
class WXDLLIMPEXP_CORE wxPrinter: public wxPrinterBase
{
wxDECLARE_DYNAMIC_CLASS(wxPrinter);
public:
wxPrinter(wxPrintData *data = NULL);
virtual ~wxPrinter();
virtual bool Print(wxWindow *parent, wxPrintout *printout, bool prompt = true);
virtual bool PrintDialog(wxWindow *parent);
virtual bool Setup(wxWindow *parent);
};
/*
* wxPrintPreview
* Programmer creates an object of this class to preview a wxPrintout.
*/
class WXDLLIMPEXP_CORE wxPrintPreview: public wxPrintPreviewBase
{
wxDECLARE_CLASS(wxPrintPreview);
public:
wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting = NULL, wxPrintData *data = NULL);
virtual ~wxPrintPreview();
virtual bool Print(bool interactive);
virtual void DetermineScaling();
};
#endif
// _WX_PRINT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/frame.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/frame.h
// Purpose: wxFrame class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_FRAME_H_
#define _WX_MOTIF_FRAME_H_
class WXDLLIMPEXP_CORE wxFrame : public wxFrameBase
{
public:
wxFrame() { Init(); }
wxFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual ~wxFrame();
virtual bool Show(bool show = true);
// Set menu bar
void SetMenuBar(wxMenuBar *menu_bar);
// Set title
void SetTitle(const wxString& title);
// Set icon
virtual void SetIcons(const wxIconBundle& icons);
#if wxUSE_STATUSBAR
virtual void PositionStatusBar();
#endif // wxUSE_STATUSBAR
// Create toolbar
#if wxUSE_TOOLBAR
virtual wxToolBar* CreateToolBar(long style = -1,
wxWindowID id = wxID_ANY,
const wxString& name = wxToolBarNameStr);
virtual void SetToolBar(wxToolBar *toolbar);
virtual void PositionToolBar();
#endif // wxUSE_TOOLBAR
// Implementation only from now on
// -------------------------------
void OnSysColourChanged(wxSysColourChangedEvent& event);
void OnActivate(wxActivateEvent& event);
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
WXWidget GetMenuBarWidget() const;
WXWidget GetShellWidget() const { return m_frameShell; }
WXWidget GetWorkAreaWidget() const { return m_workArea; }
WXWidget GetClientAreaWidget() const { return m_clientArea; }
WXWidget GetTopWidget() const { return m_frameShell; }
virtual WXWidget GetMainWidget() const { return m_mainWidget; }
// The widget that can have children on it
WXWidget GetClientWidget() const;
bool GetVisibleStatus() const { return m_visibleStatus; }
void SetVisibleStatus( bool status ) { m_visibleStatus = status; }
bool PreResize();
// for generic/mdig.h
virtual void DoGetClientSize(int *width, int *height) const;
private:
// common part of all ctors
void Init();
// set a single icon for the frame
void DoSetIcon( const wxIcon& icon );
//// Motif-specific
WXWidget m_frameShell;
WXWidget m_workArea;
WXWidget m_clientArea;
bool m_visibleStatus;
bool m_iconized;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoSetClientSize(int width, int height);
private:
virtual bool XmDoCreateTLW(wxWindow* parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name);
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxFrame);
};
#endif // _WX_MOTIF_FRAME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dataobj.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dataobj.h
// Purpose: declaration of the wxDataObject class for Motif
// Author: Julian Smart
// Copyright: (c) 1998 Julian Smart
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_DATAOBJ_H_
#define _WX_MOTIF_DATAOBJ_H_
// ----------------------------------------------------------------------------
// wxDataObject is the same as wxDataObjectBase under wxMotif
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDataObject : public wxDataObjectBase
{
public:
virtual ~wxDataObject();
};
#endif //_WX_MOTIF_DATAOBJ_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/statbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/statbox.h
// Purpose: wxStaticBox class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATBOX_H_
#define _WX_STATBOX_H_
// Group box
class WXDLLIMPEXP_CORE wxStaticBox: public wxStaticBoxBase
{
wxDECLARE_DYNAMIC_CLASS(wxStaticBox);
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)
{
Create(parent, id, label, pos, size, style, name);
}
virtual ~wxStaticBox();
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 bool ProcessCommand(wxCommandEvent& WXUNUSED(event))
{
return false;
}
virtual WXWidget GetLabelWidget() const { return m_labelWidget; }
virtual void SetLabel(const wxString& label);
virtual void GetBordersForSizer(int *borderTop, int *borderOther) const;
private:
WXWidget m_labelWidget;
private:
wxDECLARE_EVENT_TABLE();
};
#endif
// _WX_STATBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/control.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/control.h
// Purpose: wxControl class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CONTROL_H_
#define _WX_CONTROL_H_
#include "wx/window.h"
#include "wx/list.h"
#include "wx/validate.h"
// General item class
class WXDLLIMPEXP_CORE wxControl: public wxControlBase
{
wxDECLARE_ABSTRACT_CLASS(wxControl);
public:
wxControl();
wxControl( wxWindow *parent,
wxWindowID id,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString &name = wxControlNameStr )
{
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr);
// simulates the event, returns true if the event was processed
virtual void Command(wxCommandEvent& WXUNUSED(event)) { }
// calls the callback and appropriate event handlers, returns true if
// event was processed
virtual bool ProcessCommand(wxCommandEvent& event);
virtual void SetLabel(const wxString& label);
virtual wxString GetLabel() const ;
bool InSetValue() const { return m_inSetValue; }
protected:
// calls wxControlBase::CreateControl, also sets foreground, background and
// font to parent's values
bool CreateControl(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name);
// native implementation using XtQueryGeometry
virtual wxSize DoGetBestSize() const;
// Motif: prevent callbacks being called while in SetValue
bool m_inSetValue;
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_CONTROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/chkconf.h | /*
* Name: wx/motif/chkconf.h
* Purpose: Motif-specific config settings checks
* Author: Vadim Zeitlin
* Modified by:
* Created: 2005-04-05 (extracted from wx/chkconf.h)
* Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#if !defined(wxUSE_GADGETS)
# define wxUSE_GADGETS 0
#endif
/* wxGraphicsContext is not implemented in wxMotif */
#if wxUSE_GRAPHICS_CONTEXT
# undef wxUSE_GRAPHICS_CONTEXT
# define wxUSE_GRAPHICS_CONTEXT 0
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/dcprint.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/dcprint.h
// Purpose: wxPrinterDC class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCPRINT_H_
#define _WX_DCPRINT_H_
#include "wx/motif/dc.h"
class WXDLLIMPEXP_CORE wxPrinterDC : public wxMotifDCImpl
{
public:
// Create a printer DC
wxPrinterDCImpl(const wxString& driver, const wxString& device,
const wxString& output,
bool interactive = true,
wxPrintOrientation orientation = wxPORTRAIT);
virtual ~wxPrinterDC();
wxRect GetPaperRect() const;
wxDECLARE_CLASS(wxPrinterDCImpl);
};
#endif // _WX_DCPRINT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/button.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/button.h
// Purpose: wxButton class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BUTTON_H_
#define _WX_BUTTON_H_
// Pushbutton
class WXDLLIMPEXP_CORE wxButton: public wxButtonBase
{
public:
wxButton() { }
wxButton(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual wxWindow *SetDefault();
virtual void Command(wxCommandEvent& event);
static wxSize GetDefaultSize();
// Implementation
virtual wxSize GetMinSize() const;
protected:
virtual wxSize DoGetBestSize() const;
private:
wxSize OldGetBestSize() const;
wxSize OldGetMinSize() const;
void SetDefaultShadowThicknessAndResize();
wxDECLARE_DYNAMIC_CLASS(wxButton);
};
#endif // _WX_BUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/textctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/textctrl.h
// Purpose: wxTextCtrl class
// Author: Julian Smart
// Modified by:
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TEXTCTRL_H_
#define _WX_TEXTCTRL_H_
// Single-line text item
class WXDLLIMPEXP_CORE wxTextCtrl : public wxTextCtrlBase
{
public:
// creation
// --------
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)
{
Create(parent, id, value, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTextCtrlNameStr);
// accessors
// ---------
virtual wxString GetValue() const;
virtual int GetLineLength(long lineNo) const;
virtual wxString GetLineText(long lineNo) const;
virtual int GetNumberOfLines() const;
// operations
// ----------
virtual void MarkDirty();
virtual void DiscardEdits();
virtual bool IsModified() const;
virtual long XYToPosition(long x, long y) const;
virtual bool PositionToXY(long pos, long *x, long *y) const;
virtual void ShowPosition(long pos);
// callbacks
// ---------
void OnDropFiles(wxDropFilesEvent& event);
void OnChar(wxKeyEvent& event);
// void OnEraseBackground(wxEraseEvent& event);
void OnCut(wxCommandEvent& event);
void OnCopy(wxCommandEvent& event);
void OnPaste(wxCommandEvent& event);
void OnUndo(wxCommandEvent& event);
void OnRedo(wxCommandEvent& event);
void OnUpdateCut(wxUpdateUIEvent& event);
void OnUpdateCopy(wxUpdateUIEvent& event);
void OnUpdatePaste(wxUpdateUIEvent& event);
void OnUpdateUndo(wxUpdateUIEvent& event);
void OnUpdateRedo(wxUpdateUIEvent& event);
virtual void Command(wxCommandEvent& event);
// implementation from here to the end
// -----------------------------------
virtual void ChangeFont(bool keepOriginalSize = true);
virtual void ChangeBackgroundColour();
virtual void ChangeForegroundColour();
void SetModified(bool mod) { m_modified = mod; }
virtual WXWidget GetTopWidget() const;
// send the CHAR and TEXT_UPDATED events
void DoSendEvents(void /* XmTextVerifyCallbackStruct */ *cbs,
long keycode);
protected:
virtual wxSize DoGetBestSize() const;
virtual void DoSetValue(const wxString& value, int flags = 0);
virtual WXWidget GetTextWidget() const { return m_mainWidget; }
public:
// Motif-specific
void* m_tempCallbackStruct;
bool m_modified;
wxString m_value; // Required for password text controls
// Did we call wxTextCtrl::OnChar? If so, generate a command event.
bool m_processedDefault;
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxTextCtrl);
};
#endif
// _WX_TEXTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/motif/private/timer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/motif/private/timer.h
// Purpose: wxTimer class
// Author: Julian Smart
// Created: 17/09/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MOTIF_PRIVATE_TIMER_H_
#define _WX_MOTIF_PRIVATE_TIMER_H_
#include "wx/private/timer.h"
class WXDLLIMPEXP_CORE wxMotifTimerImpl : public wxTimerImpl
{
public:
wxMotifTimerImpl(wxTimer* timer) : wxTimerImpl(timer) { m_id = 0; }
virtual ~wxMotifTimerImpl();
virtual bool Start(int milliseconds = -1, bool oneShot = false);
virtual void Stop();
virtual bool IsRunning() const { return m_id != 0; }
// override this to rearm the timer if necessary (i.e. if not one shot) as
// X timeouts are removed automatically when they expire
virtual void Notify();
protected:
// common part of Start() and Notify()
void DoStart();
long m_id;
};
#endif // _WX_MOTIF_PRIVATE_TIMER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/app.h
// Purpose: wxAppConsole implementation for Unix
// Author: Lukasz Michalski
// Created: 28/01/2005
// Copyright: (c) Lukasz Michalski
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
//Ensure that sigset_t is being defined
#include <signal.h>
class wxFDIODispatcher;
class wxFDIOHandler;
class wxWakeUpPipe;
// wxApp subclass implementing event processing for console applications
class WXDLLIMPEXP_BASE wxAppConsole : public wxAppConsoleBase
{
public:
wxAppConsole();
virtual ~wxAppConsole();
// override base class initialization
virtual bool Initialize(int& argc, wxChar** argv) wxOVERRIDE;
// Unix-specific: Unix signal handling
// -----------------------------------
// type of the function which can be registered as signal handler: notice
// that it isn't really a signal handler, i.e. it's not subject to the
// usual signal handlers constraints, because it is called later from
// CheckSignal() and not when the signal really occurs
typedef void (*SignalHandler)(int);
// Set signal handler for the given signal, SIG_DFL or SIG_IGN can be used
// instead of a function pointer
//
// Return true if handler was installed, false on error
bool SetSignalHandler(int signal, SignalHandler handler);
// Check if any Unix signals arrived since the last call and execute
// handlers for them
void CheckSignal();
// Register the signal wake up pipe with the given dispatcher.
//
// This is used by wxExecute(wxEXEC_NOEVENTS) implementation only.
//
// The pointer to the handler used for processing events on this descriptor
// is returned so that it can be deleted when we no longer needed it.
wxFDIOHandler* RegisterSignalWakeUpPipe(wxFDIODispatcher& dispatcher);
private:
// signal handler set up by SetSignalHandler() for all signals we handle,
// it just adds the signal to m_signalsCaught -- the real processing is
// done later, when CheckSignal() is called
static void HandleSignal(int signal);
// signals for which HandleSignal() had been called (reset from
// CheckSignal())
sigset_t m_signalsCaught;
// the signal handlers
WX_DECLARE_HASH_MAP(int, SignalHandler, wxIntegerHash, wxIntegerEqual, SignalHandlerHash);
SignalHandlerHash m_signalHandlerHash;
// pipe used for wake up signal handling: if a signal arrives while we're
// blocking for input, writing to this pipe triggers a call to our CheckSignal()
wxWakeUpPipe *m_signalWakeUpPipe;
};
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/sound.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/sound.h
// Purpose: wxSound class
// Author: Julian Smart, Vaclav Slavik
// Modified by:
// Created: 25/10/98
// Copyright: (c) Julian Smart, Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SOUND_H_
#define _WX_SOUND_H_
#include "wx/defs.h"
#if wxUSE_SOUND
#include "wx/object.h"
// ----------------------------------------------------------------------------
// wxSound: simple audio playback class
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxSoundBackend;
class WXDLLIMPEXP_FWD_CORE wxSound;
class WXDLLIMPEXP_FWD_BASE wxDynamicLibrary;
/// Sound data, as loaded from .wav file:
class WXDLLIMPEXP_CORE wxSoundData
{
public:
wxSoundData() : m_refCnt(1) {}
void IncRef();
void DecRef();
// .wav header information:
unsigned m_channels; // num of channels (mono:1, stereo:2)
unsigned m_samplingRate;
unsigned m_bitsPerSample; // if 8, then m_data contains unsigned 8bit
// samples (wxUint8), if 16 then signed 16bit
// (wxInt16)
unsigned m_samples; // length in samples:
// wave data:
size_t m_dataBytes;
wxUint8 *m_data; // m_dataBytes bytes of data
private:
~wxSoundData();
unsigned m_refCnt;
wxUint8 *m_dataWithHeader; // ditto, but prefixed with .wav header
friend class wxSound;
};
/// Simple sound class:
class WXDLLIMPEXP_CORE wxSound : public wxSoundBase
{
public:
wxSound();
wxSound(const wxString& fileName, bool isResource = false);
wxSound(size_t size, const void* data);
virtual ~wxSound();
// Create from resource or file
bool Create(const wxString& fileName, bool isResource = false);
// Create from data
bool Create(size_t size, const void* data);
bool IsOk() const { return m_data != NULL; }
// Stop playing any sound
static void Stop();
// Returns true if a sound is being played
static bool IsPlaying();
// for internal use
static void UnloadBackend();
protected:
bool DoPlay(unsigned flags) const wxOVERRIDE;
static void EnsureBackend();
void Free();
bool LoadWAV(const void* data, size_t length, bool copyData);
static wxSoundBackend *ms_backend;
#if wxUSE_LIBSDL && wxUSE_PLUGINS
// FIXME - temporary, until we have plugins architecture
static wxDynamicLibrary *ms_backendSDL;
#endif
private:
wxSoundData *m_data;
};
// ----------------------------------------------------------------------------
// wxSoundBackend:
// ----------------------------------------------------------------------------
// This is interface to sound playing implementation. There are multiple
// sound architectures in use on Unix platforms and wxWidgets can use several
// of them for playback, depending on their availability at runtime; hence
// the need for backends. This class is for use by wxWidgets and people writing
// additional backends only, it is _not_ for use by applications!
// Structure that holds playback status information
struct wxSoundPlaybackStatus
{
// playback is in progress
bool m_playing;
// main thread called wxSound::Stop()
bool m_stopRequested;
};
// Audio backend interface
class WXDLLIMPEXP_CORE wxSoundBackend
{
public:
virtual ~wxSoundBackend() {}
// Returns the name of the backend (e.g. "Open Sound System")
virtual wxString GetName() const = 0;
// Returns priority (higher priority backends are tried first)
virtual int GetPriority() const = 0;
// Checks if the backend's audio system is available and the backend can
// be used for playback
virtual bool IsAvailable() const = 0;
// Returns true if the backend is capable of playing sound asynchronously.
// If false, then wxWidgets creates a playback thread and handles async
// playback, otherwise it is left up to the backend (will usually be more
// effective).
virtual bool HasNativeAsyncPlayback() const = 0;
// Plays the sound. flags are same flags as those passed to wxSound::Play.
// The function should periodically check the value of
// status->m_stopRequested and terminate if it is set to true (it may
// be modified by another thread)
virtual bool Play(wxSoundData *data, unsigned flags,
volatile wxSoundPlaybackStatus *status) = 0;
// Stops playback (if something is played).
virtual void Stop() = 0;
// Returns true if the backend is playing anything at the moment.
// (This method is never called for backends that don't support async
// playback.)
virtual bool IsPlaying() const = 0;
};
#endif // wxUSE_SOUND
#endif // _WX_SOUND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/pipe.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/pipe.h
// Purpose: wxPipe class
// Author: Vadim Zeitlin
// Modified by:
// Created: 24.06.2003 (extracted from src/unix/utilsunx.cpp)
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PIPE_H_
#define _WX_UNIX_PIPE_H_
#include <unistd.h>
#include <fcntl.h>
#include "wx/log.h"
#include "wx/intl.h"
// ----------------------------------------------------------------------------
// wxPipe: this class encapsulates pipe() system call
// ----------------------------------------------------------------------------
class wxPipe
{
public:
// the symbolic names for the pipe ends
enum Direction
{
Read,
Write
};
enum
{
INVALID_FD = -1
};
// default ctor doesn't do anything
wxPipe() { m_fds[Read] = m_fds[Write] = INVALID_FD; }
// create the pipe, return TRUE if ok, FALSE on error
bool Create()
{
if ( pipe(m_fds) == -1 )
{
wxLogSysError(wxGetTranslation("Pipe creation failed"));
return false;
}
return true;
}
// switch the given end of the pipe to non-blocking IO
bool MakeNonBlocking(Direction which)
{
const int flags = fcntl(m_fds[which], F_GETFL, 0);
if ( flags == -1 )
return false;
return fcntl(m_fds[which], F_SETFL, flags | O_NONBLOCK) == 0;
}
// return TRUE if we were created successfully
bool IsOk() const { return m_fds[Read] != INVALID_FD; }
// return the descriptor for one of the pipe ends
int operator[](Direction which) const { return m_fds[which]; }
// detach a descriptor, meaning that the pipe dtor won't close it, and
// return it
int Detach(Direction which)
{
int fd = m_fds[which];
m_fds[which] = INVALID_FD;
return fd;
}
// close the pipe descriptors
void Close()
{
for ( size_t n = 0; n < WXSIZEOF(m_fds); n++ )
{
if ( m_fds[n] != INVALID_FD )
{
close(m_fds[n]);
m_fds[n] = INVALID_FD;
}
}
}
// dtor closes the pipe descriptors
~wxPipe() { Close(); }
private:
int m_fds[2];
};
#endif // _WX_UNIX_PIPE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/stdpaths.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/stdpaths.h
// Purpose: wxStandardPaths for Unix systems
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-10-19
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_STDPATHS_H_
#define _WX_UNIX_STDPATHS_H_
// ----------------------------------------------------------------------------
// wxStandardPaths
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStandardPaths : public wxStandardPathsBase
{
public:
// tries to determine the installation prefix automatically (Linux only right
// now) and returns /usr/local if it failed
void DetectPrefix();
// set the program installation directory which is /usr/local by default
//
// under some systems (currently only Linux) the program directory can be
// determined automatically but for portable programs you should always set
// it explicitly
void SetInstallPrefix(const wxString& prefix);
// get the program installation prefix
//
// if the prefix had been previously by SetInstallPrefix, returns that
// value, otherwise calls DetectPrefix()
wxString GetInstallPrefix() const;
// implement base class pure virtuals
virtual wxString GetExecutablePath() const wxOVERRIDE;
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
virtual wxString GetDataDir() const wxOVERRIDE;
virtual wxString GetLocalDataDir() const wxOVERRIDE;
virtual wxString GetUserDataDir() const wxOVERRIDE;
virtual wxString GetPluginsDir() const wxOVERRIDE;
virtual wxString GetLocalizedResourcesDir(const wxString& lang,
ResourceCat category) const wxOVERRIDE;
#ifndef __VMS
virtual wxString GetUserDir(Dir userDir) const wxOVERRIDE;
#endif
virtual wxString MakeConfigFileName(const wxString& basename,
ConfigFileConv conv = ConfigFileConv_Ext
) const wxOVERRIDE;
protected:
// Ctor is protected, use wxStandardPaths::Get() instead of instantiating
// objects of this class directly.
wxStandardPaths() { }
private:
wxString m_prefix;
};
#endif // _WX_UNIX_STDPATHS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/apptrait.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/apptrait.h
// Purpose: standard implementations of wxAppTraits for Unix
// Author: Vadim Zeitlin
// Modified by:
// Created: 23.06.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_APPTRAIT_H_
#define _WX_UNIX_APPTRAIT_H_
// ----------------------------------------------------------------------------
// wxGUI/ConsoleAppTraits: must derive from wxAppTraits, not wxAppTraitsBase
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxConsoleAppTraits : public wxConsoleAppTraitsBase
{
public:
#if wxUSE_CONSOLE_EVENTLOOP
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
#endif // wxUSE_CONSOLE_EVENTLOOP
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif
};
#if wxUSE_GUI
// GTK+ and Motif integrate sockets and child processes monitoring directly in
// their main loop, the other Unix ports do it at wxEventLoop level and so use
// the non-GUI traits and don't need anything here
//
// TODO: Should we use XtAddInput() for wxX11 too? Or, vice versa, if there is
// no advantage in doing this compared to the generic way currently used
// by wxX11, should we continue to use GTK/Motif-specific stuff?
#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXQT__)
#define wxHAS_GUI_FDIOMANAGER
#define wxHAS_GUI_PROCESS_CALLBACKS
#endif // ports using wxFDIOManager
#if defined(__WXMAC__)
#define wxHAS_GUI_PROCESS_CALLBACKS
#define wxHAS_GUI_SOCKET_MANAGER
#endif
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
virtual int WaitForChild(wxExecuteData& execData) wxOVERRIDE;
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif
#if wxUSE_THREADS && defined(__WXGTK20__)
virtual void MutexGuiEnter() wxOVERRIDE;
virtual void MutexGuiLeave() wxOVERRIDE;
#endif
wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const wxOVERRIDE;
#ifdef __WXGTK20__
virtual wxString GetDesktopEnvironment() const wxOVERRIDE;
#endif // __WXGTK20____
#if defined(__WXGTK20__)
virtual bool ShowAssertDialog(const wxString& msg) wxOVERRIDE;
#endif
#if wxUSE_SOCKETS
#ifdef wxHAS_GUI_SOCKET_MANAGER
virtual wxSocketManager *GetSocketManager() wxOVERRIDE;
#endif
#ifdef wxHAS_GUI_FDIOMANAGER
virtual wxFDIOManager *GetFDIOManager() wxOVERRIDE;
#endif
#endif // wxUSE_SOCKETS
#if wxUSE_EVENTLOOP_SOURCE
virtual wxEventLoopSourcesManagerBase* GetEventLoopSourcesManager() wxOVERRIDE;
#endif
};
#endif // wxUSE_GUI
#endif // _WX_UNIX_APPTRAIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/fontutil.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/fontutil.h
// Purpose: font-related helper functions for Unix/X11
// Author: Vadim Zeitlin
// Modified by:
// Created: 05.11.99
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_FONTUTIL_H_
#define _WX_UNIX_FONTUTIL_H_
#ifdef __X__
typedef WXFontStructPtr wxNativeFont;
#elif defined(__WXGTK__)
typedef GdkFont *wxNativeFont;
#else
#error "Unsupported toolkit"
#endif
// returns the handle of the nearest available font or 0
extern wxNativeFont
wxLoadQueryNearestFont(float pointSize,
wxFontFamily family,
wxFontStyle style,
int weight,
bool underlined,
const wxString &facename,
wxFontEncoding encoding,
wxString* xFontName = NULL);
// returns the font specified by the given XLFD
extern wxNativeFont wxLoadFont(const wxString& fontSpec);
#endif // _WX_UNIX_FONTUTIL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/utilsx11.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/utilsx11.h
// Purpose: Miscellaneous X11 functions
// Author: Mattia Barbon, Vaclav Slavik, Vadim Zeitlin
// Modified by:
// Created: 25.03.02
// Copyright: (c) wxWidgets team
// (c) 2010 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_UTILSX11_H_
#define _WX_UNIX_UTILSX11_H_
#include "wx/defs.h"
#include "wx/gdicmn.h"
#include <X11/Xlib.h>
// NB: Content of this header is for wxWidgets' private use! It is not
// part of public API and may be modified or even disappear in the future!
#if defined(__WXMOTIF__) || defined(__WXGTK__) || defined(__WXX11__)
#if defined(__WXGTK__)
typedef void WXDisplay;
typedef void* WXWindow;
#endif
typedef unsigned long WXKeySym;
int wxCharCodeXToWX(WXKeySym keySym);
WXKeySym wxCharCodeWXToX(int id);
#ifdef __WXX11__
int wxUnicodeCharXToWX(WXKeySym keySym);
#endif
class wxIconBundle;
void wxSetIconsX11( WXDisplay* display, WXWindow window,
const wxIconBundle& ib );
enum wxX11FullScreenMethod
{
wxX11_FS_AUTODETECT = 0,
wxX11_FS_WMSPEC,
wxX11_FS_KDE,
wxX11_FS_GENERIC
};
wxX11FullScreenMethod wxGetFullScreenMethodX11(WXDisplay* display,
WXWindow rootWindow);
void wxSetFullScreenStateX11(WXDisplay* display, WXWindow rootWindow,
WXWindow window, bool show, wxRect *origSize,
wxX11FullScreenMethod method);
// Class wrapping X11 Display: it opens it in ctor and closes it in dtor.
class wxX11Display
{
public:
wxX11Display() { m_dpy = XOpenDisplay(NULL); }
~wxX11Display() { if ( m_dpy ) XCloseDisplay(m_dpy); }
// Pseudo move ctor: steals the open display from the other object.
explicit wxX11Display(wxX11Display& display)
{
m_dpy = display.m_dpy;
display.m_dpy = NULL;
}
operator Display *() const { return m_dpy; }
// Using DefaultRootWindow() with an object of wxX11Display class doesn't
// compile because it is a macro which tries to cast wxX11Display so
// provide a convenient helper.
Window DefaultRoot() const { return DefaultRootWindow(m_dpy); }
private:
Display *m_dpy;
wxDECLARE_NO_COPY_CLASS(wxX11Display);
};
#endif // __WXMOTIF__, __WXGTK__, __WXX11__
#endif // _WX_UNIX_UTILSX11_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/evtloop.h
// Purpose: declares wxEventLoop class
// Author: Lukasz Michalski ([email protected])
// Created: 2007-05-07
// Copyright: (c) 2007 Lukasz Michalski
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_EVTLOOP_H_
#define _WX_UNIX_EVTLOOP_H_
#if wxUSE_CONSOLE_EVENTLOOP
// ----------------------------------------------------------------------------
// wxConsoleEventLoop
// ----------------------------------------------------------------------------
class wxEventLoopSource;
class wxFDIODispatcher;
class wxWakeUpPipeMT;
class WXDLLIMPEXP_BASE wxConsoleEventLoop
#ifdef __WXOSX__
: public wxCFEventLoop
#else
: public wxEventLoopManual
#endif
{
public:
// initialize the event loop, use IsOk() to check if we were successful
wxConsoleEventLoop();
virtual ~wxConsoleEventLoop();
// implement base class pure virtuals
virtual bool Pending() const wxOVERRIDE;
virtual bool Dispatch() wxOVERRIDE;
virtual int DispatchTimeout(unsigned long timeout) wxOVERRIDE;
virtual void WakeUp() wxOVERRIDE;
virtual bool IsOk() const wxOVERRIDE { return m_dispatcher != NULL; }
protected:
virtual void OnNextIteration() wxOVERRIDE;
virtual void DoYieldFor(long eventsToProcess) wxOVERRIDE;
private:
// pipe used for wake up messages: when a child thread wants to wake up
// the event loop in the main thread it writes to this pipe
wxWakeUpPipeMT *m_wakeupPipe;
// the event loop source used to monitor this pipe
wxEventLoopSource* m_wakeupSource;
// either wxSelectDispatcher or wxEpollDispatcher
wxFDIODispatcher *m_dispatcher;
wxDECLARE_NO_COPY_CLASS(wxConsoleEventLoop);
};
#endif // wxUSE_CONSOLE_EVENTLOOP
#endif // _WX_UNIX_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/glx11.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/glx11.h
// Purpose: class common for all X11-based wxGLCanvas implementations
// Author: Vadim Zeitlin
// Created: 2007-04-15
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_GLX11_H_
#define _WX_UNIX_GLX11_H_
#include <GL/glx.h>
class wxGLContextAttrs;
class wxGLAttributes;
// ----------------------------------------------------------------------------
// wxGLContext
// ----------------------------------------------------------------------------
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:
// attach context to the drawable or unset it (if NULL)
static bool MakeCurrent(GLXDrawable drawable, GLXContext context);
GLXContext m_glContext;
wxDECLARE_CLASS(wxGLContext);
};
// ----------------------------------------------------------------------------
// wxGLCanvasX11
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLCanvasX11 : public wxGLCanvasBase
{
public:
// initialization and dtor
// -----------------------
// default ctor doesn't do anything, InitVisual() must be called
wxGLCanvasX11();
// initializes GLXFBConfig and XVisualInfo corresponding to the given attributes
bool InitVisual(const wxGLAttributes& dispAttrs);
// frees XVisualInfo info
virtual ~wxGLCanvasX11();
// implement wxGLCanvasBase methods
// --------------------------------
virtual bool SwapBuffers() wxOVERRIDE;
// X11-specific methods
// --------------------
// return GLX version: 13 means 1.3 &c
static int GetGLXVersion();
// return true if multisample extension is available
static bool IsGLXMultiSampleAvailable();
// get the X11 handle of this window
virtual Window GetXWindow() const = 0;
// GLX-specific methods
// --------------------
// override some wxWindow methods
// ------------------------------
// return true only if the window is realized: OpenGL context can't be
// created until we are
virtual bool IsShownOnScreen() const wxOVERRIDE;
// implementation only from now on
// -------------------------------
// get the GLXFBConfig/XVisualInfo we use
GLXFBConfig *GetGLXFBConfig() const { return m_fbc; }
XVisualInfo *GetXVisualInfo() const { return m_vi; }
// initialize the global default GL visual, return false if matching visual
// not found
static bool InitDefaultVisualInfo(const int *attribList);
// get the default GL X11 visual (may be NULL, shouldn't be freed by caller)
static XVisualInfo *GetDefaultXVisualInfo() { return ms_glVisualInfo; }
// free the global GL visual, called by wxGLApp
static void FreeDefaultVisualInfo();
// initializes XVisualInfo (in any case) and, if supported, GLXFBConfig
//
// returns false if XVisualInfo couldn't be initialized, otherwise caller
// is responsible for freeing the pointers
static bool InitXVisualInfo(const wxGLAttributes& dispAttrs,
GLXFBConfig **pFBC, XVisualInfo **pXVisual);
private:
// this is only used if it's supported i.e. if GL >= 1.3
GLXFBConfig *m_fbc;
// used for all GL versions, obtained from GLXFBConfig for GL >= 1.3
XVisualInfo *m_vi;
// the global/default versions of the above
static GLXFBConfig *ms_glFBCInfo;
static XVisualInfo *ms_glVisualInfo;
};
// ----------------------------------------------------------------------------
// wxGLApp
// ----------------------------------------------------------------------------
// this is used in wx/glcanvas.h, prevent it from defining a generic wxGLApp
#define wxGL_APP_DEFINED
class WXDLLIMPEXP_GL wxGLApp : public wxGLAppBase
{
public:
wxGLApp() : wxGLAppBase() { }
// implement wxGLAppBase method
virtual bool InitGLVisual(const int *attribList) wxOVERRIDE
{
return wxGLCanvasX11::InitDefaultVisualInfo(attribList);
}
// This method is not currently used by the library itself, but remains for
// backwards compatibility and also because wxGTK has it we could start
// using it for the same purpose in wxX11 too some day.
virtual void* GetXVisualInfo() wxOVERRIDE
{
return wxGLCanvasX11::GetDefaultXVisualInfo();
}
// and override this wxApp method to clean up
virtual int OnExit() wxOVERRIDE
{
wxGLCanvasX11::FreeDefaultVisualInfo();
return wxGLAppBase::OnExit();
}
private:
wxDECLARE_DYNAMIC_CLASS(wxGLApp);
};
#endif // _WX_UNIX_GLX11_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/fswatcher_inotify.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/fswatcher_inotify.h
// Purpose: wxInotifyFileSystemWatcher
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FSWATCHER_UNIX_H_
#define _WX_FSWATCHER_UNIX_H_
#include "wx/defs.h"
#if wxUSE_FSWATCHER
class WXDLLIMPEXP_BASE wxInotifyFileSystemWatcher :
public wxFileSystemWatcherBase
{
public:
wxInotifyFileSystemWatcher();
wxInotifyFileSystemWatcher(const wxFileName& path,
int events = wxFSW_EVENT_ALL);
virtual ~wxInotifyFileSystemWatcher();
void OnDirDeleted(const wxString& path);
protected:
bool Init();
};
#endif
#endif /* _WX_FSWATCHER_UNIX_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/stackwalk.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/stackwalk.h
// Purpose: declaration of wxStackWalker for Unix
// Author: Vadim Zeitlin
// Modified by:
// Created: 2005-01-19
// Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_STACKWALK_H_
#define _WX_UNIX_STACKWALK_H_
// ----------------------------------------------------------------------------
// wxStackFrame
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStackFrame : public wxStackFrameBase
{
friend class wxStackWalker;
public:
// arguments are the stack depth of this frame, its address and the return
// value of backtrace_symbols() for it
//
// NB: we don't copy syminfo pointer so it should have lifetime at least as
// long as ours
wxStackFrame(size_t level = 0, void *address = NULL, const char *syminfo = NULL)
: wxStackFrameBase(level, address)
{
m_syminfo = syminfo;
}
protected:
virtual void OnGetName() wxOVERRIDE;
// optimized for the 2 step initialization done by wxStackWalker
void Set(const wxString &name, const wxString &filename, const char* syminfo,
size_t level, size_t numLine, void *address)
{
m_level = level;
m_name = name;
m_filename = filename;
m_syminfo = syminfo;
m_line = numLine;
m_address = address;
}
private:
const char *m_syminfo;
};
// ----------------------------------------------------------------------------
// wxStackWalker
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStackWalker : public wxStackWalkerBase
{
public:
// we need the full path to the program executable to be able to use
// addr2line, normally we can retrieve it from wxTheApp but if wxTheApp
// doesn't exist or doesn't have the correct value, the path may be given
// explicitly
wxStackWalker(const char *argv0 = NULL)
{
ms_exepath = wxString::FromAscii(argv0);
}
~wxStackWalker()
{
FreeStack();
}
virtual void Walk(size_t skip = 1, size_t maxDepth = wxSTACKWALKER_MAX_DEPTH) wxOVERRIDE;
#if wxUSE_ON_FATAL_EXCEPTION
virtual void WalkFromException(size_t maxDepth = wxSTACKWALKER_MAX_DEPTH) wxOVERRIDE { Walk(2, maxDepth); }
#endif // wxUSE_ON_FATAL_EXCEPTION
static const wxString& GetExePath() { return ms_exepath; }
// these two may be used to save the stack at some point (fast operation)
// and then process it later (slow operation)
void SaveStack(size_t maxDepth);
void ProcessFrames(size_t skip);
void FreeStack();
private:
int InitFrames(wxStackFrame *arr, size_t n, void **addresses, char **syminfo);
static wxString ms_exepath;
static void *ms_addresses[];
static char **ms_symbols;
static int m_depth;
};
#endif // _WX_UNIX_STACKWALK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private.h
// Purpose: miscellaneous private things for Unix wx ports
// Author: Vadim Zeitlin
// Created: 2005-09-25
// Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_H_
#define _WX_UNIX_PRIVATE_H_
// this file is currently empty as its original contents was moved to
// include/wx/private/fd.h but let's keep it for now in case we need it for
// something again in the future
#include "wx/private/fd.h"
#endif // _WX_UNIX_PRIVATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/evtloopsrc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/evtloopsrc.h
// Purpose: wxUnixEventLoopSource class
// Author: Vadim Zeitlin
// Created: 2009-10-21
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_EVTLOOPSRC_H_
#define _WX_UNIX_EVTLOOPSRC_H_
class wxFDIODispatcher;
class wxFDIOHandler;
// ----------------------------------------------------------------------------
// wxUnixEventLoopSource: wxEventLoopSource for Unix-like toolkits using fds
// ----------------------------------------------------------------------------
class wxUnixEventLoopSource : public wxEventLoopSource
{
public:
// dispatcher and fdioHandler are only used here to allow us to unregister
// from the event loop when we're destroyed
wxUnixEventLoopSource(wxFDIODispatcher *dispatcher,
wxFDIOHandler *fdioHandler,
int fd,
wxEventLoopSourceHandler *handler,
int flags)
: wxEventLoopSource(handler, flags),
m_dispatcher(dispatcher),
m_fdioHandler(fdioHandler),
m_fd(fd)
{
}
virtual ~wxUnixEventLoopSource();
private:
wxFDIODispatcher * const m_dispatcher;
wxFDIOHandler * const m_fdioHandler;
const int m_fd;
wxDECLARE_NO_COPY_CLASS(wxUnixEventLoopSource);
};
#endif // _WX_UNIX_EVTLOOPSRC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/joystick.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/joystick.h
// Purpose: wxJoystick class
// Author: Guilhem Lavaux
// Modified by:
// Created: 01/02/97
// Copyright: (c) Guilhem Lavaux
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_JOYSTICK_H_
#define _WX_UNIX_JOYSTICK_H_
#include "wx/event.h"
class WXDLLIMPEXP_FWD_CORE wxJoystickThread;
class WXDLLIMPEXP_ADV wxJoystick: public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxJoystick);
public:
/*
* Public interface
*/
wxJoystick(int joystick = wxJOYSTICK1);
virtual ~wxJoystick();
// Attributes
////////////////////////////////////////////////////////////////////////////
wxPoint GetPosition() const;
int GetPosition(unsigned axis) const;
bool GetButtonState(unsigned button) const;
int GetZPosition() const;
int GetButtonState() const;
int GetPOVPosition() const;
int GetPOVCTSPosition() const;
int GetRudderPosition() const;
int GetUPosition() const;
int GetVPosition() const;
int GetMovementThreshold() const;
void SetMovementThreshold(int threshold) ;
// Capabilities
////////////////////////////////////////////////////////////////////////////
bool IsOk() const; // Checks that the joystick is functioning
static int GetNumberJoysticks() ;
int GetManufacturerId() const ;
int GetProductId() const ;
wxString GetProductName() const ;
int GetXMin() const;
int GetYMin() const;
int GetZMin() const;
int GetXMax() const;
int GetYMax() const;
int GetZMax() const;
int GetNumberButtons() const;
int GetNumberAxes() const;
int GetMaxButtons() const;
int GetMaxAxes() const;
int GetPollingMin() const;
int GetPollingMax() const;
int GetRudderMin() const;
int GetRudderMax() const;
int GetUMin() const;
int GetUMax() const;
int GetVMin() const;
int GetVMax() const;
bool HasRudder() const;
bool HasZ() const;
bool HasU() const;
bool HasV() const;
bool HasPOV() const;
bool HasPOV4Dir() const;
bool HasPOVCTS() const;
// Operations
////////////////////////////////////////////////////////////////////////////
// pollingFreq = 0 means that movement events are sent when above the threshold.
// If pollingFreq > 0, events are received every this many milliseconds.
bool SetCapture(wxWindow* win, int pollingFreq = 0);
bool ReleaseCapture();
protected:
int m_device;
int m_joystick;
wxJoystickThread* m_thread;
};
#endif // _WX_UNIX_JOYSTICK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/apptbase.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/apptbase.h
// Purpose: declaration of wxAppTraits for Unix systems
// Author: Vadim Zeitlin
// Modified by:
// Created: 23.06.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_APPTBASE_H_
#define _WX_UNIX_APPTBASE_H_
#include "wx/evtloop.h"
#include "wx/evtloopsrc.h"
class wxExecuteData;
class wxFDIOManager;
class wxEventLoopSourcesManagerBase;
// ----------------------------------------------------------------------------
// wxAppTraits: the Unix version adds extra hooks needed by Unix code
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxAppTraits : public wxAppTraitsBase
{
public:
// wxExecute() support methods
// ---------------------------
// Wait for the process termination and return its exit code or -1 on error.
//
// Notice that this is only used when execData.flags contains wxEXEC_SYNC
// and does not contain wxEXEC_NOEVENTS, i.e. when we need to really wait
// until the child process exit and dispatch the events while doing it.
virtual int WaitForChild(wxExecuteData& execData);
#if wxUSE_SOCKETS
// return a pointer to the object which should be used to integrate
// monitoring of the file descriptors to the event loop (currently this is
// used for the sockets only but should be used for arbitrary event loop
// sources in the future)
//
// this object may be different for the console and GUI applications
//
// the pointer is not deleted by the caller as normally it points to a
// static variable
virtual wxFDIOManager *GetFDIOManager();
#endif // wxUSE_SOCKETS
#if wxUSE_CONSOLE_EVENTLOOP && wxUSE_EVENTLOOP_SOURCE
// Return a non-NULL pointer to the object responsible for managing the
// event loop sources in this kind of application.
virtual wxEventLoopSourcesManagerBase* GetEventLoopSourcesManager();
#endif // wxUSE_CONSOLE_EVENTLOOP && wxUSE_CONSOLE_EVENTLOOP
protected:
// Wait for the process termination by running the given event loop until
// this happens.
//
// This is used by the public WaitForChild() after creating the event loop
// of the appropriate kind.
int RunLoopUntilChildExit(wxExecuteData& execData, wxEventLoopBase& loop);
};
#endif // _WX_UNIX_APPTBASE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/tls.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/tls.h
// Purpose: Pthreads implementation of wxTlsValue<>
// Author: Vadim Zeitlin
// Created: 2008-08-08
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_TLS_H_
#define _WX_UNIX_TLS_H_
#include <pthread.h>
// ----------------------------------------------------------------------------
// wxTlsKey is a helper class encapsulating the TLS value index
// ----------------------------------------------------------------------------
class wxTlsKey
{
public:
// ctor allocates a new key and possibly registering a destructor function
// for it
wxTlsKey(wxTlsDestructorFunction destructor)
{
m_destructor = destructor;
if ( pthread_key_create(&m_key, destructor) != 0 )
m_key = 0;
}
// return true if the key was successfully allocated
bool IsOk() const { return m_key != 0; }
// get the key value, there is no error return
void *Get() const
{
return pthread_getspecific(m_key);
}
// change the key value, return true if ok
bool Set(void *value)
{
void *old = Get();
if ( old )
m_destructor(old);
return pthread_setspecific(m_key, value) == 0;
}
// free the key
~wxTlsKey()
{
if ( IsOk() )
pthread_key_delete(m_key);
}
private:
wxTlsDestructorFunction m_destructor;
pthread_key_t m_key;
wxDECLARE_NO_COPY_CLASS(wxTlsKey);
};
#endif // _WX_UNIX_TLS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/taskbarx11.h | /////////////////////////////////////////////////////////////////////////
// File: wx/unix/taskbarx11.h
// Purpose: Defines wxTaskBarIcon class for most common X11 desktops
// Author: Vaclav Slavik
// Modified by:
// Created: 04/04/2003
// Copyright: (c) Vaclav Slavik, 2003
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_TASKBAR_H_
#define _WX_UNIX_TASKBAR_H_
class WXDLLIMPEXP_FWD_CORE wxTaskBarIconArea;
class WXDLLIMPEXP_CORE wxTaskBarIcon: public wxTaskBarIconBase
{
public:
wxTaskBarIcon();
virtual ~wxTaskBarIcon();
// Accessors:
bool IsOk() const;
bool IsIconInstalled() const;
// Operations:
bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxEmptyString) wxOVERRIDE;
bool RemoveIcon() wxOVERRIDE;
bool PopupMenu(wxMenu *menu) wxOVERRIDE;
protected:
wxTaskBarIconArea *m_iconWnd;
private:
void OnDestroy(wxWindowDestroyEvent&);
wxDECLARE_DYNAMIC_CLASS(wxTaskBarIcon);
};
#endif // _WX_UNIX_TASKBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/chkconf.h | /*
* Name: wx/unix/chkconf.h
* Purpose: Unix-specific config settings consistency checks
* Author: Vadim Zeitlin
* Created: 2007-07-14
* Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#if wxUSE_CONSOLE_EVENTLOOP
# if !wxUSE_SELECT_DISPATCHER && !wxUSE_EPOLL_DISPATCHER
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxSelect/EpollDispatcher needed for console event loop"
# else
# undef wxUSE_SELECT_DISPATCHER
# define wxUSE_SELECT_DISPATCHER 1
# endif
# endif
#endif /* wxUSE_CONSOLE_EVENTLOOP */
#if wxUSE_FSWATCHER
# if !defined(wxHAS_INOTIFY) && !defined(wxHAS_KQUEUE)
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxFileSystemWatcher requires either inotify() or kqueue()"
# else
# undef wxUSE_FSWATCHER
# define wxUSE_FSWATCHER 0
# endif
# endif
#endif /* wxUSE_FSWATCHER */
#if wxUSE_GSTREAMER
# if !wxUSE_THREADS
# ifdef wxABORT_ON_CONFIG_ERROR
# error "GStreamer requires threads"
# else
# undef wxUSE_GSTREAMER
# define wxUSE_GSTREAMER 0
# endif
# endif
#endif /* wxUSE_GSTREAMER */
#ifndef wxUSE_XTEST
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_XTEST must be defined, please read comment near the top of this file."
# else
# define wxUSE_XTEST 0
# endif
#endif /* !defined(wxUSE_XTEST) */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/mimetype.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/mimetype.h
// Purpose: classes and functions to manage MIME types
// Author: Vadim Zeitlin
// Modified by:
// Created: 23.09.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence (part of wxExtra library)
/////////////////////////////////////////////////////////////////////////////
#ifndef _MIMETYPE_IMPL_H
#define _MIMETYPE_IMPL_H
#include "wx/mimetype.h"
#if wxUSE_MIMETYPE
class wxMimeTypeCommands;
WX_DEFINE_ARRAY_PTR(wxMimeTypeCommands *, wxMimeCommandsArray);
// this is the real wxMimeTypesManager for Unix
class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl
{
public:
// ctor and dtor
wxMimeTypesManagerImpl();
virtual ~wxMimeTypesManagerImpl();
// load all data into memory - done when it is needed for the first time
void Initialize(int mailcapStyles = wxMAILCAP_ALL,
const wxString& extraDir = wxEmptyString);
// and delete the data here
void ClearData();
// implement containing class functions
wxFileType *GetFileTypeFromExtension(const wxString& ext);
wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
size_t EnumAllFileTypes(wxArrayString& mimetypes);
void AddFallback(const wxFileTypeInfo& filetype);
// add information about the given mimetype
void AddMimeTypeInfo(const wxString& mimetype,
const wxString& extensions,
const wxString& description);
void AddMailcapInfo(const wxString& strType,
const wxString& strOpenCmd,
const wxString& strPrintCmd,
const wxString& strTest,
const wxString& strDesc);
// add a new record to the user .mailcap/.mime.types files
wxFileType *Associate(const wxFileTypeInfo& ftInfo);
// remove association
bool Unassociate(wxFileType *ft);
// accessors
// get the string containing space separated extensions for the given
// file type
wxString GetExtension(size_t index) { return m_aExtensions[index]; }
protected:
void InitIfNeeded();
wxArrayString m_aTypes, // MIME types
m_aDescriptions, // descriptions (just some text)
m_aExtensions, // space separated list of extensions
m_aIcons; // Icon filenames
// verb=command pairs for this file type
wxMimeCommandsArray m_aEntries;
// are we initialized?
bool m_initialized;
wxString GetCommand(const wxString &verb, size_t nIndex) const;
// Read XDG *.desktop file
void LoadXDGApp(const wxString& filename);
// Scan XDG directory
void LoadXDGAppsFilesFromDir(const wxString& dirname);
// Load XDG globs files
void LoadXDGGlobs(const wxString& filename);
// functions used to do associations
virtual int AddToMimeData(const wxString& strType,
const wxString& strIcon,
wxMimeTypeCommands *entry,
const wxArrayString& strExtensions,
const wxString& strDesc,
bool replaceExisting = true);
virtual bool DoAssociation(const wxString& strType,
const wxString& strIcon,
wxMimeTypeCommands *entry,
const wxArrayString& strExtensions,
const wxString& strDesc);
virtual wxString GetIconFromMimeType(const wxString& mime);
// give it access to m_aXXX variables
friend class WXDLLIMPEXP_FWD_BASE wxFileTypeImpl;
};
class WXDLLIMPEXP_BASE wxFileTypeImpl
{
public:
// initialization functions
// this is used to construct a list of mimetypes which match;
// if built with GetFileTypeFromMimetype index 0 has the exact match and
// index 1 the type / * match
// if built with GetFileTypeFromExtension, index 0 has the mimetype for
// the first extension found, index 1 for the second and so on
void Init(wxMimeTypesManagerImpl *manager, size_t index)
{ m_manager = manager; m_index.Add(index); }
// accessors
bool GetExtensions(wxArrayString& extensions);
bool GetMimeType(wxString *mimeType) const
{ *mimeType = m_manager->m_aTypes[m_index[0]]; return true; }
bool GetMimeTypes(wxArrayString& mimeTypes) const;
bool GetIcon(wxIconLocation *iconLoc) const;
bool GetDescription(wxString *desc) const
{ *desc = m_manager->m_aDescriptions[m_index[0]]; return true; }
bool GetOpenCommand(wxString *openCmd,
const wxFileType::MessageParameters& params) const
{
*openCmd = GetExpandedCommand(wxT("open"), params);
return (! openCmd -> IsEmpty() );
}
bool GetPrintCommand(wxString *printCmd,
const wxFileType::MessageParameters& params) const
{
*printCmd = GetExpandedCommand(wxT("print"), params);
return (! printCmd -> IsEmpty() );
}
// return the number of commands defined for this file type, 0 if none
size_t GetAllCommands(wxArrayString *verbs, wxArrayString *commands,
const wxFileType::MessageParameters& params) const;
// remove the record for this file type
// probably a mistake to come here, use wxMimeTypesManager.Unassociate (ft) instead
bool Unassociate(wxFileType *ft)
{
return m_manager->Unassociate(ft);
}
// set an arbitrary command, ask confirmation if it already exists and
// overwriteprompt is TRUE
bool SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt = true);
bool SetDefaultIcon(const wxString& strIcon = wxEmptyString, int index = 0);
wxString
GetExpandedCommand(const wxString & verb,
const wxFileType::MessageParameters& params) const;
private:
wxMimeTypesManagerImpl *m_manager;
wxArrayInt m_index; // in the wxMimeTypesManagerImpl arrays
};
#endif // wxUSE_MIMETYPE
#endif // _MIMETYPE_IMPL_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/fswatcher_kqueue.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/fswatcher_kqueue.h
// Purpose: wxKqueueFileSystemWatcher
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FSWATCHER_KQUEUE_H_
#define _WX_FSWATCHER_KQUEUE_H_
#include "wx/defs.h"
#if wxUSE_FSWATCHER
class WXDLLIMPEXP_BASE wxKqueueFileSystemWatcher :
public wxFileSystemWatcherBase
{
public:
wxKqueueFileSystemWatcher();
wxKqueueFileSystemWatcher(const wxFileName& path,
int events = wxFSW_EVENT_ALL);
virtual ~wxKqueueFileSystemWatcher();
protected:
bool Init();
};
#endif
#endif /* _WX_FSWATCHER_OSX_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/displayx11.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/displayx11.h
// Purpose: Helper functions used by wxX11 and wxGTK ports
// Author: Vadim Zeitlin
// Created: 2018-10-04 (extracted from src/unix/displayx11.cpp)
// Copyright: (c) 2002-2018 wxWindows team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_DISPLAYX11_H_
#define _WX_UNIX_PRIVATE_DISPLAYX11_H_
#include "wx/defs.h"
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#if wxUSE_DISPLAY
#include "wx/log.h"
#include "wx/translation.h"
#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
#include <X11/extensions/xf86vmode.h>
//
// See (http://www.xfree86.org/4.2.0/XF86VidModeDeleteModeLine.3.html) for more
// info about xf86 video mode extensions
//
//free private data common to x (usually s3) servers
#define wxClearXVM(vm) if(vm.privsize) XFree(vm.c_private)
// Correct res rate from GLFW
#define wxCRR2(v,dc) (int) (((1000.0f * (float) dc) /*PIXELS PER SECOND */) / ((float) v.htotal * v.vtotal /*PIXELS PER FRAME*/) + 0.5f)
#define wxCRR(v) wxCRR2(v,v.dotclock)
#define wxCVM2(v, dc, display, nScreen) wxVideoMode(v.hdisplay, v.vdisplay, DefaultDepth(display, nScreen), wxCRR2(v,dc))
#define wxCVM(v, display, nScreen) wxCVM2(v, v.dotclock, display, nScreen)
wxArrayVideoModes wxXF86VidMode_GetModes(const wxVideoMode& mode, Display* display, int nScreen)
{
XF86VidModeModeInfo** ppXModes; //Enumerated Modes (Don't forget XFree() :))
int nNumModes; //Number of modes enumerated....
wxArrayVideoModes Modes; //modes to return...
if (XF86VidModeGetAllModeLines(display, nScreen, &nNumModes, &ppXModes))
{
for (int i = 0; i < nNumModes; ++i)
{
XF86VidModeModeInfo& info = *ppXModes[i];
const wxVideoMode vm = wxCVM(info, display, nScreen);
if (vm.Matches(mode))
{
Modes.Add(vm);
}
wxClearXVM(info);
// XFree(ppXModes[i]); //supposed to free?
}
XFree(ppXModes);
}
else //OOPS!
{
wxLogSysError(_("Failed to enumerate video modes"));
}
return Modes;
}
wxVideoMode wxXF86VidMode_GetCurrentMode(Display* display, int nScreen)
{
XF86VidModeModeLine VM;
int nDotClock;
if ( !XF86VidModeGetModeLine(display, nScreen, &nDotClock, &VM) )
return wxVideoMode();
wxClearXVM(VM);
return wxCVM2(VM, nDotClock, display, nScreen);
}
bool wxXF86VidMode_ChangeMode(const wxVideoMode& mode, Display* display, int nScreen)
{
XF86VidModeModeInfo** ppXModes; //Enumerated Modes (Don't forget XFree() :))
int nNumModes; //Number of modes enumerated....
if(!XF86VidModeGetAllModeLines(display, nScreen, &nNumModes, &ppXModes))
{
wxLogSysError(_("Failed to change video mode"));
return false;
}
bool bRet = false;
if (mode == wxDefaultVideoMode)
{
bRet = XF86VidModeSwitchToMode(display, nScreen, ppXModes[0]) != 0;
for (int i = 0; i < nNumModes; ++i)
{
wxClearXVM((*ppXModes[i]));
// XFree(ppXModes[i]); //supposed to free?
}
}
else
{
for (int i = 0; i < nNumModes; ++i)
{
if (!bRet &&
ppXModes[i]->hdisplay == mode.GetWidth() &&
ppXModes[i]->vdisplay == mode.GetHeight() &&
wxCRR((*ppXModes[i])) == mode.GetRefresh())
{
//switch!
bRet = XF86VidModeSwitchToMode(display, nScreen, ppXModes[i]) != 0;
}
wxClearXVM((*ppXModes[i]));
// XFree(ppXModes[i]); //supposed to free?
}
}
XFree(ppXModes);
return bRet;
}
#else // !HAVE_X11_EXTENSIONS_XF86VMODE_H
wxArrayVideoModes wxX11_GetModes(const wxDisplayImpl* impl, const wxVideoMode& modeMatch, Display* display)
{
int count_return;
int* depths = XListDepths(display, 0, &count_return);
wxArrayVideoModes modes;
if ( depths )
{
const wxRect rect = impl->GetGeometry();
for ( int x = 0; x < count_return; ++x )
{
wxVideoMode mode(rect.width, rect.height, depths[x]);
if ( mode.Matches(modeMatch) )
{
modes.Add(mode);
}
}
XFree(depths);
}
return modes;
}
#endif // !HAVE_X11_EXTENSIONS_XF86VMODE_H
#endif // wxUSE_DISPLAY
void wxGetWorkAreaX11(Screen* screen, int& x, int& y, int& width, int& height)
{
Display* display = DisplayOfScreen(screen);
Atom property = XInternAtom(display, "_NET_WORKAREA", true);
if (property)
{
Atom actual_type;
int actual_format;
unsigned long nitems;
unsigned long bytes_after;
unsigned char* data = NULL;
Status status = XGetWindowProperty(
display, RootWindowOfScreen(screen), property,
0, 4, false, XA_CARDINAL,
&actual_type, &actual_format, &nitems, &bytes_after, &data);
if (status == Success && actual_type == XA_CARDINAL &&
actual_format == 32 && nitems == 4)
{
const long* p = (long*)data;
x = p[0];
y = p[1];
width = p[2];
height = p[3];
}
if (data)
XFree(data);
}
}
#endif // _WX_UNIX_PRIVATE_DISPLAYX11_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/wakeuppipe.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/wakeuppipe.h
// Purpose: Helper class allowing to wake up the main thread.
// Author: Vadim Zeitlin
// Created: 2013-06-09 (extracted from src/unix/evtloopunix.cpp)
// Copyright: (c) 2013 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_WAKEUPPIPE_H_
#define _WX_UNIX_PRIVATE_WAKEUPPIPE_H_
#include "wx/unix/pipe.h"
#include "wx/evtloopsrc.h"
// ----------------------------------------------------------------------------
// wxWakeUpPipe: allows to wake up the event loop by writing to it
// ----------------------------------------------------------------------------
// This class is not MT-safe, see wxWakeUpPipeMT below for a wake up pipe
// usable from other threads.
class wxWakeUpPipe : public wxEventLoopSourceHandler
{
public:
// Create and initialize the pipe.
//
// It's the callers responsibility to add the read end of this pipe,
// returned by GetReadFd(), to the code blocking on input.
wxWakeUpPipe();
// Wake up the blocking operation involving this pipe.
//
// It simply writes to the write end of the pipe.
//
// As indicated by its name, this method does no locking and so can be
// called only from the main thread.
void WakeUpNoLock();
// Same as WakeUp() but without locking.
// Return the read end of the pipe.
int GetReadFd() { return m_pipe[wxPipe::Read]; }
// Implement wxEventLoopSourceHandler pure virtual methods
virtual void OnReadWaiting() wxOVERRIDE;
virtual void OnWriteWaiting() wxOVERRIDE { }
virtual void OnExceptionWaiting() wxOVERRIDE { }
private:
wxPipe m_pipe;
// This flag is set to true after writing to the pipe and reset to false
// after reading from it in the main thread. Having it allows us to avoid
// overflowing the pipe with too many writes if the main thread can't keep
// up with reading from it.
bool m_pipeIsEmpty;
};
// ----------------------------------------------------------------------------
// wxWakeUpPipeMT: thread-safe version of wxWakeUpPipe
// ----------------------------------------------------------------------------
// This class can be used from multiple threads, i.e. its WakeUp() can be
// called concurrently.
class wxWakeUpPipeMT : public wxWakeUpPipe
{
#if wxUSE_THREADS
public:
wxWakeUpPipeMT() { }
// Thread-safe wrapper around WakeUpNoLock(): can be called from another
// thread to wake up the main one.
void WakeUp()
{
wxCriticalSectionLocker lock(m_pipeLock);
WakeUpNoLock();
}
virtual void OnReadWaiting() wxOVERRIDE
{
wxCriticalSectionLocker lock(m_pipeLock);
wxWakeUpPipe::OnReadWaiting();
}
private:
// Protects access to m_pipeIsEmpty.
wxCriticalSection m_pipeLock;
#endif // wxUSE_THREADS
};
#endif // _WX_UNIX_PRIVATE_WAKEUPPIPE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/epolldispatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/epolldispatcher.h
// Purpose: wxEpollDispatcher class
// Authors: Lukasz Michalski
// Created: April 2007
// Copyright: (c) Lukasz Michalski
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_EPOLLDISPATCHER_H_
#define _WX_PRIVATE_EPOLLDISPATCHER_H_
#include "wx/defs.h"
#ifdef wxUSE_EPOLL_DISPATCHER
#include "wx/private/fdiodispatcher.h"
struct epoll_event;
class WXDLLIMPEXP_BASE wxEpollDispatcher : public wxFDIODispatcher
{
public:
// create a new instance of this class, can return NULL if
// epoll() is not supported on this system
//
// the caller should delete the returned pointer
static wxEpollDispatcher *Create();
virtual ~wxEpollDispatcher();
// implement base class pure virtual methods
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:
// ctor is private, use Create()
wxEpollDispatcher(int epollDescriptor);
// common part of HasPending() and Dispatch(): calls epoll_wait() with the
// given timeout
int DoPoll(epoll_event *events, int numEvents, int timeout) const;
int m_epollDescriptor;
};
#endif // wxUSE_EPOLL_DISPATCHER
#endif // _WX_PRIVATE_SOCKETEVTDISPATCH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/executeiohandler.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/executeiohandler.h
// Purpose: IO handler class for the FD used by wxExecute() under Unix
// Author: Rob Bresalier, Vadim Zeitlin
// Created: 2013-01-06
// Copyright: (c) 2013 Rob Bresalier, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_EXECUTEIOHANDLER_H_
#define _WX_UNIX_PRIVATE_EXECUTEIOHANDLER_H_
#include "wx/private/streamtempinput.h"
// This class handles IO events on the pipe FD connected to the child process
// stdout/stderr and is used by wxExecute().
//
// Currently it can derive from either wxEventLoopSourceHandler or
// wxFDIOHandler depending on the kind of dispatcher/event loop it is used
// with. In the future, when we get rid of wxFDIOHandler entirely, it will
// derive from wxEventLoopSourceHandler only.
template <class T>
class wxExecuteIOHandlerBase : public T
{
public:
wxExecuteIOHandlerBase(int fd, wxStreamTempInputBuffer& buf)
: m_fd(fd),
m_buf(buf)
{
m_callbackDisabled = false;
}
// Called when the associated descriptor is available for reading.
virtual void OnReadWaiting() wxOVERRIDE
{
// Sync process, process all data coming at us from the pipe so that
// the pipe does not get full and cause a deadlock situation.
m_buf.Update();
if ( m_buf.Eof() )
DisableCallback();
}
// These methods are never called as we only monitor the associated FD for
// reading, but we still must implement them as they're pure virtual in the
// base class.
virtual void OnWriteWaiting() wxOVERRIDE { }
virtual void OnExceptionWaiting() wxOVERRIDE { }
// Disable any future calls to our OnReadWaiting(), can be called when
// we're sure that no more input is forthcoming.
void DisableCallback()
{
if ( !m_callbackDisabled )
{
m_callbackDisabled = true;
DoDisable();
}
}
protected:
const int m_fd;
private:
virtual void DoDisable() = 0;
wxStreamTempInputBuffer& m_buf;
// If true, DisableCallback() had been already called.
bool m_callbackDisabled;
wxDECLARE_NO_COPY_CLASS(wxExecuteIOHandlerBase);
};
// This is the version used with wxFDIODispatcher, which must be passed to the
// ctor in order to register this handler with it.
class wxExecuteFDIOHandler : public wxExecuteIOHandlerBase<wxFDIOHandler>
{
public:
wxExecuteFDIOHandler(wxFDIODispatcher& dispatcher,
int fd,
wxStreamTempInputBuffer& buf)
: wxExecuteIOHandlerBase<wxFDIOHandler>(fd, buf),
m_dispatcher(dispatcher)
{
dispatcher.RegisterFD(fd, this, wxFDIO_INPUT);
}
virtual ~wxExecuteFDIOHandler()
{
DisableCallback();
}
private:
virtual void DoDisable() wxOVERRIDE
{
m_dispatcher.UnregisterFD(m_fd);
}
wxFDIODispatcher& m_dispatcher;
wxDECLARE_NO_COPY_CLASS(wxExecuteFDIOHandler);
};
// And this is the version used with an event loop. As AddSourceForFD() is
// static, we don't require passing the event loop to the ctor but an event
// loop must be running to handle our events.
class wxExecuteEventLoopSourceHandler
: public wxExecuteIOHandlerBase<wxEventLoopSourceHandler>
{
public:
wxExecuteEventLoopSourceHandler(int fd, wxStreamTempInputBuffer& buf)
: wxExecuteIOHandlerBase<wxEventLoopSourceHandler>(fd, buf)
{
m_source = wxEventLoop::AddSourceForFD(fd, this, wxEVENT_SOURCE_INPUT);
}
virtual ~wxExecuteEventLoopSourceHandler()
{
DisableCallback();
}
private:
virtual void DoDisable() wxOVERRIDE
{
delete m_source;
m_source = NULL;
}
wxEventLoopSource* m_source;
wxDECLARE_NO_COPY_CLASS(wxExecuteEventLoopSourceHandler);
};
#endif // _WX_UNIX_PRIVATE_EXECUTEIOHANDLER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/fswatcher_inotify.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/fswatcher_inotify.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_UNIX_PRIVATE_FSWATCHER_INOTIFY_H_
#define WX_UNIX_PRIVATE_FSWATCHER_INOTIFY_H_
#include "wx/filename.h"
#include "wx/evtloopsrc.h"
// ============================================================================
// wxFSWatcherEntry implementation & helper declarations
// ============================================================================
class wxFSWatcherImplUNIX;
class wxFSWatchEntry : public wxFSWatchInfo
{
public:
wxFSWatchEntry(const wxFSWatchInfo& winfo) :
wxFSWatchInfo(winfo)
{
}
int GetWatchDescriptor() const
{
return m_wd;
}
void SetWatchDescriptor(int wd)
{
m_wd = wd;
}
private:
int m_wd;
wxDECLARE_NO_COPY_CLASS(wxFSWatchEntry);
};
// ============================================================================
// wxFSWSourceHandler helper class
// ============================================================================
class wxFSWatcherImplUnix;
/**
* Handler for handling i/o from inotify descriptor
*/
class wxFSWSourceHandler : public wxEventLoopSourceHandler
{
public:
wxFSWSourceHandler(wxFSWatcherImplUnix* service) :
m_service(service)
{ }
virtual void OnReadWaiting() wxOVERRIDE;
virtual void OnWriteWaiting() wxOVERRIDE;
virtual void OnExceptionWaiting() wxOVERRIDE;
protected:
wxFSWatcherImplUnix* m_service;
};
#endif /* WX_UNIX_PRIVATE_FSWATCHER_INOTIFY_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/timer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/timer.h
// Purpose: wxTimer for wxBase (unix)
// Author: Lukasz Michalski
// Created: 15/01/2005
// Copyright: (c) Lukasz Michalski
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_TIMER_H_
#define _WX_UNIX_PRIVATE_TIMER_H_
#if wxUSE_TIMER
#include "wx/private/timer.h"
// the type used for milliseconds is large enough for microseconds too but
// introduce a synonym for it to avoid confusion
typedef wxMilliClock_t wxUsecClock_t;
// ----------------------------------------------------------------------------
// wxTimer implementation class for Unix platforms
// ----------------------------------------------------------------------------
// NB: we have to export at least this symbol from the shared library, because
// it's used by wxDFB's wxCore
class WXDLLIMPEXP_BASE wxUnixTimerImpl : public wxTimerImpl
{
public:
wxUnixTimerImpl(wxTimer *timer);
virtual ~wxUnixTimerImpl();
virtual bool IsRunning() const wxOVERRIDE;
virtual bool Start(int milliseconds = -1, bool oneShot = false) wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
// for wxTimerScheduler only: resets the internal flag indicating that the
// timer is running
void MarkStopped()
{
wxASSERT_MSG( m_isRunning, wxT("stopping non-running timer?") );
m_isRunning = false;
}
private:
bool m_isRunning;
};
// ----------------------------------------------------------------------------
// wxTimerSchedule: information about a single timer, used by wxTimerScheduler
// ----------------------------------------------------------------------------
struct wxTimerSchedule
{
wxTimerSchedule(wxUnixTimerImpl *timer, wxUsecClock_t expiration)
: m_timer(timer),
m_expiration(expiration)
{
}
// the timer itself (we don't own this pointer)
wxUnixTimerImpl *m_timer;
// the time of its next expiration, in usec
wxUsecClock_t m_expiration;
};
// the linked list of all active timers, we keep it sorted by expiration time
WX_DECLARE_LIST(wxTimerSchedule, wxTimerList);
// ----------------------------------------------------------------------------
// wxTimerScheduler: class responsible for updating all timers
// ----------------------------------------------------------------------------
class wxTimerScheduler
{
public:
// get the unique timer scheduler instance
static wxTimerScheduler& Get()
{
if ( !ms_instance )
ms_instance = new wxTimerScheduler;
return *ms_instance;
}
// must be called on shutdown to delete the global timer scheduler
static void Shutdown()
{
if ( ms_instance )
{
delete ms_instance;
ms_instance = NULL;
}
}
// adds timer which should expire at the given absolute time to the list
void AddTimer(wxUnixTimerImpl *timer, wxUsecClock_t expiration);
// remove timer from the list, called automatically from timer dtor
void RemoveTimer(wxUnixTimerImpl *timer);
// the functions below are used by the event loop implementation to monitor
// and notify timers:
// if this function returns true, the time remaining until the next time
// expiration is returned in the provided parameter (always positive or 0)
//
// it returns false if there are no timers
bool GetNext(wxUsecClock_t *remaining) const;
// trigger the timer event for all timers which have expired, return true
// if any did
bool NotifyExpired();
private:
// ctor and dtor are private, this is a singleton class only created by
// Get() and destroyed by Shutdown()
wxTimerScheduler() { }
~wxTimerScheduler();
// add the given timer schedule to the list in the right place
//
// we take ownership of the pointer "s" which must be heap-allocated
void DoAddTimer(wxTimerSchedule *s);
// the list of all currently active timers sorted by expiration
wxTimerList m_timers;
static wxTimerScheduler *ms_instance;
};
#endif // wxUSE_TIMER
#endif // _WX_UNIX_PRIVATE_TIMER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/execute.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/execute.h
// Purpose: private details of wxExecute() implementation
// Author: Vadim Zeitlin
// Copyright: (c) 1998 Robert Roebling, Julian Smart, Vadim Zeitlin
// (c) 2013 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_EXECUTE_H
#define _WX_UNIX_EXECUTE_H
#include "wx/app.h"
#include "wx/hashmap.h"
#include "wx/process.h"
#if wxUSE_STREAMS
#include "wx/unix/pipe.h"
#include "wx/private/streamtempinput.h"
#endif
class wxEventLoopBase;
// Information associated with a running child process.
class wxExecuteData
{
public:
wxExecuteData()
{
flags =
pid = 0;
exitcode = -1;
process = NULL;
syncEventLoop = NULL;
#if wxUSE_STREAMS
fdOut =
fdErr = wxPipe::INVALID_FD;
#endif // wxUSE_STREAMS
}
// This must be called in the parent process as soon as fork() returns to
// update us with the effective child PID. It also ensures that we handle
// SIGCHLD to be able to detect when this PID exits, so wxTheApp must be
// available.
void OnStart(int pid);
// Called when the child process exits.
void OnExit(int exitcode);
// Return true if we should (or already did) redirect the child IO.
bool IsRedirected() const { return process && process->IsRedirected(); }
// wxExecute() flags
int flags;
// the pid of the child process
int pid;
// The exit code of the process, set once the child terminates.
int exitcode;
// the associated process object or NULL
wxProcess *process;
// Local event loop used to wait for the child process termination in
// synchronous execution case. We can't create it ourselves as its exact
// type depends on the application kind (console/GUI), so we rely on
// wxAppTraits setting up this pointer to point to the appropriate object.
wxEventLoopBase *syncEventLoop;
#if wxUSE_STREAMS
// the input buffer bufOut is connected to stdout, this is why it is
// called bufOut and not bufIn
wxStreamTempInputBuffer bufOut,
bufErr;
// the corresponding FDs, -1 if not redirected
int fdOut,
fdErr;
#endif // wxUSE_STREAMS
private:
// SIGCHLD signal handler that checks whether any of the currently running
// children have exited.
static void OnSomeChildExited(int sig);
// All currently running child processes indexed by their PID.
//
// Notice that the container doesn't own its elements.
WX_DECLARE_HASH_MAP(int, wxExecuteData*, wxIntegerHash, wxIntegerEqual,
ChildProcessesData);
static ChildProcessesData ms_childProcesses;
wxDECLARE_NO_COPY_CLASS(wxExecuteData);
};
#endif // _WX_UNIX_EXECUTE_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/pipestream.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/pipestream.h
// Purpose: Unix wxPipeInputStream and wxPipeOutputStream declarations
// Author: Vadim Zeitlin
// Created: 2013-06-08 (extracted from wx/unix/pipe.h)
// Copyright: (c) 2013 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_PIPESTREAM_H_
#define _WX_UNIX_PRIVATE_PIPESTREAM_H_
#include "wx/wfstream.h"
class wxPipeInputStream : public wxFileInputStream
{
public:
explicit wxPipeInputStream(int fd) : wxFileInputStream(fd) { }
// return true if the pipe is still opened
bool IsOpened() const { return !Eof(); }
// return true if we have anything to read, don't block
virtual bool CanRead() const wxOVERRIDE;
};
class wxPipeOutputStream : public wxFileOutputStream
{
public:
wxPipeOutputStream(int fd) : wxFileOutputStream(fd) { }
// Override the base class version to ignore "pipe full" errors: this is
// not an error for this class.
size_t OnSysWrite(const void *buffer, size_t size) wxOVERRIDE;
};
#endif // _WX_UNIX_PRIVATE_PIPESTREAM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/sockunix.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/sockunix.h
// Purpose: wxSocketImpl implementation for Unix systems
// Authors: Guilhem Lavaux, Vadim Zeitlin
// Created: April 1997
// Copyright: (c) 1997 Guilhem Lavaux
// (c) 2008 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_GSOCKUNX_H_
#define _WX_UNIX_GSOCKUNX_H_
#include <unistd.h>
#include <sys/ioctl.h>
// Under older (Open)Solaris versions FIONBIO is declared in this header only.
// In the newer versions it's included by sys/ioctl.h but it's simpler to just
// include it always instead of testing for whether it is or not.
#ifdef __SOLARIS__
#include <sys/filio.h>
#endif
#include "wx/private/fdiomanager.h"
class wxSocketImplUnix : public wxSocketImpl,
public wxFDIOHandler
{
public:
wxSocketImplUnix(wxSocketBase& wxsocket)
: wxSocketImpl(wxsocket)
{
m_fds[0] =
m_fds[1] = -1;
}
virtual wxSocketError GetLastError() const wxOVERRIDE;
virtual void ReenableEvents(wxSocketEventFlags flags) wxOVERRIDE
{
// enable the notifications about input/output being available again in
// case they were disabled by OnRead/WriteWaiting()
//
// notice that we'd like to enable the events here only if there is
// nothing more left on the socket right now as otherwise we're going
// to get a "ready for whatever" notification immediately (well, during
// the next event loop iteration) and disable the event back again
// which is rather inefficient but unfortunately doing it like this
// doesn't work because the existing code (e.g. src/common/sckipc.cpp)
// expects to keep getting notifications about the data available from
// the socket even if it didn't read all the data the last time, so we
// absolutely have to continue generating them
EnableEvents(flags);
}
// wxFDIOHandler methods
virtual void OnReadWaiting() wxOVERRIDE;
virtual void OnWriteWaiting() wxOVERRIDE;
virtual void OnExceptionWaiting() wxOVERRIDE;
virtual bool IsOk() const wxOVERRIDE { return m_fd != INVALID_SOCKET; }
private:
virtual void DoClose() wxOVERRIDE
{
DisableEvents();
close(m_fd);
}
virtual void UnblockAndRegisterWithEventLoop() wxOVERRIDE
{
int trueArg = 1;
ioctl(m_fd, FIONBIO, &trueArg);
EnableEvents();
}
// enable or disable notifications for socket input/output events
void EnableEvents(int flags = wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG)
{ DoEnableEvents(flags, true); }
void DisableEvents(int flags = wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG)
{ DoEnableEvents(flags, false); }
// really enable or disable socket input/output events
void DoEnableEvents(int flags, bool enable);
protected:
// descriptors for input and output event notification channels associated
// with the socket
int m_fds[2];
private:
// notify the associated wxSocket about a change in socket state and shut
// down the socket if the event is wxSOCKET_LOST
void OnStateChange(wxSocketNotify event);
// check if there is any input available, return 1 if yes, 0 if no or -1 on
// error
int CheckForInput();
// give it access to our m_fds
friend class wxSocketFDBasedManager;
};
// A version of wxSocketManager which uses FDs for socket IO: it is used by
// Unix console applications and some X11-like ports (wxGTK and wxMotif but not
// wxX11 currently) which implement their own port-specific wxFDIOManagers
class wxSocketFDBasedManager : public wxSocketManager
{
public:
wxSocketFDBasedManager()
{
m_fdioManager = NULL;
}
virtual bool OnInit() wxOVERRIDE;
virtual void OnExit() wxOVERRIDE { }
virtual wxSocketImpl *CreateSocket(wxSocketBase& wxsocket) wxOVERRIDE
{
return new wxSocketImplUnix(wxsocket);
}
virtual void Install_Callback(wxSocketImpl *socket_, wxSocketNotify event) wxOVERRIDE;
virtual void Uninstall_Callback(wxSocketImpl *socket_, wxSocketNotify event) wxOVERRIDE;
protected:
// get the FD index corresponding to the given wxSocketNotify
wxFDIOManager::Direction
GetDirForEvent(wxSocketImpl *socket, wxSocketNotify event);
// access the FDs we store
int& FD(wxSocketImplUnix *socket, wxFDIOManager::Direction d)
{
return socket->m_fds[d];
}
wxFDIOManager *m_fdioManager;
wxDECLARE_NO_COPY_CLASS(wxSocketFDBasedManager);
};
#endif /* _WX_UNIX_GSOCKUNX_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/fdiounix.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/fdiounix.h
// Purpose: wxFDIOManagerUnix class used by console Unix applications
// Author: Vadim Zeitlin
// Created: 2009-08-17
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _UNIX_PRIVATE_FDIOUNIX_H_
#define _UNIX_PRIVATE_FDIOUNIX_H_
#include "wx/private/fdiomanager.h"
// ----------------------------------------------------------------------------
// wxFDIOManagerUnix: implement wxFDIOManager interface using wxFDIODispatcher
// ----------------------------------------------------------------------------
class wxFDIOManagerUnix : public wxFDIOManager
{
public:
virtual int AddInput(wxFDIOHandler *handler, int fd, Direction d) wxOVERRIDE;
virtual void RemoveInput(wxFDIOHandler *handler, int fd, Direction d) wxOVERRIDE;
};
#endif // _UNIX_PRIVATE_FDIOUNIX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/unix/private/fswatcher_kqueue.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/fswatcher_kqueue.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_UNIX_PRIVATE_FSWATCHER_KQUEUE_H_
#define WX_UNIX_PRIVATE_FSWATCHER_KQUEUE_H_
#include <fcntl.h>
#include <unistd.h>
#include "wx/dir.h"
#include "wx/debug.h"
#include "wx/arrstr.h"
// ============================================================================
// wxFSWatcherEntry implementation & helper declarations
// ============================================================================
class wxFSWatcherImplKqueue;
class wxFSWatchEntryKq : public wxFSWatchInfo
{
public:
struct wxDirState
{
wxDirState(const wxFSWatchInfo& winfo)
{
if (!wxDir::Exists(winfo.GetPath()))
return;
wxDir dir(winfo.GetPath());
wxCHECK_RET( dir.IsOpened(),
wxString::Format("Unable to open dir '%s'", winfo.GetPath()));
wxString filename;
bool ret = dir.GetFirst(&filename);
while (ret)
{
files.push_back(filename);
ret = dir.GetNext(&filename);
}
}
wxSortedArrayString files;
};
wxFSWatchEntryKq(const wxFSWatchInfo& winfo) :
wxFSWatchInfo(winfo), m_lastState(winfo)
{
m_fd = wxOpen(m_path, O_RDONLY, 0);
if (m_fd == -1)
{
wxLogSysError(_("Unable to open path '%s'"), m_path);
}
}
virtual ~wxFSWatchEntryKq()
{
(void) Close();
}
bool Close()
{
if (!IsOk())
return false;
int ret = close(m_fd);
if (ret == -1)
{
wxLogSysError(_("Unable to close path '%s'"), m_path);
}
m_fd = -1;
return ret != -1;
}
bool IsOk() const
{
return m_fd != -1;
}
int GetFileDescriptor() const
{
return m_fd;
}
void RefreshState()
{
m_lastState = wxDirState(*this);
}
const wxDirState& GetLastState() const
{
return m_lastState;
}
private:
int m_fd;
wxDirState m_lastState;
wxDECLARE_NO_COPY_CLASS(wxFSWatchEntryKq);
};
#endif /* WX_UNIX_PRIVATE_FSWATCHER_KQUEUE_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/regconf.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/regconf.h
// Purpose: Registry based implementation of wxConfigBase
// Author: Vadim Zeitlin
// Modified by:
// Created: 27.04.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_REGCONF_H_
#define _WX_MSW_REGCONF_H_
#include "wx/defs.h"
#if wxUSE_CONFIG && wxUSE_REGKEY
#include "wx/msw/registry.h"
#include "wx/object.h"
#include "wx/confbase.h"
#include "wx/buffer.h"
// ----------------------------------------------------------------------------
// wxRegConfig
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxRegConfig : public wxConfigBase
{
public:
// ctor & dtor
// will store data in HKLM\appName and HKCU\appName
wxRegConfig(const wxString& appName = wxEmptyString,
const wxString& vendorName = wxEmptyString,
const wxString& localFilename = wxEmptyString,
const wxString& globalFilename = wxEmptyString,
long style = wxCONFIG_USE_GLOBAL_FILE);
// dtor will save unsaved data
virtual ~wxRegConfig(){}
// implement inherited pure virtual functions
// ------------------------------------------
// path management
virtual void SetPath(const wxString& strPath) wxOVERRIDE;
virtual const wxString& GetPath() const wxOVERRIDE { return m_strPath; }
// entry/subgroup info
// enumerate all of them
virtual bool GetFirstGroup(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextGroup (wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetFirstEntry(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextEntry (wxString& str, long& lIndex) const wxOVERRIDE;
// tests for existence
virtual bool HasGroup(const wxString& strName) const wxOVERRIDE;
virtual bool HasEntry(const wxString& strName) const wxOVERRIDE;
virtual EntryType GetEntryType(const wxString& name) const wxOVERRIDE;
// get number of entries/subgroups in the current group, with or without
// it's subgroups
virtual size_t GetNumberOfEntries(bool bRecursive = false) const wxOVERRIDE;
virtual size_t GetNumberOfGroups(bool bRecursive = false) const wxOVERRIDE;
virtual bool Flush(bool WXUNUSED(bCurrentOnly) = false) wxOVERRIDE { return true; }
// rename
virtual bool RenameEntry(const wxString& oldName, const wxString& newName) wxOVERRIDE;
virtual bool RenameGroup(const wxString& oldName, const wxString& newName) wxOVERRIDE;
// delete
virtual bool DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso = true) wxOVERRIDE;
virtual bool DeleteGroup(const wxString& key) wxOVERRIDE;
virtual bool DeleteAll() wxOVERRIDE;
protected:
// opens the local key creating it if necessary and returns it
wxRegKey& LocalKey() const // must be const to be callable from const funcs
{
wxRegConfig* self = wxConstCast(this, wxRegConfig);
if ( !m_keyLocal.IsOpened() )
{
// create on demand
self->m_keyLocal.Create();
}
return self->m_keyLocal;
}
// implement read/write methods
virtual bool DoReadString(const wxString& key, wxString *pStr) const wxOVERRIDE;
virtual bool DoReadLong(const wxString& key, long *plResult) const wxOVERRIDE;
#if wxUSE_BASE64
virtual bool DoReadBinary(const wxString& key, wxMemoryBuffer* buf) const wxOVERRIDE;
#endif // wxUSE_BASE64
virtual bool DoWriteString(const wxString& key, const wxString& szValue) wxOVERRIDE;
virtual bool DoWriteLong(const wxString& key, long lValue) wxOVERRIDE;
#if wxUSE_BASE64
virtual bool DoWriteBinary(const wxString& key, const wxMemoryBuffer& buf) wxOVERRIDE;
#endif // wxUSE_BASE64
private:
// these keys are opened during all lifetime of wxRegConfig object
wxRegKey m_keyLocalRoot, m_keyLocal,
m_keyGlobalRoot, m_keyGlobal;
// current path (not '/' terminated)
wxString m_strPath;
wxDECLARE_NO_COPY_CLASS(wxRegConfig);
wxDECLARE_ABSTRACT_CLASS(wxRegConfig);
};
#endif // wxUSE_CONFIG && wxUSE_REGKEY
#endif // _WX_MSW_REGCONF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/metafile.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/metafile.h
// Purpose: wxMetaFile, wxMetaFileDC and wxMetaFileDataObject classes
// Author: Julian Smart
// Modified by: VZ 07.01.00: implemented wxMetaFileDataObject
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_METAFIILE_H_
#define _WX_METAFIILE_H_
#include "wx/dc.h"
#include "wx/gdiobj.h"
#if wxUSE_DATAOBJ
#include "wx/dataobj.h"
#endif
// ----------------------------------------------------------------------------
// Metafile and metafile device context classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxMetafile;
class WXDLLIMPEXP_CORE wxMetafileRefData: public wxGDIRefData
{
public:
wxMetafileRefData();
virtual ~wxMetafileRefData();
virtual bool IsOk() const wxOVERRIDE { return m_metafile != 0; }
public:
WXHANDLE m_metafile;
int m_windowsMappingMode;
int m_width, m_height;
friend class WXDLLIMPEXP_FWD_CORE wxMetafile;
};
#define M_METAFILEDATA ((wxMetafileRefData *)m_refData)
class WXDLLIMPEXP_CORE wxMetafile: public wxGDIObject
{
public:
wxMetafile(const wxString& file = wxEmptyString);
virtual ~wxMetafile();
// After this is called, the metafile cannot be used for anything
// since it is now owned by the clipboard.
virtual bool SetClipboard(int width = 0, int height = 0);
virtual bool Play(wxDC *dc);
// set/get the size of metafile for clipboard operations
wxSize GetSize() const { return wxSize(GetWidth(), GetHeight()); }
int GetWidth() const { return M_METAFILEDATA->m_width; }
int GetHeight() const { return M_METAFILEDATA->m_height; }
void SetWidth(int width) { M_METAFILEDATA->m_width = width; }
void SetHeight(int height) { M_METAFILEDATA->m_height = height; }
// Implementation
WXHANDLE GetHMETAFILE() const { return M_METAFILEDATA->m_metafile; }
void SetHMETAFILE(WXHANDLE mf) ;
int GetWindowsMappingMode() const { return M_METAFILEDATA->m_windowsMappingMode; }
void SetWindowsMappingMode(int mm);
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxMetafile);
};
class WXDLLIMPEXP_CORE wxMetafileDCImpl: public wxMSWDCImpl
{
public:
wxMetafileDCImpl(wxDC *owner, const wxString& file = wxEmptyString);
wxMetafileDCImpl(wxDC *owner, const wxString& file,
int xext, int yext, int xorg, int yorg);
virtual ~wxMetafileDCImpl();
virtual wxMetafile *Close();
virtual void SetMapMode(wxMappingMode mode) wxOVERRIDE;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *x, wxCoord *y,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
const wxFont *theFont = NULL) const wxOVERRIDE;
// Implementation
wxMetafile *GetMetaFile() const { return m_metaFile; }
void SetMetaFile(wxMetafile *mf) { m_metaFile = mf; }
int GetWindowsMappingMode() const { return m_windowsMappingMode; }
void SetWindowsMappingMode(int mm) { m_windowsMappingMode = mm; }
protected:
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
int m_windowsMappingMode;
wxMetafile* m_metaFile;
private:
wxDECLARE_CLASS(wxMetafileDCImpl);
wxDECLARE_NO_COPY_CLASS(wxMetafileDCImpl);
};
class WXDLLIMPEXP_CORE wxMetafileDC: public wxDC
{
public:
// Don't supply origin and extent
// Supply them to wxMakeMetaFilePlaceable instead.
wxMetafileDC(const wxString& file)
: wxDC(new wxMetafileDCImpl( this, file ))
{ }
// Supply origin and extent (recommended).
// Then don't need to supply them to wxMakeMetaFilePlaceable.
wxMetafileDC(const wxString& file, int xext, int yext, int xorg, int yorg)
: wxDC(new wxMetafileDCImpl( this, file, xext, yext, xorg, yorg ))
{ }
wxMetafile *GetMetafile() const
{ return ((wxMetafileDCImpl*)m_pimpl)->GetMetaFile(); }
wxMetafile *Close()
{ return ((wxMetafileDCImpl*)m_pimpl)->Close(); }
private:
wxDECLARE_CLASS(wxMetafileDC);
wxDECLARE_NO_COPY_CLASS(wxMetafileDC);
};
/*
* Pass filename of existing non-placeable metafile, and bounding box.
* Adds a placeable metafile header, sets the mapping mode to anisotropic,
* and sets the window origin and extent to mimic the wxMM_TEXT mapping mode.
*
*/
// No origin or extent
bool WXDLLIMPEXP_CORE wxMakeMetafilePlaceable(const wxString& filename, float scale = 1.0);
// Optional origin and extent
bool WXDLLIMPEXP_CORE wxMakeMetaFilePlaceable(const wxString& filename, int x1, int y1, int x2, int y2, float scale = 1.0, bool useOriginAndExtent = true);
// ----------------------------------------------------------------------------
// wxMetafileDataObject is a specialization of wxDataObject for metafile data
// ----------------------------------------------------------------------------
#if wxUSE_DATAOBJ
class WXDLLIMPEXP_CORE wxMetafileDataObject : public wxDataObjectSimple
{
public:
// ctors
wxMetafileDataObject() : wxDataObjectSimple(wxDF_METAFILE)
{ }
wxMetafileDataObject(const wxMetafile& metafile)
: wxDataObjectSimple(wxDF_METAFILE), m_metafile(metafile) { }
// virtual functions which you may override if you want to provide data on
// demand only - otherwise, the trivial default versions will be used
virtual void SetMetafile(const wxMetafile& metafile)
{ m_metafile = metafile; }
virtual wxMetafile GetMetafile() const
{ return m_metafile; }
// implement base class pure virtuals
virtual size_t GetDataSize() const wxOVERRIDE;
virtual bool GetDataHere(void *buf) const wxOVERRIDE;
virtual bool SetData(size_t len, const void *buf) wxOVERRIDE;
protected:
wxMetafile m_metafile;
};
#endif // wxUSE_DATAOBJ
#endif
// _WX_METAFIILE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/webviewhistoryitem_ie.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/webviewhistoryitem.h
// Purpose: wxWebViewHistoryItem header for MSW
// Author: Steven Lamerton
// Copyright: (c) 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WEBVIEWHISTORYITEM_H_
#define _WX_MSW_WEBVIEWHISTORYITEM_H_
#include "wx/setup.h"
#if wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE && defined(__WXMSW__)
class WXDLLIMPEXP_WEBVIEW wxWebViewHistoryItem
{
public:
wxWebViewHistoryItem(const wxString& url, const wxString& title) :
m_url(url), m_title(title) {}
wxString GetUrl() { return m_url; }
wxString GetTitle() { return m_title; }
private:
wxString m_url, m_title;
};
#endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE && defined(__WXMSW__)
#endif // _WX_MSW_WEBVIEWHISTORYITEM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/helpwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpwin.h
// Purpose: Help system: WinHelp implementation
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPWIN_H_
#define _WX_HELPWIN_H_
#include "wx/wx.h"
#if wxUSE_HELP
#include "wx/helpbase.h"
class WXDLLIMPEXP_CORE wxWinHelpController: public wxHelpControllerBase
{
wxDECLARE_DYNAMIC_CLASS(wxWinHelpController);
public:
wxWinHelpController(wxWindow* parentWindow = NULL): wxHelpControllerBase(parentWindow) {}
virtual ~wxWinHelpController() {}
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE;
virtual bool DisplayContents() wxOVERRIDE;
virtual bool DisplaySection(int sectionNo) wxOVERRIDE;
virtual bool DisplaySection(const wxString& section) wxOVERRIDE { return KeywordSearch(section); }
virtual bool DisplayBlock(long blockNo) wxOVERRIDE;
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE;
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE;
virtual bool Quit() wxOVERRIDE;
inline wxString GetHelpFile() const { return m_helpFile; }
protected:
// Append extension if necessary.
wxString GetValidFilename(const wxString& file) const;
private:
wxString m_helpFile;
};
#endif // wxUSE_HELP
#endif
// _WX_HELPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/dcclient.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dcclient.h
// Purpose: wxClientDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCCLIENT_H_
#define _WX_DCCLIENT_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/dc.h"
#include "wx/msw/dc.h"
#include "wx/dcclient.h"
class wxPaintDCInfo;
// ----------------------------------------------------------------------------
// DC classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDCImpl : public wxMSWDCImpl
{
public:
// default ctor
wxWindowDCImpl( wxDC *owner );
// Create a DC corresponding to the whole window
wxWindowDCImpl( wxDC *owner, wxWindow *win );
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
protected:
// initialize the newly created DC
void InitDC();
wxDECLARE_CLASS(wxWindowDCImpl);
wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
{
public:
// default ctor
wxClientDCImpl( wxDC *owner );
// Create a DC corresponding to the client area of the window
wxClientDCImpl( wxDC *owner, wxWindow *win );
virtual ~wxClientDCImpl();
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
protected:
void InitDC();
wxDECLARE_CLASS(wxClientDCImpl);
wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
{
public:
wxPaintDCImpl( wxDC *owner );
// Create a DC corresponding for painting the window in OnPaint()
wxPaintDCImpl( wxDC *owner, wxWindow *win );
virtual ~wxPaintDCImpl();
// find the entry for this DC in the cache (keyed by the window)
static WXHDC FindDCInCache(wxWindow* win);
// This must be called by the code handling WM_PAINT to remove the DC
// cached for this window for the duration of this message processing.
static void EndPaint(wxWindow *win);
protected:
// Find the DC for this window in the cache, return NULL if not found.
static wxPaintDCInfo *FindInCache(wxWindow* win);
wxDECLARE_CLASS(wxPaintDCImpl);
wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
/*
* wxPaintDCEx
* This class is used when an application sends an HDC with the WM_PAINT
* message. It is used in HandlePaint and need not be used by an application.
*/
class WXDLLIMPEXP_CORE wxPaintDCEx : public wxPaintDC
{
public:
wxPaintDCEx(wxWindow *canvas, WXHDC dc);
wxDECLARE_CLASS(wxPaintDCEx);
wxDECLARE_NO_COPY_CLASS(wxPaintDCEx);
};
#endif
// _WX_DCCLIENT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/setup.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/setup.h
// Purpose: Configuration for the library
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
/* --- start common options --- */
// ----------------------------------------------------------------------------
// global settings
// ----------------------------------------------------------------------------
// define this to 0 when building wxBase library - this can also be done from
// makefile/project file overriding the value here
#ifndef wxUSE_GUI
#define wxUSE_GUI 1
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// compatibility settings
// ----------------------------------------------------------------------------
// This setting determines the compatibility with 2.8 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_2_8 0
// This setting determines the compatibility with 3.0 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_3_0 1
// MSW-only: Set to 0 for accurate dialog units, else 1 for old behaviour when
// default system font is used for wxWindow::GetCharWidth/Height() instead of
// the current font.
//
// Default is 0
//
// Recommended setting: 0
#define wxDIALOG_UNIT_COMPATIBILITY 0
// Provide unsafe implicit conversions in wxString to "const char*" or
// "std::string" (depending on wxUSE_STD_STRING_CONV_IN_WXSTRING value).
//
// Default is 1 but only for compatibility reasons, it is recommended to set
// this to 0 because converting wxString to a narrow (non-Unicode) string may
// fail unless a locale using UTF-8 encoding is used, which is never the case
// under MSW, for example, hence such conversions can result in silent data
// loss.
//
// Recommended setting: 0
#define wxUSE_UNSAFE_WXSTRING_CONV 1
// If set to 1, enables "reproducible builds", i.e. build output should be
// exactly the same if the same build is redone again. As using __DATE__ and
// __TIME__ macros clearly makes the build irreproducible, setting this option
// to 1 disables their use in the library code.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_REPRODUCIBLE_BUILD 0
// ----------------------------------------------------------------------------
// debugging settings
// ----------------------------------------------------------------------------
// wxDEBUG_LEVEL will be defined as 1 in wx/debug.h so normally there is no
// need to define it here. You may do it for two reasons: either completely
// disable/compile out the asserts in release version (then do it inside #ifdef
// NDEBUG) or, on the contrary, enable more asserts, including the usually
// disabled ones, in the debug build (then do it inside #ifndef NDEBUG)
//
// #ifdef NDEBUG
// #define wxDEBUG_LEVEL 0
// #else
// #define wxDEBUG_LEVEL 2
// #endif
// wxHandleFatalExceptions() may be used to catch the program faults at run
// time and, instead of terminating the program with a usual GPF message box,
// call the user-defined wxApp::OnFatalException() function. If you set
// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
//
// This setting is for Win32 only and can only be enabled if your compiler
// supports Win32 structured exception handling (currently only VC++ does)
//
// Default is 1
//
// Recommended setting: 1 if your compiler supports it.
#define wxUSE_ON_FATAL_EXCEPTION 1
// Set this to 1 to be able to generate a human-readable (unlike
// machine-readable minidump created by wxCrashReport::Generate()) stack back
// trace when your program crashes using wxStackWalker
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_STACKWALKER 1
// Set this to 1 to compile in wxDebugReport class which allows you to create
// and optionally upload to your web site a debug report consisting of back
// trace of the crash (if wxUSE_STACKWALKER == 1) and other information.
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, it is compiled into a separate library so there
// is no overhead if you don't use it
#define wxUSE_DEBUGREPORT 1
// Generic comment about debugging settings: they are very useful if you don't
// use any other memory leak detection tools such as Purify/BoundsChecker, but
// are probably redundant otherwise. Also, Visual C++ CRT has the same features
// as wxWidgets memory debugging subsystem built in since version 5.0 and you
// may prefer to use it instead of built in memory debugging code because it is
// faster and more fool proof.
//
// Using VC++ CRT memory debugging is enabled by default in debug build (_DEBUG
// is defined) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
// and if __NO_VC_CRTDBG__ is not defined.
// The rest of the options in this section are obsolete and not supported,
// enable them at your own risk.
// If 1, enables wxDebugContext, for writing error messages to file, etc. If
// __WXDEBUG__ is not defined, will still use the normal memory operators.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_CONTEXT 0
// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
// __WXDEBUG__ is also defined.
//
// WARNING: this code may not work with all architectures, especially if
// alignment is an issue. This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 1 if you are not using a memory debugging tool, else 0
#define wxUSE_MEMORY_TRACING 0
// In debug mode, cause new and delete to be redefined globally.
// If this causes problems (e.g. link errors which is a common problem
// especially if you use another library which also redefines the global new
// and delete), set this to 0.
// This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
// this causes problems (e.g. link errors), set this to 0. You may need to set
// this to 0 if using templates (at least for VC++). This switch is currently
// ignored for MinGW/Cygwin.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_NEW_ALWAYS 0
// ----------------------------------------------------------------------------
// Unicode support
// ----------------------------------------------------------------------------
// These settings are obsolete: the library is always built in Unicode mode
// now, only set wxUSE_UNICODE to 0 to compile legacy code in ANSI mode if
// absolutely necessary -- updating it is strongly recommended as the ANSI mode
// will disappear completely in future wxWidgets releases.
#ifndef wxUSE_UNICODE
#define wxUSE_UNICODE 1
#endif
// wxUSE_WCHAR_T is required by wxWidgets now, don't change.
#define wxUSE_WCHAR_T 1
// ----------------------------------------------------------------------------
// global features
// ----------------------------------------------------------------------------
// Compile library in exception-safe mode? If set to 1, the library will try to
// behave correctly in presence of exceptions (even though it still will not
// use the exceptions itself) and notify the user code about any unhandled
// exceptions. If set to 0, propagation of the exceptions through the library
// code will lead to undefined behaviour -- but the code itself will be
// slightly smaller and faster.
//
// Note that like wxUSE_THREADS this option is automatically set to 0 if
// wxNO_EXCEPTIONS is defined.
//
// Default is 1
//
// Recommended setting: depends on whether you intend to use C++ exceptions
// in your own code (1 if you do, 0 if you don't)
#define wxUSE_EXCEPTIONS 1
// Set wxUSE_EXTENDED_RTTI to 1 to use extended RTTI
//
// Default is 0
//
// Recommended setting: 0 (this is still work in progress...)
#define wxUSE_EXTENDED_RTTI 0
// Support for message/error logging. This includes wxLogXXX() functions and
// wxLog and derived classes. Don't set this to 0 unless you really know what
// you are doing.
//
// Default is 1
//
// Recommended setting: 1 (always)
#define wxUSE_LOG 1
// Recommended setting: 1
#define wxUSE_LOGWINDOW 1
// Recommended setting: 1
#define wxUSE_LOGGUI 1
// Recommended setting: 1
#define wxUSE_LOG_DIALOG 1
// Support for command line parsing using wxCmdLineParser class.
//
// Default is 1
//
// Recommended setting: 1 (can be set to 0 if you don't use the cmd line)
#define wxUSE_CMDLINE_PARSER 1
// Support for multithreaded applications: if 1, compile in thread classes
// (thread.h) and make the library a bit more thread safe. Although thread
// support is quite stable by now, you may still consider recompiling the
// library without it if you have no use for it - this will result in a
// somewhat smaller and faster operation.
//
// Notice that if wxNO_THREADS is defined, wxUSE_THREADS is automatically reset
// to 0 in wx/chkconf.h, so, for example, if you set USE_THREADS to 0 in
// build/msw/config.* file this value will have no effect.
//
// Default is 1
//
// Recommended setting: 0 unless you do plan to develop MT applications
#define wxUSE_THREADS 1
// If enabled, compiles wxWidgets streams classes
//
// wx stream classes are used for image IO, process IO redirection, network
// protocols implementation and much more and so disabling this results in a
// lot of other functionality being lost.
//
// Default is 1
//
// Recommended setting: 1 as setting it to 0 disables many other things
#define wxUSE_STREAMS 1
// Support for positional parameters (e.g. %1$d, %2$s ...) in wxVsnprintf.
// Note that if the system's implementation does not support positional
// parameters, setting this to 1 forces the use of the wxWidgets implementation
// of wxVsnprintf. The standard vsnprintf() supports positional parameters on
// many Unix systems but usually doesn't under Windows.
//
// Positional parameters are very useful when translating a program since using
// them in formatting strings allow translators to correctly reorder the
// translated sentences.
//
// Default is 1
//
// Recommended setting: 1 if you want to support multiple languages
#define wxUSE_PRINTF_POS_PARAMS 1
// Enable the use of compiler-specific thread local storage keyword, if any.
// This is used for wxTLS_XXX() macros implementation and normally should use
// the compiler-provided support as it's simpler and more efficient, but is
// disabled under Windows in wx/msw/chkconf.h as it can't be used if wxWidgets
// is used in a dynamically loaded Win32 DLL (i.e. using LoadLibrary()) under
// XP as this triggers a bug in compiler TLS support that results in crashes
// when any TLS variables are used.
//
// If you're absolutely sure that your build of wxWidgets is never going to be
// used in such situation, either because it's not going to be linked from any
// kind of plugin or because you only target Vista or later systems, you can
// set this to 2 to force the use of compiler TLS even under MSW.
//
// Default is 1 meaning that compiler TLS is used only if it's 100% safe.
//
// Recommended setting: 2 if you want to have maximal performance and don't
// care about the scenario described above.
#define wxUSE_COMPILER_TLS 1
// ----------------------------------------------------------------------------
// Interoperability with the standard library.
// ----------------------------------------------------------------------------
// Set wxUSE_STL to 1 to enable maximal interoperability with the standard
// library, even at the cost of backwards compatibility.
//
// Default is 0
//
// Recommended setting: 0 as the options below already provide a relatively
// good level of interoperability and changing this option arguably isn't worth
// diverging from the official builds of the library.
#define wxUSE_STL 0
// This is not a real option but is used as the default value for
// wxUSE_STD_IOSTREAM, wxUSE_STD_STRING and wxUSE_STD_CONTAINERS_COMPATIBLY.
//
// Set it to 0 if you want to disable the use of all standard classes
// completely for some reason.
#define wxUSE_STD_DEFAULT 1
// Use standard C++ containers where it can be done without breaking backwards
// compatibility.
//
// This provides better interoperability with the standard library, e.g. with
// this option on it's possible to insert std::vector<> into many wxWidgets
// containers directly.
//
// Default is 1.
//
// Recommended setting is 1 unless you want to avoid all dependencies on the
// standard library.
#define wxUSE_STD_CONTAINERS_COMPATIBLY wxUSE_STD_DEFAULT
// Use standard C++ containers to implement wxVector<>, wxStack<>, wxDList<>
// and wxHashXXX<> classes. If disabled, wxWidgets own (mostly compatible but
// usually more limited) implementations are used which allows to avoid the
// dependency on the C++ run-time library.
//
// Default is 0 for compatibility reasons.
//
// Recommended setting: 1 unless compatibility with the official wxWidgets
// build and/or the existing code is a concern.
#define wxUSE_STD_CONTAINERS 0
// Use standard C++ streams if 1 instead of wx streams in some places. If
// disabled, wx streams are used everywhere and wxWidgets doesn't depend on the
// standard streams library.
//
// Notice that enabling this does not replace wx streams with std streams
// everywhere, in a lot of places wx streams are used no matter what.
//
// Default is 1 if compiler supports it.
//
// Recommended setting: 1 if you use the standard streams anyhow and so
// dependency on the standard streams library is not a
// problem
#define wxUSE_STD_IOSTREAM wxUSE_STD_DEFAULT
// Enable minimal interoperability with the standard C++ string class if 1.
// "Minimal" means that wxString can be constructed from std::string or
// std::wstring but can't be implicitly converted to them. You need to enable
// the option below for the latter.
//
// Default is 1 for most compilers.
//
// Recommended setting: 1 unless you want to ensure your program doesn't use
// the standard C++ library at all.
#define wxUSE_STD_STRING wxUSE_STD_DEFAULT
// Make wxString as much interchangeable with std::[w]string as possible, in
// particular allow implicit conversion of wxString to either of these classes.
// This comes at a price (or a benefit, depending on your point of view) of not
// allowing implicit conversion to "const char *" and "const wchar_t *".
//
// Because a lot of existing code relies on these conversions, this option is
// disabled by default but can be enabled for your build if you don't care
// about compatibility.
//
// Default is 0 if wxUSE_STL has its default value or 1 if it is enabled.
//
// Recommended setting: 0 to remain compatible with the official builds of
// wxWidgets.
#define wxUSE_STD_STRING_CONV_IN_WXSTRING wxUSE_STL
// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
// them. Set this option to 1 to use <iostream.h>, 0 to use <iostream>.
//
// Note that newer compilers (including VC++ 7.1 and later) don't support
// wxUSE_IOSTREAMH == 1 and so <iostream> will be used anyhow.
//
// Default is 0.
//
// Recommended setting: 0, only set to 1 if you use a really old compiler
#define wxUSE_IOSTREAMH 0
// ----------------------------------------------------------------------------
// non GUI features selection
// ----------------------------------------------------------------------------
// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
// integer which is implemented in terms of native 64 bit integers if any or
// uses emulation otherwise.
//
// This class is required by wxDateTime and so you should enable it if you want
// to use wxDateTime. For most modern platforms, it will use the native 64 bit
// integers in which case (almost) all of its functions are inline and it
// almost does not take any space, so there should be no reason to switch it
// off.
//
// Recommended setting: 1
#define wxUSE_LONGLONG 1
// Set wxUSE_BASE64 to 1, to compile in Base64 support. This is required for
// storing binary data in wxConfig on most platforms.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_BASE64 1
// Set this to 1 to be able to use wxEventLoop even in console applications
// (i.e. using base library only, without GUI). This is mostly useful for
// processing socket events but is also necessary to use timers in console
// applications
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_CONSOLE_EVENTLOOP 1
// Set wxUSE_(F)FILE to 1 to compile wx(F)File classes. wxFile uses low level
// POSIX functions for file access, wxFFile uses ANSI C stdio.h functions.
//
// Default is 1
//
// Recommended setting: 1 (wxFile is highly recommended as it is required by
// i18n code, wxFileConfig and others)
#define wxUSE_FILE 1
#define wxUSE_FFILE 1
// Use wxFSVolume class providing access to the configured/active mount points
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_FSVOLUME 1
// Use wxSecretStore class for storing passwords using OS-specific facilities.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_SECRETSTORE 1
// Use wxStandardPaths class which allows to retrieve some standard locations
// in the file system
//
// Default is 1
//
// Recommended setting: 1 (may be disabled to save space, but not much)
#define wxUSE_STDPATHS 1
// use wxTextBuffer class: required by wxTextFile
#define wxUSE_TEXTBUFFER 1
// use wxTextFile class: requires wxFile and wxTextBuffer, required by
// wxFileConfig
#define wxUSE_TEXTFILE 1
// i18n support: _() macro, wxLocale class. Requires wxTextFile.
#define wxUSE_INTL 1
// Provide wxFoo_l() functions similar to standard foo() functions but taking
// an extra locale parameter.
//
// Notice that this is fully implemented only for the systems providing POSIX
// xlocale support or Microsoft Visual C++ >= 8 (which provides proprietary
// almost-equivalent of xlocale functions), otherwise wxFoo_l() functions will
// only work for the current user locale and "C" locale. You can use
// wxHAS_XLOCALE_SUPPORT to test whether the full support is available.
//
// Default is 1
//
// Recommended setting: 1 but may be disabled if you are writing programs
// running only in C locale anyhow
#define wxUSE_XLOCALE 1
// Set wxUSE_DATETIME to 1 to compile the wxDateTime and related classes which
// allow to manipulate dates, times and time intervals.
//
// Requires: wxUSE_LONGLONG
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_DATETIME 1
// Set wxUSE_TIMER to 1 to compile wxTimer class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_TIMER 1
// Use wxStopWatch clas.
//
// Default is 1
//
// Recommended setting: 1 (needed by wxSocket)
#define wxUSE_STOPWATCH 1
// Set wxUSE_FSWATCHER to 1 if you want to enable wxFileSystemWatcher
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FSWATCHER 1
// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
// which allow the application to store its settings in the persistent
// storage. Setting this to 1 will also enable on-demand creation of the
// global config object in wxApp.
//
// See also wxUSE_CONFIG_NATIVE below.
//
// Recommended setting: 1
#define wxUSE_CONFIG 1
// If wxUSE_CONFIG is 1, you may choose to use either the native config
// classes under Windows (using .INI files under Win16 and the registry under
// Win32) or the portable text file format used by the config classes under
// Unix.
//
// Default is 1 to use native classes. Note that you may still use
// wxFileConfig even if you set this to 1 - just the config object created by
// default for the applications needs will be a wxRegConfig or wxIniConfig and
// not wxFileConfig.
//
// Recommended setting: 1
#define wxUSE_CONFIG_NATIVE 1
// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
// to connect/disconnect from the network and be notified whenever the dial-up
// network connection is established/terminated. Requires wxUSE_DYNAMIC_LOADER.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DIALUP_MANAGER 1
// Compile in classes for run-time DLL loading and function calling.
// Required by wxUSE_DIALUP_MANAGER.
//
// This setting is for Win32 only
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DYNLIB_CLASS 1
// experimental, don't use for now
#define wxUSE_DYNAMIC_LOADER 1
// Set to 1 to use socket classes
#define wxUSE_SOCKETS 1
// Set to 1 to use ipv6 socket classes (requires wxUSE_SOCKETS)
//
// Notice that currently setting this option under Windows will result in
// programs which can only run on recent OS versions (with ws2_32.dll
// installed) which is why it is disabled by default.
//
// Default is 1.
//
// Recommended setting: 1 if you need IPv6 support
#define wxUSE_IPV6 0
// Set to 1 to enable virtual file systems (required by wxHTML)
#define wxUSE_FILESYSTEM 1
// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ZIP 1
// Set to 1 to enable virtual archive filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ARCHIVE 1
// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_INET 1
// wxArchive classes for accessing archives such as zip and tar
#define wxUSE_ARCHIVE_STREAMS 1
// Set to 1 to compile wxZipInput/OutputStream classes.
#define wxUSE_ZIPSTREAM 1
// Set to 1 to compile wxTarInput/OutputStream classes.
#define wxUSE_TARSTREAM 1
// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
// wxUSE_LIBPNG
#define wxUSE_ZLIB 1
// Set to 1 if liblzma is available to enable wxLZMA{Input,Output}Stream
// classes.
//
// Notice that if you enable this build option when not using configure or
// CMake, you need to ensure that liblzma headers and libraries are available
// (i.e. by building the library yourself or downloading its binaries) and can
// be found, either by copying them to one of the locations searched by the
// compiler/linker by default (e.g. any of the directories in the INCLUDE or
// LIB environment variables, respectively, when using MSVC) or modify the
// make- or project files to add references to these directories.
//
// Default is 0 under MSW, auto-detected by configure.
//
// Recommended setting: 1 if you need LZMA compression.
#define wxUSE_LIBLZMA 0
// If enabled, the code written by Apple will be used to write, in a portable
// way, float on the disk. See extended.c for the license which is different
// from wxWidgets one.
//
// Default is 1.
//
// Recommended setting: 1 unless you don't like the license terms (unlikely)
#define wxUSE_APPLE_IEEE 1
// Joystick support class
#define wxUSE_JOYSTICK 1
// wxFontEnumerator class
#define wxUSE_FONTENUM 1
// wxFontMapper class
#define wxUSE_FONTMAP 1
// wxMimeTypesManager class
#define wxUSE_MIMETYPE 1
// wxProtocol and related classes: if you want to use either of wxFTP, wxHTTP
// or wxURL you need to set this to 1.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_PROTOCOL 1
// The settings for the individual URL schemes
#define wxUSE_PROTOCOL_FILE 1
#define wxUSE_PROTOCOL_FTP 1
#define wxUSE_PROTOCOL_HTTP 1
// Define this to use wxURL class.
#define wxUSE_URL 1
// Define this to use native platform url and protocol support.
// Currently valid only for MS-Windows.
// Note: if you set this to 1, you can open ftp/http/gopher sites
// and obtain a valid input stream for these sites
// even when you set wxUSE_PROTOCOL_FTP/HTTP to 0.
// Doing so reduces the code size.
//
// This code is experimental and subject to change.
#define wxUSE_URL_NATIVE 0
// Support for wxVariant class used in several places throughout the library,
// notably in wxDataViewCtrl API.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size as much as
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
// Support for wxAny class, the successor for wxVariant.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size by a small amount,
// or your compiler cannot for some reason cope with complexity of templates used.
#define wxUSE_ANY 1
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
//
// Default is 0
//
// Recommended setting: 1 if your compiler supports it, if it doesn't please
// contribute us a makefile for src/regex for it
#define wxUSE_REGEX 1
// wxSystemOptions class
#define wxUSE_SYSTEM_OPTIONS 1
// wxSound class
#define wxUSE_SOUND 1
// Use wxMediaCtrl
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_MEDIACTRL 1
// Use wxWidget's XRC XML-based resource system. Recommended.
//
// Default is 1
//
// Recommended setting: 1 (requires wxUSE_XML)
#define wxUSE_XRC 1
// XML parsing classes. Note that their API will change in the future, so
// using wxXmlDocument and wxXmlNode in your app is not recommended.
//
// Default is the same as wxUSE_XRC, i.e. 1 by default.
//
// Recommended setting: 1 (required by XRC)
#define wxUSE_XML wxUSE_XRC
// Use wxWidget's AUI docking system
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_AUI 1
// Use wxWidget's Ribbon classes for interfaces
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_RIBBON 1
// Use wxPropertyGrid.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_PROPGRID 1
// Use wxStyledTextCtrl, a wxWidgets implementation of Scintilla.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STC 1
// Use wxWidget's web viewing classes
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_WEBVIEW 1
// Use the IE wxWebView backend
//
// Default is 1 on MSW
//
// Recommended setting: 1
#ifdef __WXMSW__
#define wxUSE_WEBVIEW_IE 1
#else
#define wxUSE_WEBVIEW_IE 0
#endif
// Use the WebKit wxWebView backend
//
// Default is 1 on GTK and OSX
//
// Recommended setting: 1
#if (defined(__WXGTK__) && !defined(__WXGTK3__)) || defined(__WXOSX__)
#define wxUSE_WEBVIEW_WEBKIT 1
#else
#define wxUSE_WEBVIEW_WEBKIT 0
#endif
// Use the WebKit2 wxWebView backend
//
// Default is 1 on GTK3
//
// Recommended setting: 1
#if defined(__WXGTK3__)
#define wxUSE_WEBVIEW_WEBKIT2 1
#else
#define wxUSE_WEBVIEW_WEBKIT2 0
#endif
// Enable wxGraphicsContext and related classes for a modern 2D drawing API.
//
// Default is 1 except if you're using a compiler without support for GDI+
// under MSW, i.e. gdiplus.h and related headers (MSVC and MinGW >= 4.8 are
// known to have them). For other compilers (e.g. older mingw32) you may need
// to install the headers (and just the headers) yourself. If you do, change
// the setting below manually.
//
// Recommended setting: 1 if supported by the compilation environment
// Notice that we can't use wxCHECK_VISUALC_VERSION() nor wxCHECK_GCC_VERSION()
// here as this file is included from wx/platform.h before they're defined.
#if defined(_MSC_VER) || \
(defined(__MINGW32__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 8))
#define wxUSE_GRAPHICS_CONTEXT 1
#else
// Disable support for other Windows compilers, enable it if your compiler
// comes with new enough SDK or you installed the headers manually.
//
// Notice that this will be set by configure under non-Windows platforms
// anyhow so the value there is not important.
#define wxUSE_GRAPHICS_CONTEXT 0
#endif
// Enable wxGraphicsContext implementation using Cairo library.
//
// This is not needed under Windows and detected automatically by configure
// under other systems, however you may set this to 1 manually if you installed
// Cairo under Windows yourself and prefer to use it instead the native GDI+
// implementation.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_CAIRO 0
// ----------------------------------------------------------------------------
// Individual GUI controls
// ----------------------------------------------------------------------------
// You must set wxUSE_CONTROLS to 1 if you are using any controls at all
// (without it, wxControl class is not compiled)
//
// Default is 1
//
// Recommended setting: 1 (don't change except for very special programs)
#define wxUSE_CONTROLS 1
// Support markup in control labels, i.e. provide wxControl::SetLabelMarkup().
// Currently markup is supported only by a few controls and only some ports but
// their number will increase with time.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you want to save on code size)
#define wxUSE_MARKUP 1
// wxPopupWindow class is a top level transient window. It is currently used
// to implement wxTipWindow
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you don't wxUSE_TIPWINDOW)
#define wxUSE_POPUPWIN 1
// wxTipWindow allows to implement the custom tooltips, it is used by the
// context help classes. Requires wxUSE_POPUPWIN.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0)
#define wxUSE_TIPWINDOW 1
// Each of the settings below corresponds to one wxWidgets control. They are
// all switched on by default but may be disabled if you are sure that your
// program (including any standard dialogs it can show!) doesn't need them and
// if you desperately want to save some space. If you use any of these you must
// set wxUSE_CONTROLS as well.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_ACTIVITYINDICATOR 1 // wxActivityIndicator
#define wxUSE_ANIMATIONCTRL 1 // wxAnimationCtrl
#define wxUSE_BANNERWINDOW 1 // wxBannerWindow
#define wxUSE_BUTTON 1 // wxButton
#define wxUSE_BMPBUTTON 1 // wxBitmapButton
#define wxUSE_CALENDARCTRL 1 // wxCalendarCtrl
#define wxUSE_CHECKBOX 1 // wxCheckBox
#define wxUSE_CHECKLISTBOX 1 // wxCheckListBox (requires wxUSE_OWNER_DRAWN)
#define wxUSE_CHOICE 1 // wxChoice
#define wxUSE_COLLPANE 1 // wxCollapsiblePane
#define wxUSE_COLOURPICKERCTRL 1 // wxColourPickerCtrl
#define wxUSE_COMBOBOX 1 // wxComboBox
#define wxUSE_COMMANDLINKBUTTON 1 // wxCommandLinkButton
#define wxUSE_DATAVIEWCTRL 1 // wxDataViewCtrl
#define wxUSE_DATEPICKCTRL 1 // wxDatePickerCtrl
#define wxUSE_DIRPICKERCTRL 1 // wxDirPickerCtrl
#define wxUSE_EDITABLELISTBOX 1 // wxEditableListBox
#define wxUSE_FILECTRL 1 // wxFileCtrl
#define wxUSE_FILEPICKERCTRL 1 // wxFilePickerCtrl
#define wxUSE_FONTPICKERCTRL 1 // wxFontPickerCtrl
#define wxUSE_GAUGE 1 // wxGauge
#define wxUSE_HEADERCTRL 1 // wxHeaderCtrl
#define wxUSE_HYPERLINKCTRL 1 // wxHyperlinkCtrl
#define wxUSE_LISTBOX 1 // wxListBox
#define wxUSE_LISTCTRL 1 // wxListCtrl
#define wxUSE_RADIOBOX 1 // wxRadioBox
#define wxUSE_RADIOBTN 1 // wxRadioButton
#define wxUSE_RICHMSGDLG 1 // wxRichMessageDialog
#define wxUSE_SCROLLBAR 1 // wxScrollBar
#define wxUSE_SEARCHCTRL 1 // wxSearchCtrl
#define wxUSE_SLIDER 1 // wxSlider
#define wxUSE_SPINBTN 1 // wxSpinButton
#define wxUSE_SPINCTRL 1 // wxSpinCtrl
#define wxUSE_STATBOX 1 // wxStaticBox
#define wxUSE_STATLINE 1 // wxStaticLine
#define wxUSE_STATTEXT 1 // wxStaticText
#define wxUSE_STATBMP 1 // wxStaticBitmap
#define wxUSE_TEXTCTRL 1 // wxTextCtrl
#define wxUSE_TIMEPICKCTRL 1 // wxTimePickerCtrl
#define wxUSE_TOGGLEBTN 1 // requires wxButton
#define wxUSE_TREECTRL 1 // wxTreeCtrl
#define wxUSE_TREELISTCTRL 1 // wxTreeListCtrl
// Use a status bar class? Depending on the value of wxUSE_NATIVE_STATUSBAR
// below either wxStatusBar95 or a generic wxStatusBar will be used.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STATUSBAR 1
// Two status bar implementations are available under Win32: the generic one
// or the wrapper around native control. For native look and feel the native
// version should be used.
//
// Default is 1 for the platforms where native status bar is supported.
//
// Recommended setting: 1 (there is no advantage in using the generic one)
#define wxUSE_NATIVE_STATUSBAR 1
// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
// classes at all. Otherwise, use the native toolbar class unless
// wxUSE_TOOLBAR_NATIVE is 0.
//
// Default is 1 for all settings.
//
// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE.
#define wxUSE_TOOLBAR 1
#define wxUSE_TOOLBAR_NATIVE 1
// wxNotebook is a control with several "tabs" located on one of its sides. It
// may be used to logically organise the data presented to the user instead of
// putting everything in one huge dialog. It replaces wxTabControl and related
// classes of wxWin 1.6x.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTEBOOK 1
// wxListbook control is similar to wxNotebook but uses wxListCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_LISTBOOK 1
// wxChoicebook control is similar to wxNotebook but uses wxChoice instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CHOICEBOOK 1
// wxTreebook control is similar to wxNotebook but uses wxTreeCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TREEBOOK 1
// wxToolbook control is similar to wxNotebook but uses wxToolBar instead of
// tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLBOOK 1
// wxTaskBarIcon is a small notification icon shown in the system toolbar or
// dock.
//
// Default is 1.
//
// Recommended setting: 1 (but can be set to 0 if you don't need it)
#define wxUSE_TASKBARICON 1
// wxGrid class
//
// Default is 1, set to 0 to cut down compilation time and binaries size if you
// don't use it.
//
// Recommended setting: 1
//
#define wxUSE_GRID 1
// wxMiniFrame class: a frame with narrow title bar
//
// Default is 1.
//
// Recommended setting: 1 (it doesn't cost almost anything)
#define wxUSE_MINIFRAME 1
// wxComboCtrl and related classes: combobox with custom popup window and
// not necessarily a listbox.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 except for wxUniv where it
// it used by wxComboBox
#define wxUSE_COMBOCTRL 1
// wxOwnerDrawnComboBox is a custom combobox allowing to paint the combobox
// items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0, except where it is
// needed as a base class for generic wxBitmapComboBox.
#define wxUSE_ODCOMBOBOX 1
// wxBitmapComboBox is a combobox that can have images in front of text items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0
#define wxUSE_BITMAPCOMBOBOX 1
// wxRearrangeCtrl is a wxCheckListBox with two buttons allowing to move items
// up and down in it. It is also used as part of wxRearrangeDialog.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 (currently used only by
// wxHeaderCtrl)
#define wxUSE_REARRANGECTRL 1
// wxAddRemoveCtrl is a composite control containing a control showing some
// items (e.g. wxListBox, wxListCtrl, wxTreeCtrl, wxDataViewCtrl, ...) and "+"/
// "-" buttons allowing to add and remove items to/from the control.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 if you don't need it (not
// used by the library itself).
#define wxUSE_ADDREMOVECTRL 1
// ----------------------------------------------------------------------------
// Miscellaneous GUI stuff
// ----------------------------------------------------------------------------
// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
#define wxUSE_ACCEL 1
// Use the standard art provider. The icons returned by this provider are
// embedded into the library as XPMs so disabling it reduces the library size
// somewhat but this should only be done if you use your own custom art
// provider returning the icons or never use any icons not provided by the
// native art provider (which might not be implemented at all for some
// platforms) or by the Tango icons provider (if it's not itself disabled
// below).
//
// Default is 1.
//
// Recommended setting: 1 unless you use your own custom art provider.
#define wxUSE_ARTPROVIDER_STD 1
// Use art provider providing Tango icons: this art provider has higher quality
// icons than the default ones using smaller size XPM icons without
// transparency but the embedded PNG icons add to the library size.
//
// Default is 1 under non-GTK ports. Under wxGTK the native art provider using
// the GTK+ stock icons replaces it so it is normally not necessary.
//
// Recommended setting: 1 but can be turned off to reduce the library size.
#define wxUSE_ARTPROVIDER_TANGO 1
// Hotkey support (currently Windows only)
#define wxUSE_HOTKEY 1
// Use wxCaret: a class implementing a "cursor" in a text control (called caret
// under Windows).
//
// Default is 1.
//
// Recommended setting: 1 (can be safely set to 0, not used by the library)
#define wxUSE_CARET 1
// Use wxDisplay class: it allows enumerating all displays on a system and
// their geometries as well as finding the display on which the given point or
// window lies.
//
// Default is 1.
//
// Recommended setting: 1 if you need it, can be safely set to 0 otherwise
#define wxUSE_DISPLAY 1
// Miscellaneous geometry code: needed for Canvas library
#define wxUSE_GEOMETRY 1
// Use wxImageList. This class is needed by wxNotebook, wxTreeCtrl and
// wxListCtrl.
//
// Default is 1.
//
// Recommended setting: 1 (set it to 0 if you don't use any of the controls
// enumerated above, then this class is mostly useless too)
#define wxUSE_IMAGLIST 1
// Use wxInfoBar class.
//
// Default is 1.
//
// Recommended setting: 1 (but can be disabled without problems as nothing
// depends on it)
#define wxUSE_INFOBAR 1
// Use wxMenu, wxMenuBar, wxMenuItem.
//
// Default is 1.
//
// Recommended setting: 1 (can't be disabled under MSW)
#define wxUSE_MENUS 1
// Use wxNotificationMessage.
//
// wxNotificationMessage allows to show non-intrusive messages to the user
// using balloons, banners, popups or whatever is the appropriate method for
// the current platform.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTIFICATION_MESSAGE 1
// wxPreferencesEditor provides a common API for different ways of presenting
// the standard "Preferences" or "Properties" dialog under different platforms
// (e.g. some use modal dialogs, some use modeless ones; some apply the changes
// immediately while others require an explicit "Apply" button).
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_PREFERENCES_EDITOR 1
// wxFont::AddPrivateFont() allows to use fonts not installed on the system by
// loading them from font files during run-time.
//
// Default is 1 except under Unix where it will be turned off by configure if
// the required libraries are not available or not new enough.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it and
// want to avoid extra dependencies under Linux, for example).
#define wxUSE_PRIVATE_FONTS 1
// wxRichToolTip is a customizable tooltip class which has more functionality
// than the stock (but native, unlike this class) wxToolTip.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely set to 0 if you don't need it)
#define wxUSE_RICHTOOLTIP 1
// Use wxSashWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SASH 1
// Use wxSplitterWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SPLITTER 1
// Use wxToolTip and wxWindow::Set/GetToolTip() methods.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLTIPS 1
// wxValidator class and related methods
#define wxUSE_VALIDATORS 1
// Use reference counted ID management: this means that wxWidgets will track
// the automatically allocated ids (those used when you use wxID_ANY when
// creating a window, menu or toolbar item &c) instead of just supposing that
// the program never runs out of them. This is mostly useful only under wxMSW
// where the total ids range is limited to SHRT_MIN..SHRT_MAX and where
// long-running programs can run into problems with ids reuse without this. On
// the other platforms, where the ids have the full int range, this shouldn't
// be necessary.
#ifdef __WXMSW__
#define wxUSE_AUTOID_MANAGEMENT 1
#else
#define wxUSE_AUTOID_MANAGEMENT 0
#endif
// ----------------------------------------------------------------------------
// common dialogs
// ----------------------------------------------------------------------------
// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
// file selector, printer dialog). Switching this off also switches off the
// printing architecture and interactive wxPrinterDC.
//
// Default is 1
//
// Recommended setting: 1 (unless it really doesn't work)
#define wxUSE_COMMON_DIALOGS 1
// wxBusyInfo displays window with message when app is busy. Works in same way
// as wxBusyCursor
#define wxUSE_BUSYINFO 1
// Use single/multiple choice dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_CHOICEDLG 1
// Use colour picker dialog
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_COLOURDLG 1
// wxDirDlg class for getting a directory name from user
#define wxUSE_DIRDLG 1
// TODO: setting to choose the generic or native one
// Use file open/save dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in many places in the library itself)
#define wxUSE_FILEDLG 1
// Use find/replace dialogs.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely set to 0)
#define wxUSE_FINDREPLDLG 1
// Use font picker dialog
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_FONTDLG 1
// Use wxMessageDialog and wxMessageBox.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_MSGDLG 1
// progress dialog class for lengthy operations
#define wxUSE_PROGRESSDLG 1
// Set to 0 to disable the use of the native progress dialog (currently only
// available under MSW and suffering from some bugs there, hence this option).
#define wxUSE_NATIVE_PROGRESSDLG 1
// support for startup tips (wxShowTip &c)
#define wxUSE_STARTUP_TIPS 1
// text entry dialog and wxGetTextFromUser function
#define wxUSE_TEXTDLG 1
// number entry dialog
#define wxUSE_NUMBERDLG 1
// splash screen class
#define wxUSE_SPLASH 1
// wizards
#define wxUSE_WIZARDDLG 1
// Compile in wxAboutBox() function showing the standard "About" dialog.
//
// Default is 1
//
// Recommended setting: 1 but can be set to 0 to save some space if you don't
// use this function
#define wxUSE_ABOUTDLG 1
// wxFileHistory class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FILE_HISTORY 1
// ----------------------------------------------------------------------------
// Metafiles support
// ----------------------------------------------------------------------------
// Windows supports the graphics format known as metafile which, though not
// portable, is widely used under Windows and so is supported by wxWidgets
// (under Windows only, of course). Both the so-called "Window MetaFiles" or
// WMFs, and "Enhanced MetaFiles" or EMFs are supported in wxWin and, by
// default, EMFs will be used. This may be changed by setting
// wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting wxUSE_ENH_METAFILE to 0.
// You may also set wxUSE_METAFILE to 0 to not compile in any metafile
// related classes at all.
//
// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
//
// Recommended setting: default or 0 for everything for portable programs.
#define wxUSE_METAFILE 1
#define wxUSE_ENH_METAFILE 1
#define wxUSE_WIN_METAFILES_ALWAYS 0
// ----------------------------------------------------------------------------
// Big GUI components
// ----------------------------------------------------------------------------
// Set to 0 to disable MDI support.
//
// Requires wxUSE_NOTEBOOK under platforms other than MSW.
//
// Default is 1.
//
// Recommended setting: 1, can be safely set to 0.
#define wxUSE_MDI 1
// Set to 0 to disable document/view architecture
#define wxUSE_DOC_VIEW_ARCHITECTURE 1
// Set to 0 to disable MDI document/view architecture
//
// Requires wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 1
// Set to 0 to disable print/preview architecture code
#define wxUSE_PRINTING_ARCHITECTURE 1
// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
// much more.
//
// Default is 1.
//
// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
// smaller library.
#define wxUSE_HTML 1
// Setting wxUSE_GLCANVAS to 1 enables OpenGL support. You need to have OpenGL
// headers and libraries to be able to compile the library with wxUSE_GLCANVAS
// set to 1 and, under Windows, also to add opengl32.lib and glu32.lib to the
// list of libraries used to link your application (although this is done
// implicitly for Microsoft Visual C++ users).
//
// Default is 1.
//
// Recommended setting: 1 if you intend to use OpenGL, can be safely set to 0
// otherwise.
#define wxUSE_GLCANVAS 1
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 if you want compile a
// smaller library.
#define wxUSE_RICHTEXT 1
// ----------------------------------------------------------------------------
// Data transfer
// ----------------------------------------------------------------------------
// Use wxClipboard class for clipboard copy/paste.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CLIPBOARD 1
// Use wxDataObject and related classes. Needed for clipboard and OLE drag and
// drop
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DATAOBJ 1
// Use wxDropTarget and wxDropSource classes for drag and drop (this is
// different from "built in" drag and drop in wxTreeCtrl which is always
// available). Requires wxUSE_DATAOBJ.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DRAG_AND_DROP 1
// Use wxAccessible for enhanced and customisable accessibility.
// Depends on wxUSE_OLE on MSW.
//
// Default is 1 on MSW, 0 elsewhere.
//
// Recommended setting (at present): 1 (MSW-only)
#ifdef __WXMSW__
#define wxUSE_ACCESSIBILITY 1
#else
#define wxUSE_ACCESSIBILITY 0
#endif
// ----------------------------------------------------------------------------
// miscellaneous settings
// ----------------------------------------------------------------------------
// wxSingleInstanceChecker class allows to verify at startup if another program
// instance is running.
//
// Default is 1
//
// Recommended setting: 1 (the class is tiny, disabling it won't save much
// space)
#define wxUSE_SNGLINST_CHECKER 1
#define wxUSE_DRAGIMAGE 1
#define wxUSE_IPC 1
// 0 for no interprocess comms
#define wxUSE_HELP 1
// 0 for no help facility
// Should we use MS HTML help for wxHelpController? If disabled, neither
// wxCHMHelpController nor wxBestHelpController are available.
//
// Default is 1 under MSW, 0 is always used for the other platforms.
//
// Recommended setting: 1, only set to 0 if you have trouble compiling
// wxCHMHelpController (could be a problem with really ancient compilers)
#define wxUSE_MS_HTML_HELP 1
// Use wxHTML-based help controller?
#define wxUSE_WXHTML_HELP 1
#define wxUSE_CONSTRAINTS 1
// 0 for no window layout constraint system
#define wxUSE_SPLINES 1
// 0 for no splines
#define wxUSE_MOUSEWHEEL 1
// Include mouse wheel support
// Compile wxUIActionSimulator class?
#define wxUSE_UIACTIONSIMULATOR 1
// ----------------------------------------------------------------------------
// wxDC classes for various output formats
// ----------------------------------------------------------------------------
// Set to 1 for PostScript device context.
#define wxUSE_POSTSCRIPT 0
// Set to 1 to use font metric files in GetTextExtent
#define wxUSE_AFM_FOR_POSTSCRIPT 1
// Set to 1 to compile in support for wxSVGFileDC, a wxDC subclass which allows
// to create files in SVG (Scalable Vector Graphics) format.
#define wxUSE_SVG 1
// Should wxDC provide SetTransformMatrix() and related methods?
//
// Default is 1 but can be set to 0 if this functionality is not used. Notice
// that currently wxMSW, wxGTK3 support this for wxDC and all platforms support
// this for wxGCDC so setting this to 0 doesn't change much if neither of these
// is used (although it will still save a few bytes probably).
//
// Recommended setting: 1.
#define wxUSE_DC_TRANSFORM_MATRIX 1
// ----------------------------------------------------------------------------
// image format support
// ----------------------------------------------------------------------------
// wxImage supports many different image formats which can be configured at
// compile-time. BMP is always supported, others are optional and can be safely
// disabled if you don't plan to use images in such format sometimes saving
// substantial amount of code in the final library.
//
// Some formats require an extra library which is included in wxWin sources
// which is mentioned if it is the case.
// Set to 1 for wxImage support (recommended).
#define wxUSE_IMAGE 1
// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
#define wxUSE_LIBPNG 1
// Set to 1 for JPEG format support (requires libjpeg)
#define wxUSE_LIBJPEG 1
// Set to 1 for TIFF format support (requires libtiff)
#define wxUSE_LIBTIFF 1
// Set to 1 for TGA format support (loading only)
#define wxUSE_TGA 1
// Set to 1 for GIF format support
#define wxUSE_GIF 1
// Set to 1 for PNM format support
#define wxUSE_PNM 1
// Set to 1 for PCX format support
#define wxUSE_PCX 1
// Set to 1 for IFF format support (Amiga format)
#define wxUSE_IFF 0
// Set to 1 for XPM format support
#define wxUSE_XPM 1
// Set to 1 for MS Icons and Cursors format support
#define wxUSE_ICO_CUR 1
// Set to 1 to compile in wxPalette class
#define wxUSE_PALETTE 1
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
/* --- end common options --- */
/* --- start MSW options --- */
// ----------------------------------------------------------------------------
// Graphics backends choices for Windows
// ----------------------------------------------------------------------------
// The options here are only taken into account if wxUSE_GRAPHICS_CONTEXT is 1.
// Enable support for GDI+-based implementation of wxGraphicsContext.
//
// Default is 1.
//
// Recommended setting: 1 if you need to support XP, as Direct2D is not
// available there.
#define wxUSE_GRAPHICS_GDIPLUS wxUSE_GRAPHICS_CONTEXT
// Enable support for Direct2D-based implementation of wxGraphicsContext.
//
// Default is 1 for compilers which support it, i.e. VC10+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1 for faster and better quality graphics under Windows
// 7 and later systems (if wxUSE_GRAPHICS_GDIPLUS is also enabled, earlier
// systems will fall back on using GDI+).
#if defined(_MSC_VER) && _MSC_VER >= 1600
#define wxUSE_GRAPHICS_DIRECT2D wxUSE_GRAPHICS_CONTEXT
#else
#define wxUSE_GRAPHICS_DIRECT2D 0
#endif
// ----------------------------------------------------------------------------
// Windows-only settings
// ----------------------------------------------------------------------------
// Set this to 1 for generic OLE support: this is required for drag-and-drop,
// clipboard, OLE Automation. Only set it to 0 if your compiler is very old and
// can't compile/doesn't have the OLE headers.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_OLE 1
// Set this to 1 to enable wxAutomationObject class.
//
// Default is 1.
//
// Recommended setting: 1 if you need to control other applications via OLE
// Automation, can be safely set to 0 otherwise
#define wxUSE_OLE_AUTOMATION 1
// Set this to 1 to enable wxActiveXContainer class allowing to embed OLE
// controls in wx.
//
// Default is 1.
//
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
// Enable WinRT support
//
// Default is 1 for compilers which support it, i.e. VS2012+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1
#if defined(_MSC_VER) && _MSC_VER >= 1700 && !defined(_USING_V110_SDK71_)
#define wxUSE_WINRT 1
#else
#define wxUSE_WINRT 0
#endif
// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
// wxBitmap data.
//
// Default is 1, set it to 0 only if you don't use wxImage neither
//
// Recommended setting: 1 (without it conversion to/from wxImage won't work)
#define wxUSE_WXDIB 1
// Set to 0 to disable PostScript print/preview architecture code under Windows
// (just use Windows printing).
#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
// Set this to 1 to compile in wxRegKey class.
//
// Default is 1
//
// Recommended setting: 1, this is used internally by wx in a few places
#define wxUSE_REGKEY 1
// Set this to 1 to use RICHEDIT controls for wxTextCtrl with style wxTE_RICH
// which allows to put more than ~32Kb of text in it even under Win9x (NT
// doesn't have such limitation).
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1, only set it to 0 if your compiler doesn't have
// or can't compile <richedit.h>
#define wxUSE_RICHEDIT 1
// Set this to 1 to use extra features of richedit v2 and later controls
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1
#define wxUSE_RICHEDIT2 1
// Set this to 1 to enable support for the owner-drawn menu and listboxes. This
// is required by wxUSE_CHECKLISTBOX.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a small library size reduction
#define wxUSE_OWNER_DRAWN 1
// Set this to 1 to enable MSW-specific wxTaskBarIcon::ShowBalloon() method. It
// is required by native wxNotificationMessage implementation.
//
// Default is 1 but disabled in wx/msw/chkconf.h if SDK is too old to contain
// the necessary declarations.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARICON_BALLOONS 1
// Set this to 1 to enable following functionality added in Windows 7: thumbnail
// representations, thumbnail toolbars, notification and status overlays,
// progress indicators and jump lists.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARBUTTON 1
// Set to 1 to compile MS Windows XP theme engine support
#define wxUSE_UXTHEME 1
// Set to 1 to use InkEdit control (Tablet PC), if available
#define wxUSE_INKEDIT 0
// Set to 1 to enable .INI files based wxConfig implementation (wxIniConfig)
//
// Default is 0.
//
// Recommended setting: 0, nobody uses .INI files any more
#define wxUSE_INICONF 0
// ----------------------------------------------------------------------------
// Generic versions of native controls
// ----------------------------------------------------------------------------
// Set this to 1 to be able to use wxDatePickerCtrlGeneric in addition to the
// native wxDatePickerCtrl
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_DATEPICKCTRL_GENERIC 0
// Set this to 1 to be able to use wxTimePickerCtrlGeneric in addition to the
// native wxTimePickerCtrl for the platforms that have the latter (MSW).
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_TIMEPICKCTRL_GENERIC 0
// ----------------------------------------------------------------------------
// Crash debugging helpers
// ----------------------------------------------------------------------------
// Set this to 1 to use dbghelp.dll for providing stack traces in crash
// reports.
//
// Default is 1 if the compiler supports it, 0 for old MinGW.
//
// Recommended setting: 1, there is not much gain in disabling this
#if defined(__VISUALC__) || defined(__MINGW64_TOOLCHAIN__)
#define wxUSE_DBGHELP 1
#else
#define wxUSE_DBGHELP 0
#endif
// Set this to 1 to be able to use wxCrashReport::Generate() to create mini
// dumps of your program when it crashes (or at any other moment)
//
// Default is 1 if supported by the compiler (VC++ and recent BC++ only).
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_CRASHREPORT 1
/* --- end MSW options --- */
#endif // _WX_SETUP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/datetimectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/datetimectrl.h
// Purpose: wxDateTimePickerCtrl for Windows.
// Author: Vadim Zeitlin
// Created: 2011-09-22 (extracted from wx/msw/datectrl.h).
// Copyright: (c) 2005-2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DATETIMECTRL_H_
#define _WX_MSW_DATETIMECTRL_H_
#include "wx/intl.h"
// Forward declare a struct from Platform SDK.
struct tagNMDATETIMECHANGE;
// ----------------------------------------------------------------------------
// wxDateTimePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDateTimePickerCtrl : public wxDateTimePickerCtrlBase
{
public:
// set/get the date
virtual void SetValue(const wxDateTime& dt) wxOVERRIDE;
virtual wxDateTime GetValue() const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// Helper for the derived classes Create(): creates a native control with
// the specified attributes.
bool MSWCreateDateTimePicker(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name);
// Notice that the methods below must be overridden in all native MSW
// classes inheriting from this one but they can't be pure virtual because
// the generic implementations, not needing nor able to implement them, is
// also derived from this class currently. The real problem is, of course,
// this wrong class structure because the generic classes also inherit the
// wrong implementations of Set/GetValue() and DoGetBestSize() but as they
// override these methods anyhow, it does work -- but is definitely ugly
// and need to be changed (but how?) in the future.
#if wxUSE_INTL
// Override to return the date/time format used by this control.
virtual wxLocaleInfo MSWGetFormat() const /* = 0 */
{
wxFAIL_MSG( "Unreachable" );
return wxLOCALE_TIME_FMT;
}
#endif // wxUSE_INTL
// Override to indicate whether we can have no date at all.
virtual bool MSWAllowsNone() const /* = 0 */
{
wxFAIL_MSG( "Unreachable" );
return false;
}
// Override to update m_date and send the event when the control contents
// changes, return true if the event was handled.
virtual bool MSWOnDateTimeChange(const tagNMDATETIMECHANGE& dtch) /* = 0 */
{
wxUnusedVar(dtch);
wxFAIL_MSG( "Unreachable" );
return false;
}
// the date currently shown by the control, may be invalid
wxDateTime m_date;
};
#endif // _WX_MSW_DATETIMECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/wrapshl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapshl.h
// Purpose: wrapper class for stuff from shell32.dll
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-10-19
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WRAPSHL_H_
#define _WX_MSW_WRAPSHL_H_
#include "wx/msw/wrapwin.h"
#ifdef __VISUALC__
// Disable a warning that we can do nothing about: we get it for
// shlobj.h at least from 7.1a Windows kit when using VC14.
#pragma warning(push)
// 'typedef ': ignored on left of '' when no variable is declared
#pragma warning(disable:4091)
#endif
#include <shlobj.h>
#ifdef __VISUALC__
#pragma warning(pop)
#endif
#include "wx/msw/winundef.h"
#include "wx/log.h"
// ----------------------------------------------------------------------------
// wxItemIdList implements RAII on top of ITEMIDLIST
// ----------------------------------------------------------------------------
class wxItemIdList
{
public:
// ctor takes ownership of the item and will free it
wxItemIdList(LPITEMIDLIST pidl)
{
m_pidl = pidl;
}
static void Free(LPITEMIDLIST pidl)
{
if ( pidl )
{
LPMALLOC pMalloc;
SHGetMalloc(&pMalloc);
if ( pMalloc )
{
pMalloc->Free(pidl);
pMalloc->Release();
}
else
{
wxLogLastError(wxT("SHGetMalloc"));
}
}
}
~wxItemIdList()
{
Free(m_pidl);
}
// implicit conversion to LPITEMIDLIST
operator LPITEMIDLIST() const { return m_pidl; }
// get the corresponding path, returns empty string on error
wxString GetPath() const
{
wxString path;
if ( !SHGetPathFromIDList(m_pidl, wxStringBuffer(path, MAX_PATH)) )
{
wxLogLastError(wxT("SHGetPathFromIDList"));
}
return path;
}
private:
LPITEMIDLIST m_pidl;
wxDECLARE_NO_COPY_CLASS(wxItemIdList);
};
// enable autocompleting filenames in the text control with given HWND
//
// this only works on systems with shlwapi.dll 5.0 or later
//
// implemented in src/msw/utilsgui.cpp
extern bool wxEnableFileNameAutoComplete(HWND hwnd);
#endif // _WX_MSW_WRAPSHL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/listctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/listctrl.h
// Purpose: wxListCtrl class
// Author: Julian Smart
// Modified by: Agron Selimaj
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTCTRL_H_
#define _WX_LISTCTRL_H_
#include "wx/textctrl.h"
#include "wx/dynarray.h"
#include "wx/vector.h"
class wxMSWListItemData;
class wxMSWListHeaderCustomDraw;
// define this symbol to indicate the availability of SetColumnsOrder() and
// related functions
#define wxHAS_LISTCTRL_COLUMN_ORDER
/*
The wxListCtrl can show lists of items in four different modes:
wxLC_LIST: multicolumn list view, with optional small icons (icons could be
optional for some platforms). Columns are computed automatically,
i.e. you don't set columns as in wxLC_REPORT. In other words,
the list wraps, unlike a wxListBox.
wxLC_REPORT: single or multicolumn report view (with optional header)
wxLC_ICON: large icon view, with optional labels
wxLC_SMALL_ICON: small icon view, with optional labels
You can change the style dynamically, either with SetSingleStyle or
SetWindowStyleFlag.
Further window styles:
wxLC_ALIGN_TOP icons align to the top (default)
wxLC_ALIGN_LEFT icons align to the left
wxLC_AUTOARRANGE icons arrange themselves
wxLC_USER_TEXT the app provides label text on demand, except for column headers
wxLC_EDIT_LABELS labels are editable: app will be notified.
wxLC_NO_HEADER no header in report mode
wxLC_NO_SORT_HEADER can't click on header
wxLC_SINGLE_SEL single selection
wxLC_SORT_ASCENDING sort ascending (must still supply a comparison callback in SortItems)
wxLC_SORT_DESCENDING sort descending (ditto)
Items are referred to by their index (position in the list starting from zero).
Label text is supplied via insertion/setting functions and is stored by the
control, unless the wxLC_USER_TEXT style has been specified, in which case
the app will be notified when text is required (see sample).
Images are dealt with by (optionally) associating 3 image lists with the control.
Zero-based indexes into these image lists indicate which image is to be used for
which item. Each image in an image list can contain a mask, and can be made out
of either a bitmap, two bitmaps or an icon. See ImagList.h for more details.
Notifications are passed via the event system.
See the sample wxListCtrl app for API usage.
TODO:
- addition of further convenience functions
to avoid use of wxListItem in some functions
- state/overlay images: probably not needed.
- testing of whole API, extending current sample.
*/
class WXDLLIMPEXP_CORE wxListCtrl: public wxListCtrlBase
{
public:
/*
* Public interface
*/
wxListCtrl() { Init(); }
wxListCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListCtrlNameStr)
{
Init();
Create(parent, id, pos, size, style, validator, name);
}
virtual ~wxListCtrl();
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListCtrlNameStr);
// Attributes
////////////////////////////////////////////////////////////////////////////
// Set the control colours
bool SetForegroundColour(const wxColour& col) wxOVERRIDE;
bool SetBackgroundColour(const wxColour& col) wxOVERRIDE;
// Header attributes
virtual bool SetHeaderAttr(const wxItemAttr& attr) wxOVERRIDE;
// Gets information about this column
bool GetColumn(int col, wxListItem& item) const wxOVERRIDE;
// Sets information about this column
bool SetColumn(int col, const wxListItem& item) wxOVERRIDE;
// Gets the column width
int GetColumnWidth(int col) const wxOVERRIDE;
// Sets the column width
bool SetColumnWidth(int col, int width) wxOVERRIDE;
// Gets the column order from its index or index from its order
int GetColumnOrder(int col) const;
int GetColumnIndexFromOrder(int order) const;
// Gets the column order for all columns
wxArrayInt GetColumnsOrder() const;
// Sets the column order for all columns
bool SetColumnsOrder(const wxArrayInt& orders);
// Gets the number of items that can fit vertically in the
// visible area of the list control (list or report view)
// or the total number of items in the list control (icon
// or small icon view)
int GetCountPerPage() const;
// return the total area occupied by all the items (icon/small icon only)
wxRect GetViewRect() const;
// Gets the edit control for editing labels.
wxTextCtrl* GetEditControl() const;
// Gets information about the item
bool GetItem(wxListItem& info) const;
// Sets information about the item
bool SetItem(wxListItem& info);
// Sets a string field at a particular column
bool SetItem(long index, int col, const wxString& label, int imageId = -1);
// Gets the item state
int GetItemState(long item, long stateMask) const;
// Sets the item state
bool SetItemState(long item, long state, long stateMask);
// Sets the item image
bool SetItemImage(long item, int image, int selImage = -1);
bool SetItemColumnImage(long item, long column, int image);
// Gets the item text
wxString GetItemText(long item, int col = 0) const;
// Sets the item text
void SetItemText(long item, const wxString& str);
// Gets the item data
wxUIntPtr GetItemData(long item) const;
// Sets the item data
bool SetItemPtrData(long item, wxUIntPtr data);
bool SetItemData(long item, long data) { return SetItemPtrData(item, data); }
// Gets the item rectangle
bool GetItemRect(long item, wxRect& rect, int code = wxLIST_RECT_BOUNDS) const;
// Gets the subitem rectangle in report mode
bool GetSubItemRect(long item, long subItem, wxRect& rect, int code = wxLIST_RECT_BOUNDS) const;
// Gets the item position
bool GetItemPosition(long item, wxPoint& pos) const;
// Sets the item position
bool SetItemPosition(long item, const wxPoint& pos);
// Gets the number of items in the list control
int GetItemCount() const;
// Gets the number of columns in the list control
int GetColumnCount() const wxOVERRIDE { return m_colCount; }
// get the horizontal and vertical components of the item spacing
wxSize GetItemSpacing() const;
// Foreground colour of an item.
void SetItemTextColour( long item, const wxColour& col);
wxColour GetItemTextColour( long item ) const;
// Background colour of an item.
void SetItemBackgroundColour( long item, const wxColour &col);
wxColour GetItemBackgroundColour( long item ) const;
// Font of an item.
void SetItemFont( long item, const wxFont &f);
wxFont GetItemFont( long item ) const;
// Checkbox state of an item
virtual bool HasCheckBoxes() const wxOVERRIDE;
virtual bool EnableCheckBoxes(bool enable = true) wxOVERRIDE;
virtual bool IsItemChecked(long item) const wxOVERRIDE;
virtual void CheckItem(long item, bool check) wxOVERRIDE;
// Gets the number of selected items in the list control
int GetSelectedItemCount() const;
// Gets the text colour of the listview
wxColour GetTextColour() const;
// Sets the text colour of the listview
void SetTextColour(const wxColour& col);
// Gets the index of the topmost visible item when in
// list or report view
long GetTopItem() const;
// Add or remove a single window style
void SetSingleStyle(long style, bool add = true);
// Set the whole window style
void SetWindowStyleFlag(long style) wxOVERRIDE;
// Searches for an item, starting from 'item'.
// item can be -1 to find the first item that matches the
// specified flags.
// Returns the item or -1 if unsuccessful.
long GetNextItem(long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE) const;
// Gets one of the three image lists
wxImageList *GetImageList(int which) const wxOVERRIDE;
// Sets the image list
void SetImageList(wxImageList *imageList, int which) wxOVERRIDE;
void AssignImageList(wxImageList *imageList, int which) wxOVERRIDE;
// refresh items selectively (only useful for virtual list controls)
void RefreshItem(long item);
void RefreshItems(long itemFrom, long itemTo);
// Operations
////////////////////////////////////////////////////////////////////////////
// Arranges the items
bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
// Deletes an item
bool DeleteItem(long item);
// Deletes all items
bool DeleteAllItems();
// Deletes a column
bool DeleteColumn(int col) wxOVERRIDE;
// Deletes all columns
bool DeleteAllColumns() wxOVERRIDE;
// Clears items, and columns if there are any.
void ClearAll();
// Edit the label
wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
// Ensures this item is visible
bool EnsureVisible(long item);
// Find an item whose label matches this string, starting from the item after 'start'
// or the beginning if 'start' is -1.
long FindItem(long start, const wxString& str, bool partial = false);
// Find an item whose data matches this data, starting from the item after 'start'
// or the beginning if 'start' is -1.
long FindItem(long start, wxUIntPtr data);
// Find an item nearest this position in the specified direction, starting from
// the item after 'start' or the beginning if 'start' is -1.
long FindItem(long start, const wxPoint& pt, int direction);
// Determines which item (if any) is at the specified point,
// giving details in 'flags' (see wxLIST_HITTEST_... flags above)
// Request the subitem number as well at the given coordinate.
long HitTest(const wxPoint& point, int& flags, long* ptrSubItem = NULL) const;
// Inserts an item, returning the index of the new item if successful,
// -1 otherwise.
long InsertItem(const wxListItem& info);
// Insert a string item
long InsertItem(long index, const wxString& label);
// Insert an image item
long InsertItem(long index, int imageIndex);
// Insert an image/string item
long InsertItem(long index, const wxString& label, int imageIndex);
// set the number of items in a virtual list control
void SetItemCount(long count);
// Scrolls the list control. If in icon, small icon or report view mode,
// x specifies the number of pixels to scroll. If in list view mode, x
// specifies the number of columns to scroll.
// If in icon, small icon or list view mode, y specifies the number of pixels
// to scroll. If in report view mode, y specifies the number of lines to scroll.
bool ScrollList(int dx, int dy);
// Sort items.
// fn is a function which takes 3 long arguments: item1, item2, data.
// item1 is the long data associated with a first item (NOT the index).
// item2 is the long data associated with a second item (NOT the index).
// data is the same value as passed to SortItems.
// The return value is a negative number if the first item should precede the second
// item, a positive number of the second item should precede the first,
// or zero if the two items are equivalent.
// data is arbitrary data to be passed to the sort function.
bool SortItems(wxListCtrlCompare fn, wxIntPtr data);
// IMPLEMENTATION
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWShouldPreProcessMessage(WXMSG* msg) wxOVERRIDE;
#if WXWIN_COMPATIBILITY_3_0
// bring the control in sync with current m_windowStyle value
wxDEPRECATED_MSG("useless and will be removed in the future, use SetWindowStyleFlag() instead")
void UpdateStyle();
#endif // WXWIN_COMPATIBILITY_3_0
// Event handlers
////////////////////////////////////////////////////////////////////////////
// Necessary for drawing hrules and vrules, if specified
void OnPaint(wxPaintEvent& event);
virtual bool ShouldInheritColours() const wxOVERRIDE { return false; }
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// convert our styles to Windows
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// special Windows message handling
virtual WXLRESULT MSWWindowProc(WXUINT nMsg,
WXWPARAM wParam,
WXLPARAM lParam) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
virtual bool MSWShouldSetDefaultFont() const wxOVERRIDE { return false; }
// Implement constrained best size calculation.
virtual int DoGetBestClientHeight(int width) const wxOVERRIDE
{ return MSWGetBestViewRect(width, -1).y; }
virtual int DoGetBestClientWidth(int height) const wxOVERRIDE
{ return MSWGetBestViewRect(-1, height).x; }
wxSize MSWGetBestViewRect(int x, int y) const;
// Implement base class pure virtual methods.
long DoInsertColumn(long col, const wxListItem& info) wxOVERRIDE;
// free memory taken by all internal data
void FreeAllInternalData();
// get the internal data object for this item (may return NULL)
wxMSWListItemData *MSWGetItemData(long item) const;
// get the item attribute, either by quering it for virtual control, or by
// returning the one previously set using setter methods for a normal one
wxItemAttr *DoGetItemColumnAttr(long item, long column) const;
wxTextCtrl* m_textCtrl; // The control used for editing a label
wxImageList * m_imageListNormal; // The image list for normal icons
wxImageList * m_imageListSmall; // The image list for small icons
wxImageList * m_imageListState; // The image list state icons (not implemented yet)
bool m_ownsImageListNormal,
m_ownsImageListSmall,
m_ownsImageListState;
int m_colCount; // Windows doesn't have GetColumnCount so must
// keep track of inserted/deleted columns
// all wxMSWListItemData objects we use
wxVector<wxMSWListItemData *> m_internalData;
// true if we have any items with custom attributes
bool m_hasAnyAttr;
// these functions are only used for virtual list view controls, i.e. the
// ones with wxLC_VIRTUAL style
// return the text for the given column of the given item
virtual wxString OnGetItemText(long item, long column) const;
// return the icon for the given item. In report view, OnGetItemImage will
// only be called for the first column. See OnGetItemColumnImage for
// details.
virtual int OnGetItemImage(long item) const;
// return the icon for the given item and column.
virtual int OnGetItemColumnImage(long item, long column) const;
// return the attribute for the given item and column (may return NULL if none)
virtual wxItemAttr *OnGetItemColumnAttr(long item, long WXUNUSED(column)) const
{
return OnGetItemAttr(item);
}
private:
// process NM_CUSTOMDRAW notification message
WXLPARAM OnCustomDraw(WXLPARAM lParam);
// set the extended styles for the control (used by Create() and
// UpdateStyle()), only should be called if InReportView()
void MSWSetExListStyles();
// initialize the (already created) m_textCtrl with the associated HWND
void InitEditControl(WXHWND hWnd);
// destroy m_textCtrl if it's currently valid and reset it to NULL
void DeleteEditControl();
// Intercept Escape and Enter keys to avoid them being stolen from our
// in-place editor control.
void OnCharHook(wxKeyEvent& event);
// Object using for header custom drawing if necessary, may be NULL.
wxMSWListHeaderCustomDraw* m_headerCustomDraw;
wxDECLARE_DYNAMIC_CLASS(wxListCtrl);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxListCtrl);
};
#endif // _WX_LISTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/progdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/progdlg.h
// Purpose: wxProgressDialog
// Author: Rickard Westerlund
// Created: 2010-07-22
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PROGDLG_H_
#define _WX_PROGDLG_H_
class wxProgressDialogTaskRunner;
class wxProgressDialogSharedData;
class WXDLLIMPEXP_CORE wxProgressDialog : public wxGenericProgressDialog
{
public:
wxProgressDialog(const wxString& title, const wxString& message,
int maximum = 100,
wxWindow *parent = NULL,
int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE);
virtual ~wxProgressDialog();
virtual bool Update(int value, const wxString& newmsg = wxEmptyString, bool *skip = NULL) wxOVERRIDE;
virtual bool Pulse(const wxString& newmsg = wxEmptyString, bool *skip = NULL) wxOVERRIDE;
virtual void Resume() wxOVERRIDE;
virtual int GetValue() const wxOVERRIDE;
virtual wxString GetMessage() const wxOVERRIDE;
virtual void SetRange(int maximum) wxOVERRIDE;
// Return whether "Cancel" or "Skip" button was pressed, always return
// false if the corresponding button is not shown.
virtual bool WasSkipped() const wxOVERRIDE;
virtual bool WasCancelled() const wxOVERRIDE;
virtual void SetTitle(const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
virtual void SetIcons(const wxIconBundle& icons) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void Fit() wxOVERRIDE;
virtual bool Show( bool show = true ) wxOVERRIDE;
// Must provide overload to avoid hiding it (and warnings about it)
virtual void Update() wxOVERRIDE { wxGenericProgressDialog::Update(); }
virtual WXWidget GetHandle() const wxOVERRIDE;
private:
// Common part of Update() and Pulse().
//
// Returns false if the user requested cancelling the dialog.
bool DoNativeBeforeUpdate(bool *skip);
// Dispatch the pending events to let the windows to update, just as the
// generic version does. This is done as part of DoNativeBeforeUpdate().
void DispatchEvents();
// Updates the various timing informations for both determinate
// and indeterminate modes. Requires the shared object to have
// been entered.
void UpdateExpandedInformation(int value);
// Get the task dialog geometry when using the native dialog.
wxRect GetTaskDialogRect() const;
wxProgressDialogTaskRunner *m_taskDialogRunner;
wxProgressDialogSharedData *m_sharedData;
// Store the message and title we currently use to be able to return it
// from Get{Message,Title}()
wxString m_message,
m_title;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxProgressDialog);
};
#endif // _WX_PROGDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/font.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/font.h
// Purpose: wxFont class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONT_H_
#define _WX_FONT_H_
#include "wx/gdicmn.h"
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFont : public wxFontBase
{
public:
// ctors and such
wxFont() { }
wxFont(const wxFontInfo& info);
wxFont(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(size, family, style, weight, underlined, face, encoding);
}
bool Create(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
return DoCreate(InfoFromLegacyParams(size,
family,
style,
weight,
underlined,
face,
encoding));
}
wxFont(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(pixelSize, family, style, weight,
underlined, face, encoding);
}
wxFont(const wxNativeFontInfo& info, WXHFONT hFont = 0)
{
Create(info, hFont);
}
wxFont(const wxString& fontDesc);
bool Create(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
return DoCreate(InfoFromLegacyParams(pixelSize,
family,
style,
weight,
underlined,
face,
encoding));
}
bool Create(const wxNativeFontInfo& info, WXHFONT hFont = 0);
virtual ~wxFont();
// implement base class pure virtuals
virtual float GetFractionalPointSize() const wxOVERRIDE;
virtual wxSize GetPixelSize() const wxOVERRIDE;
virtual bool IsUsingSizeInPixels() const wxOVERRIDE;
virtual wxFontStyle GetStyle() const wxOVERRIDE;
virtual int GetNumericWeight() const wxOVERRIDE;
virtual bool GetUnderlined() const wxOVERRIDE;
virtual bool GetStrikethrough() const wxOVERRIDE;
virtual wxString GetFaceName() const wxOVERRIDE;
virtual wxFontEncoding GetEncoding() const wxOVERRIDE;
virtual const wxNativeFontInfo *GetNativeFontInfo() const wxOVERRIDE;
virtual void SetFractionalPointSize(float pointSize) wxOVERRIDE;
virtual void SetPixelSize(const wxSize& pixelSize) wxOVERRIDE;
virtual void SetFamily(wxFontFamily family) wxOVERRIDE;
virtual void SetStyle(wxFontStyle style) wxOVERRIDE;
virtual void SetNumericWeight(int weight) wxOVERRIDE;
virtual bool SetFaceName(const wxString& faceName) wxOVERRIDE;
virtual void SetUnderlined(bool underlined) wxOVERRIDE;
virtual void SetStrikethrough(bool strikethrough) wxOVERRIDE;
virtual void SetEncoding(wxFontEncoding encoding) wxOVERRIDE;
wxDECLARE_COMMON_FONT_METHODS();
virtual bool IsFixedWidth() const wxOVERRIDE;
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants ie: wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD")
wxFont(int size,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(size, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight, underlined, face, encoding);
}
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants ie: wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD")
wxFont(const wxSize& pixelSize,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(pixelSize, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight,
underlined, face, encoding);
}
// implementation only from now on
// -------------------------------
virtual bool IsFree() const wxOVERRIDE;
virtual bool RealizeResource() wxOVERRIDE;
virtual WXHANDLE GetResourceHandle() const wxOVERRIDE;
virtual bool FreeResource(bool force = false) wxOVERRIDE;
// for consistency with other wxMSW classes
WXHFONT GetHFONT() const;
protected:
// Common helper of overloaded Create() methods.
bool DoCreate(const wxFontInfo& info);
virtual void DoSetNativeFontInfo(const wxNativeFontInfo& info) wxOVERRIDE;
virtual wxFontFamily DoGetFamily() const wxOVERRIDE;
// implement wxObject virtuals which are used by AllocExclusive()
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxFont);
};
#endif // _WX_FONT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/evtloopconsole.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/evtloopconsole.h
// Purpose: wxConsoleEventLoop class for Windows
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-07-31
// Copyright: (c) 2003-2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_EVTLOOPCONSOLE_H_
#define _WX_MSW_EVTLOOPCONSOLE_H_
class WXDLLIMPEXP_BASE wxMSWEventLoopBase : public wxEventLoopManual
{
public:
wxMSWEventLoopBase();
virtual ~wxMSWEventLoopBase();
// implement base class pure virtuals
virtual bool Pending() const wxOVERRIDE;
virtual void WakeUp() wxOVERRIDE;
#if wxUSE_THREADS
// MSW-specific method to wait for the termination of the specified (by its
// native handle) thread or any input message arriving (in GUI case).
//
// Return value is WAIT_OBJECT_0 if the thread terminated, WAIT_OBJECT_0+1
// if a message arrived with anything else indicating an error.
WXDWORD MSWWaitForThread(WXHANDLE hThread);
#endif // wxUSE_THREADS
// Return true if wake up was requested and not handled yet, i.e. if
// m_heventWake is signaled.
bool MSWIsWakeUpRequested();
protected:
// get the next message from queue and return true or return false if we
// got WM_QUIT or an error occurred
bool GetNextMessage(WXMSG *msg);
// same as above but with a timeout and return value can be -1 meaning that
// time out expired in addition to true/false
int GetNextMessageTimeout(WXMSG *msg, unsigned long timeout);
private:
// An auto-reset Win32 event which is signalled when we need to wake up the
// main thread waiting in GetNextMessage[Timeout]().
WXHANDLE m_heventWake;
};
#if wxUSE_CONSOLE_EVENTLOOP
class WXDLLIMPEXP_BASE wxConsoleEventLoop : public wxMSWEventLoopBase
{
public:
wxConsoleEventLoop() { }
// override/implement base class virtuals
virtual bool Dispatch() wxOVERRIDE;
virtual int DispatchTimeout(unsigned long timeout) wxOVERRIDE;
// Windows-specific function to process a single message
virtual void ProcessMessage(WXMSG *msg);
protected:
virtual void DoYieldFor(long eventsToProcess) wxOVERRIDE;
};
#endif // wxUSE_CONSOLE_EVENTLOOP
#endif // _WX_MSW_EVTLOOPCONSOLE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/nonownedwnd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/nonownedwnd.h
// Purpose: wxNonOwnedWindow declaration for wxMSW.
// Author: Vadim Zeitlin
// Created: 2011-10-09
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_NONOWNEDWND_H_
#define _WX_MSW_NONOWNEDWND_H_
class wxNonOwnedWindowShapeImpl;
// ----------------------------------------------------------------------------
// wxNonOwnedWindow
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNonOwnedWindow : public wxNonOwnedWindowBase
{
public:
wxNonOwnedWindow();
virtual ~wxNonOwnedWindow();
protected:
virtual bool DoClearShape() wxOVERRIDE;
virtual bool DoSetRegionShape(const wxRegion& region) wxOVERRIDE;
#if wxUSE_GRAPHICS_CONTEXT
virtual bool DoSetPathShape(const wxGraphicsPath& path) wxOVERRIDE;
private:
wxNonOwnedWindowShapeImpl* m_shapeImpl;
#endif // wxUSE_GRAPHICS_CONTEXT
wxDECLARE_NO_COPY_CLASS(wxNonOwnedWindow);
};
#endif // _WX_MSW_NONOWNEDWND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/app.h
// Purpose: wxApp class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_APP_H_
#define _WX_APP_H_
#include "wx/event.h"
#include "wx/icon.h"
class WXDLLIMPEXP_FWD_CORE wxFrame;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxApp;
class WXDLLIMPEXP_FWD_CORE wxKeyEvent;
class WXDLLIMPEXP_FWD_BASE wxLog;
// Represents the application. Derive OnInit and declare
// a new App object to start application
class WXDLLIMPEXP_CORE wxApp : public wxAppBase
{
public:
wxApp();
virtual ~wxApp();
// override base class (pure) virtuals
virtual bool Initialize(int& argc, wxChar **argv) wxOVERRIDE;
virtual void CleanUp() wxOVERRIDE;
virtual void WakeUpIdle() wxOVERRIDE;
virtual void SetPrintMode(int mode) wxOVERRIDE { m_printMode = mode; }
virtual int GetPrintMode() const { return m_printMode; }
// implementation only
void OnIdle(wxIdleEvent& event);
void OnEndSession(wxCloseEvent& event);
void OnQueryEndSession(wxCloseEvent& event);
#if wxUSE_EXCEPTIONS
virtual bool OnExceptionInMainLoop() wxOVERRIDE;
#endif // wxUSE_EXCEPTIONS
// MSW-specific from now on
// ------------------------
// this suffix should be appended to all our Win32 class names to obtain a
// variant registered without CS_[HV]REDRAW styles
static const wxChar *GetNoRedrawClassSuffix() { return wxT("NR"); }
// Flags for GetRegisteredClassName()
enum
{
// Just a symbolic name indicating absence of any special flags.
RegClass_Default = 0,
// Return the name with the GetNoRedrawClassSuffix() appended to it.
RegClass_ReturnNR = 1,
// Don't register the class with CS_[HV]REDRAW styles. This is useful
// for internal windows for which we can guarantee that they will be
// never created with wxFULL_REPAINT_ON_RESIZE flag.
//
// Notice that this implies RegClass_ReturnNR.
RegClass_OnlyNR = 3
};
// get the name of the registered Win32 class with the given (unique) base
// name: this function constructs the unique class name using this name as
// prefix, checks if the class is already registered and registers it if it
// isn't and returns the name it was registered under (or NULL if it failed)
//
// the registered class will always have CS_[HV]REDRAW and CS_DBLCLKS
// styles as well as any additional styles specified as arguments here; and
// there will be also a companion registered class identical to this one
// but without CS_[HV]REDRAW whose name will be the same one but with
// GetNoRedrawClassSuffix()
//
// the background brush argument must be either a COLOR_XXX standard value
// or (default) -1 meaning that the class paints its background itself
static const wxChar *GetRegisteredClassName(const wxChar *name,
int bgBrushCol = -1,
int extraStyles = 0,
int flags = RegClass_Default);
// return true if this name corresponds to one of the classes we registered
// in the previous GetRegisteredClassName() calls
static bool IsRegisteredClassName(const wxString& name);
// Return the layout direction to use for a window by default.
//
// If the parent is specified, use the same layout direction as it uses.
// Otherwise use the default global layout, either from wxTheApp, if it
// exists, or Windows itself.
//
// Notice that this normally should not be used for the child windows as
// they already inherit, just dialogs such as wxMessageDialog may want to
// use it.
static wxLayoutDirection MSWGetDefaultLayout(wxWindow* parent = NULL);
// Call ProcessPendingEvents() but only if we need to do it, i.e. there was
// a recent call to WakeUpIdle().
void MSWProcessPendingEventsIfNeeded();
protected:
int m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
public:
// unregister any window classes registered by GetRegisteredClassName()
static void UnregisterWindowClasses();
#if wxUSE_RICHEDIT
// initialize the richedit DLL of (at least) given version, return true if
// ok
static bool InitRichEdit(int version = 2);
#endif // wxUSE_RICHEDIT
// returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
// wasn't found at all
static int GetComCtl32Version();
// the SW_XXX value to be used for the frames opened by the application
// (currently seems unused which is a bug -- TODO)
static int m_nCmdShow;
protected:
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxApp);
wxDECLARE_DYNAMIC_CLASS(wxApp);
};
#endif // _WX_APP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/combo.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/combo.h
// Purpose: wxComboCtrl class
// Author: Jaakko Salli
// Modified by:
// Created: Apr-30-2006
// Copyright: (c) Jaakko Salli
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COMBOCONTROL_H_
#define _WX_COMBOCONTROL_H_
// NB: Definition of _WX_COMBOCONTROL_H_ is used in wx/generic/combo.h to
// determine whether there is native wxComboCtrl, so make sure you
// use it in all native wxComboCtrls.
#if wxUSE_COMBOCTRL
#if wxUSE_TIMER
#include "wx/timer.h"
#define wxUSE_COMBOCTRL_POPUP_ANIMATION 1
#endif
// ----------------------------------------------------------------------------
// Native wxComboCtrl
// ----------------------------------------------------------------------------
// Define this only if native implementation includes all features
#define wxCOMBOCONTROL_FULLY_FEATURED
extern WXDLLIMPEXP_DATA_CORE(const char) wxComboBoxNameStr[];
class WXDLLIMPEXP_CORE wxComboCtrl : public wxComboCtrlBase
{
public:
// ctors and such
wxComboCtrl() : wxComboCtrlBase() { Init(); }
wxComboCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
: wxComboCtrlBase()
{
Init();
(void)Create(parent, id, value, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
virtual ~wxComboCtrl();
virtual void PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const wxOVERRIDE;
virtual bool IsKeyPopupToggle(const wxKeyEvent& event) const wxOVERRIDE;
static int GetFeatures() { return wxComboCtrlFeatures::All; }
#if wxUSE_COMBOCTRL_POPUP_ANIMATION
void OnTimerEvent(wxTimerEvent& WXUNUSED(event)) { DoTimerEvent(); }
protected:
void DoTimerEvent();
virtual bool AnimateShow( const wxRect& rect, int flags ) wxOVERRIDE;
#endif // wxUSE_COMBOCTRL_POPUP_ANIMATION
protected:
// Dummy method - we override all functions that call this
virtual WXHWND GetEditHWND() const wxOVERRIDE { return NULL; }
// customization
virtual void OnResize() wxOVERRIDE;
virtual wxCoord GetNativeTextIndent() const wxOVERRIDE;
// event handlers
void OnPaintEvent( wxPaintEvent& event );
void OnMouseEvent( wxMouseEvent& event );
virtual bool HasTransparentBackground() wxOVERRIDE { return IsDoubleBuffered(); }
private:
void Init();
#if wxUSE_COMBOCTRL_POPUP_ANIMATION
// Popup animation related
wxMilliClock_t m_animStart;
wxTimer m_animTimer;
wxRect m_animRect;
int m_animFlags;
#endif
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxComboCtrl);
};
#endif // wxUSE_COMBOCTRL
#endif
// _WX_COMBOCONTROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/dcmemory.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dcmemory.h
// Purpose: wxMemoryDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCMEMORY_H_
#define _WX_DCMEMORY_H_
#include "wx/dcmemory.h"
#include "wx/msw/dc.h"
class WXDLLIMPEXP_CORE wxMemoryDCImpl: public wxMSWDCImpl
{
public:
wxMemoryDCImpl( wxMemoryDC *owner );
wxMemoryDCImpl( wxMemoryDC *owner, wxBitmap& bitmap );
wxMemoryDCImpl( wxMemoryDC *owner, wxDC *dc ); // Create compatible DC
// override some base class virtuals
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) wxOVERRIDE;
virtual void DoGetSize(int* width, int* height) const wxOVERRIDE;
virtual void DoSelect(const wxBitmap& bitmap) wxOVERRIDE;
virtual wxBitmap DoGetAsBitmap(const wxRect* subrect) const wxOVERRIDE
{ return subrect == NULL ? GetSelectedBitmap() : GetSelectedBitmap().GetSubBitmapOfHDC(*subrect, GetHDC() );}
protected:
// create DC compatible with the given one or screen if dc == NULL
bool CreateCompatible(wxDC *dc);
// initialize the newly created DC
void Init();
wxDECLARE_CLASS(wxMemoryDCImpl);
wxDECLARE_NO_COPY_CLASS(wxMemoryDCImpl);
};
#endif
// _WX_DCMEMORY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/anybutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/anybutton.h
// Purpose: wxAnyButton class
// Author: Julian Smart
// Created: 1997-02-01 (extracted from button.h)
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_ANYBUTTON_H_
#define _WX_MSW_ANYBUTTON_H_
// ----------------------------------------------------------------------------
// Common button functionality
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAnyButton : public wxAnyButtonBase
{
public:
wxAnyButton()
{
m_imageData = NULL;
#if wxUSE_MARKUP
m_markupText = NULL;
#endif // wxUSE_MARKUP
}
virtual ~wxAnyButton();
// overridden base class methods
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour &colour) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour &colour) wxOVERRIDE;
// implementation from now on
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
// usually overridden base class virtuals
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxBitmap DoGetBitmap(State which) const wxOVERRIDE;
virtual void DoSetBitmap(const wxBitmap& bitmap, State which) wxOVERRIDE;
virtual wxSize DoGetBitmapMargins() const wxOVERRIDE;
virtual void DoSetBitmapMargins(wxCoord x, wxCoord y) wxOVERRIDE;
virtual void DoSetBitmapPosition(wxDirection dir) wxOVERRIDE;
#if wxUSE_MARKUP
virtual bool DoSetLabelMarkup(const wxString& markup) wxOVERRIDE;
#endif // wxUSE_MARKUP
// Increases the passed in size to account for the button image.
//
// Should only be called if we do have a button, i.e. if m_imageData is
// non-NULL.
void AdjustForBitmapSize(wxSize& size) const;
class wxButtonImageData *m_imageData;
#if wxUSE_MARKUP
class wxMarkupText *m_markupText;
#endif // wxUSE_MARKUP
// Switches button into owner-drawn mode: this is used if we need to draw
// something not supported by the native control, such as using non default
// colours or a bitmap on pre-XP systems.
void MakeOwnerDrawn();
bool IsOwnerDrawn() const;
virtual bool MSWIsPushed() const;
private:
wxDECLARE_NO_COPY_CLASS(wxAnyButton);
};
#endif // _WX_MSW_ANYBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/toplevel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/toplevel.h
// Purpose: wxTopLevelWindowMSW is the MSW implementation of wxTLW
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.09.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TOPLEVEL_H_
#define _WX_MSW_TOPLEVEL_H_
#include "wx/weakref.h"
// ----------------------------------------------------------------------------
// wxTopLevelWindowMSW
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindowMSW : public wxTopLevelWindowBase
{
public:
// constructors and such
wxTopLevelWindowMSW() { Init(); }
wxTopLevelWindowMSW(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, style, name);
}
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 ~wxTopLevelWindowMSW();
// implement base class pure virtuals
virtual void SetTitle( const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
virtual void Maximize(bool maximize = true) wxOVERRIDE;
virtual bool IsMaximized() const wxOVERRIDE;
virtual void Iconize(bool iconize = true) wxOVERRIDE;
virtual bool IsIconized() const wxOVERRIDE;
virtual void SetIcons(const wxIconBundle& icons ) wxOVERRIDE;
virtual void Restore() wxOVERRIDE;
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual void Raise() wxOVERRIDE;
virtual void ShowWithoutActivating() wxOVERRIDE;
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) wxOVERRIDE;
virtual bool IsFullScreen() const wxOVERRIDE { return m_fsIsShowing; }
// wxMSW only: EnableCloseButton(false) may be used to remove the "Close"
// button from the title bar
virtual bool EnableCloseButton(bool enable = true) wxOVERRIDE;
virtual bool EnableMaximizeButton(bool enable = true) wxOVERRIDE;
virtual bool EnableMinimizeButton(bool enable = true) wxOVERRIDE;
// Set window transparency if the platform supports it
virtual bool SetTransparent(wxByte alpha) wxOVERRIDE;
virtual bool CanSetTransparent() wxOVERRIDE;
// MSW-specific methods
// --------------------
// Return the menu representing the "system" menu of the window. You can
// call wxMenu::AppendWhatever() methods on it but removing items from it
// is in general not a good idea.
//
// The pointer returned by this method belongs to the window and will be
// deleted when the window itself is, do not delete it yourself. May return
// NULL if getting the system menu failed.
wxMenu *MSWGetSystemMenu() const;
// Enable or disable the close button of the specified window.
static bool MSWEnableCloseButton(WXHWND hwnd, bool enable = true);
// implementation from now on
// --------------------------
// event handlers
void OnActivate(wxActivateEvent& event);
// called by wxWindow whenever it gets focus
void SetLastFocus(wxWindow *win) { m_winLastFocused = win; }
wxWindow *GetLastFocus() const { return m_winLastFocused; }
// translate wxWidgets flags to Windows ones
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle) const wxOVERRIDE;
// choose the right parent to use with CreateWindow()
virtual WXHWND MSWGetParent() const wxOVERRIDE;
// window proc for the frames
WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
// This function is only for internal use.
void MSWSetShowCommand(WXUINT showCmd) { m_showCmd = showCmd; }
protected:
// common part of all ctors
void Init();
// create a new frame, return false if it couldn't be created
bool CreateFrame(const wxString& title,
const wxPoint& pos,
const wxSize& size);
// create a new dialog using the given dialog template from resources,
// return false if it couldn't be created
bool CreateDialog(const void *dlgTemplate,
const wxString& title,
const wxPoint& pos,
const wxSize& size);
// Just a wrapper around MSW ShowWindow().
void DoShowWindow(int nShowCmd);
// Return true if the window is iconized at MSW level, ignoring m_showCmd.
bool MSWIsIconized() const;
// override those to return the normal window coordinates even when the
// window is minimized
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
// Top level windows have different freeze semantics on Windows
virtual void DoFreeze() wxOVERRIDE;
virtual void DoThaw() wxOVERRIDE;
// helper of SetIcons(): calls gets the icon with the size specified by the
// given system metrics (SM_C{X|Y}[SM]ICON) from the bundle and sets it
// using WM_SETICON with the specified wParam (ICOM_SMALL or ICON_BIG);
// returns true if the icon was set
bool DoSelectAndSetIcon(const wxIconBundle& icons, int smX, int smY, int i);
// override wxWindow virtual method to use CW_USEDEFAULT if necessary
virtual void MSWGetCreateWindowCoords(const wxPoint& pos,
const wxSize& size,
int& x, int& y,
int& w, int& h) const wxOVERRIDE;
// This field contains the show command to use when showing the window the
// next time and also indicates whether the window should be considered
// being iconized or maximized (which may be different from whether it's
// actually iconized or maximized at MSW level).
WXUINT m_showCmd;
// Data to save/restore when calling ShowFullScreen
long m_fsStyle; // Passed to ShowFullScreen
wxRect m_fsOldSize;
long m_fsOldWindowStyle;
bool m_fsIsMaximized;
bool m_fsIsShowing;
// Save the current focus to m_winLastFocused if we're not iconized (the
// focus is always NULL when we're iconized).
void DoSaveLastFocus();
// Restore focus to m_winLastFocused if possible and needed.
void DoRestoreLastFocus();
// The last focused child: we remember it when we're deactivated and
// restore focus to it when we're activated (this is done here) or restored
// from iconic state (done by wxFrame).
wxWindowRef m_winLastFocused;
private:
// The system menu: initially NULL but can be set (once) by
// MSWGetSystemMenu(). Owned by this window.
wxMenu *m_menuSystem;
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxTopLevelWindowMSW);
};
#endif // _WX_MSW_TOPLEVEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/sound.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/sound.h
// Purpose: wxSound class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SOUND_H_
#define _WX_SOUND_H_
#if wxUSE_SOUND
class WXDLLIMPEXP_ADV wxSound : public wxSoundBase
{
public:
wxSound();
wxSound(const wxString& fileName, bool isResource = false);
wxSound(size_t size, const void* data);
virtual ~wxSound();
// Create from resource or file
bool Create(const wxString& fileName, bool isResource = false);
// Create from data
bool Create(size_t size, const void* data);
bool IsOk() const { return m_data != NULL; }
static void Stop();
protected:
void Init() { m_data = NULL; }
bool CheckCreatedOk();
void Free();
virtual bool DoPlay(unsigned flags) const wxOVERRIDE;
private:
// data of this object
class wxSoundData *m_data;
wxDECLARE_NO_COPY_CLASS(wxSound);
};
#endif // wxUSE_SOUND
#endif // _WX_SOUND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/tooltip.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/tooltip.h
// Purpose: wxToolTip class - tooltip control
// Author: Vadim Zeitlin
// Modified by:
// Created: 31.01.99
// Copyright: (c) 1999 Robert Roebling, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TOOLTIP_H_
#define _WX_MSW_TOOLTIP_H_
#include "wx/object.h"
#include "wx/gdicmn.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
class wxToolTipOtherWindows;
class WXDLLIMPEXP_CORE wxToolTip : public wxObject
{
public:
// ctor & dtor
wxToolTip(const wxString &tip);
virtual ~wxToolTip();
// ctor used by wxStatusBar to associate a tooltip to a portion of
// the status bar window:
wxToolTip(wxWindow* win, unsigned int id,
const wxString &tip, const wxRect& rc);
// accessors
// tip text
void SetTip(const wxString& tip);
const wxString& GetTip() const { return m_text; }
// the window we're associated with
void SetWindow(wxWindow *win);
wxWindow *GetWindow() const { return m_window; }
// controlling tooltip behaviour: globally change tooltip parameters
// enable or disable the tooltips globally
static void Enable(bool flag);
// set the delay after which the tooltip appears
static void SetDelay(long milliseconds);
// set the delay after which the tooltip disappears or how long the
// tooltip remains visible
static void SetAutoPop(long milliseconds);
// set the delay between subsequent tooltips to appear
static void SetReshow(long milliseconds);
// set maximum width for the new tooltips: -1 disables wrapping
// entirely, 0 restores the default behaviour
static void SetMaxWidth(int width);
// implementation only from now on
// -------------------------------
// should be called in response to WM_MOUSEMOVE
static void RelayEvent(WXMSG *msg);
// add a window to the tooltip control
void AddOtherWindow(WXHWND hwnd);
// remove any tooltip from the window
static void Remove(WXHWND hwnd, unsigned int id, const wxRect& rc);
// Set the rectangle we're associated with. This rectangle is only used for
// the main window, not any sub-windows added with Add() so in general it
// makes sense to use it for tooltips associated with a single window only.
void SetRect(const wxRect& rc);
// Called when TLW shown state is changed and hides the tooltip itself if
// the window it's associated with is hidden.
static void UpdateVisibility();
private:
// This module calls our DeleteToolTipCtrl().
friend class wxToolTipModule;
// Adds a window other than our main m_window to this tooltip.
void DoAddHWND(WXHWND hWnd);
// Perform the specified operation for the given window only.
void DoSetTip(WXHWND hWnd);
void DoRemove(WXHWND hWnd);
// Call the given function for all windows we're associated with.
void DoForAllWindows(void (wxToolTip::*func)(WXHWND));
// the one and only one tooltip control we use - never access it directly
// but use GetToolTipCtrl() which will create it when needed
static WXHWND ms_hwndTT;
// create the tooltip ctrl if it doesn't exist yet and return its HWND
static WXHWND GetToolTipCtrl();
// to be used in wxModule for deleting tooltip ctrl window when exiting mainloop
static void DeleteToolTipCtrl();
// new tooltip maximum width, defaults to min(display width, 400)
static int ms_maxWidth;
// remove this tooltip from the tooltip control
void Remove();
// adjust tooltip max width based on current tooltip text
bool AdjustMaxWidth();
wxString m_text; // tooltip text
wxWindow* m_window; // main window we're associated with
wxToolTipOtherWindows *m_others; // other windows associated with it or NULL
wxRect m_rect; // the rect of the window for which this tooltip is shown
// (or a rect with width/height == 0 to show it for the entire window)
unsigned int m_id; // the id of this tooltip (ignored when m_rect width/height is 0)
wxDECLARE_ABSTRACT_CLASS(wxToolTip);
wxDECLARE_NO_COPY_CLASS(wxToolTip);
};
#endif // _WX_MSW_TOOLTIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/stattext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stattext.h
// Purpose: wxStaticText class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATTEXT_H_
#define _WX_STATTEXT_H_
class WXDLLIMPEXP_CORE wxStaticText : public wxStaticTextBase
{
public:
wxStaticText() { }
wxStaticText(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr);
// override some methods to resize the window properly
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
// implement/override some base class virtuals
virtual void DoSetSize(int x, int y, int w, int h,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual wxString DoGetLabel() const wxOVERRIDE;
virtual void DoSetLabel(const wxString& str) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticText);
};
#endif
// _WX_STATTEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/genrcdefs.h | /*
* Name: wx/msw/genrcdefs.h
* Purpose: Emit preprocessor symbols into rcdefs.h for resource compiler
* Author: Mike Wetherell
* Copyright: (c) 2005 Mike Wetherell
* Licence: wxWindows licence
*/
#define EMIT(line) line
EMIT(#ifndef _WX_RCDEFS_H)
EMIT(#define _WX_RCDEFS_H)
#ifdef _MSC_FULL_VER
#if _MSC_FULL_VER < 140040130
EMIT(#define wxUSE_RC_MANIFEST 1)
#endif
#else
EMIT(#define wxUSE_RC_MANIFEST 1)
#endif
#if defined _M_AMD64 || defined __x86_64__
EMIT(#define WX_CPU_AMD64)
#endif
#ifdef _M_ARM
EMIT(#define WX_CPU_ARM)
#endif
#ifdef _M_ARM64
EMIT(#define WX_CPU_ARM64)
#endif
#if defined _M_IA64 || defined __ia64__
EMIT(#define WX_CPU_IA64)
#endif
#if defined _M_IX86 || defined _X86_
EMIT(#define WX_CPU_X86)
#endif
#ifdef _M_PPC
EMIT(#define WX_CPU_PPC)
#endif
#ifdef _M_SH
EMIT(#define WX_CPU_SH)
#endif
EMIT(#endif)
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/imaglist.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/imaglist.h
// Purpose: wxImageList class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGLIST_H_
#define _WX_IMAGLIST_H_
#include "wx/bitmap.h"
// Eventually we'll make this a reference-counted wxGDIObject. For
// now, the app must take care of ownership issues. That is, the
// image lists must be explicitly deleted after the control(s) that uses them
// is (are) deleted, or when the app exits.
class WXDLLIMPEXP_CORE wxImageList : public wxObject
{
public:
/*
* Public interface
*/
wxImageList();
// Creates an image list.
// Specify the width and height of the images in the list,
// whether there are masks associated with them (e.g. if creating images
// from icons), and the initial size of the list.
wxImageList(int width, int height, bool mask = true, int initialCount = 1)
{
Create(width, height, mask, initialCount);
}
virtual ~wxImageList();
// Attributes
////////////////////////////////////////////////////////////////////////////
// Returns the number of images in the image list.
int GetImageCount() const;
// Returns the size (same for all images) of the images in the list
bool GetSize(int index, int &width, int &height) const;
// Returns the overall size
wxSize GetSize() const { return m_size; }
// Operations
////////////////////////////////////////////////////////////////////////////
// Creates an image list
// width, height specify the size of the images in the list (all the same).
// mask specifies whether the images have masks or not.
// initialNumber is the initial number of images to reserve.
bool Create(int width, int height, bool mask = true, int initialNumber = 1);
// Adds a bitmap, and optionally a mask bitmap.
// Note that wxImageList creates *new* bitmaps, so you may delete
// 'bitmap' and 'mask' after calling Add.
int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
// Adds a bitmap, using the specified colour to create the mask bitmap
// Note that wxImageList creates *new* bitmaps, so you may delete
// 'bitmap' after calling Add.
int Add(const wxBitmap& bitmap, const wxColour& maskColour);
// Adds a bitmap and mask from an icon.
int Add(const wxIcon& icon);
// Replaces a bitmap, optionally passing a mask bitmap.
// Note that wxImageList creates new bitmaps, so you may delete
// 'bitmap' and 'mask' after calling Replace.
bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
// Replaces a bitmap and mask from an icon.
// You can delete 'icon' after calling Replace.
bool Replace(int index, const wxIcon& icon);
// Removes the image at the given index.
bool Remove(int index);
// Remove all images
bool RemoveAll();
// Draws the given image on a dc at the specified position.
// If 'solidBackground' is true, Draw sets the image list background
// colour to the background colour of the wxDC, to speed up
// drawing by eliminating masked drawing where possible.
bool Draw(int index, wxDC& dc, int x, int y,
int flags = wxIMAGELIST_DRAW_NORMAL,
bool solidBackground = false);
// Get a bitmap
wxBitmap GetBitmap(int index) const;
// Get an icon
wxIcon GetIcon(int index) const;
// TODO: miscellaneous functionality
/*
wxIcon *MakeIcon(int index);
bool SetOverlayImage(int index, int overlayMask);
*/
// TODO: Drag-and-drop related functionality.
#if 0
// Creates a new drag image by combining the given image (typically a mouse cursor image)
// with the current drag image.
bool SetDragCursorImage(int index, const wxPoint& hotSpot);
// If successful, returns a pointer to the temporary image list that is used for dragging;
// otherwise, NULL.
// dragPos: receives the current drag position.
// hotSpot: receives the offset of the drag image relative to the drag position.
static wxImageList *GetDragImageList(wxPoint& dragPos, wxPoint& hotSpot);
// Call this function to begin dragging an image. This function creates a temporary image list
// that is used for dragging. The image combines the specified image and its mask with the
// current cursor. In response to subsequent mouse move messages, you can move the drag image
// by using the DragMove member function. To end the drag operation, you can use the EndDrag
// member function.
bool BeginDrag(int index, const wxPoint& hotSpot);
// Ends a drag operation.
bool EndDrag();
// Call this function to move the image that is being dragged during a drag-and-drop operation.
// This function is typically called in response to a mouse move message. To begin a drag
// operation, use the BeginDrag member function.
static bool DragMove(const wxPoint& point);
// During a drag operation, locks updates to the window specified by lockWindow and displays
// the drag image at the position specified by point.
// The coordinates are relative to the window's upper left corner, so you must compensate
// for the widths of window elements, such as the border, title bar, and menu bar, when
// specifying the coordinates.
// If lockWindow is NULL, this function draws the image in the display context associated
// with the desktop window, and coordinates are relative to the upper left corner of the screen.
// This function locks all other updates to the given window during the drag operation.
// If you need to do any drawing during a drag operation, such as highlighting the target
// of a drag-and-drop operation, you can temporarily hide the dragged image by using the
// wxImageList::DragLeave function.
// lockWindow: pointer to the window that owns the drag image.
// point: position at which to display the drag image. Coordinates are relative to the
// upper left corner of the window (not the client area).
static bool DragEnter( wxWindow *lockWindow, const wxPoint& point );
// Unlocks the window specified by pWndLock and hides the drag image, allowing the
// window to be updated.
static bool DragLeave( wxWindow *lockWindow );
/* Here's roughly how you'd use these functions:
1) Starting to drag:
wxImageList *dragImageList = new wxImageList(16, 16, true);
dragImageList->Add(myDragImage); // Provide an image to combine with the current cursor
dragImageList->BeginDrag(0, wxPoint(0, 0));
wxShowCursor(false); // wxShowCursor not yet implemented in wxWin
myWindow->CaptureMouse();
2) Dragging:
// Called within mouse move event. Could also use dragImageList instead of assuming
// these are static functions.
// These two functions could possibly be combined into one, since DragEnter is
// a bit obscure.
wxImageList::DragMove(wxPoint(x, y)); // x, y are current cursor position
wxImageList::DragEnter(NULL, wxPoint(x, y)); // NULL assumes dragging across whole screen
3) Finishing dragging:
dragImageList->EndDrag();
myWindow->ReleaseMouse();
wxShowCursor(true);
*/
#endif
// Implementation
////////////////////////////////////////////////////////////////////////////
// Returns the native image list handle
WXHIMAGELIST GetHIMAGELIST() const { return m_hImageList; }
protected:
WXHIMAGELIST m_hImageList;
wxSize m_size;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxImageList);
};
#endif
// _WX_IMAGLIST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/gdiimage.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/gdiimage.h
// Purpose: wxGDIImage class: base class for wxBitmap, wxIcon, wxCursor
// under MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.11.99
// Copyright: (c) 1999 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// NB: this is a private header, it is not intended to be directly included by
// user code (but may be included from other, public, wxWin headers
#ifndef _WX_MSW_GDIIMAGE_H_
#define _WX_MSW_GDIIMAGE_H_
#include "wx/gdiobj.h" // base class
#include "wx/gdicmn.h" // wxBITMAP_TYPE_INVALID
#include "wx/list.h"
class WXDLLIMPEXP_FWD_CORE wxGDIImageRefData;
class WXDLLIMPEXP_FWD_CORE wxGDIImageHandler;
class WXDLLIMPEXP_FWD_CORE wxGDIImage;
WX_DECLARE_EXPORTED_LIST(wxGDIImageHandler, wxGDIImageHandlerList);
// ----------------------------------------------------------------------------
// wxGDIImageRefData: common data fields for all derived classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImageRefData : public wxGDIRefData
{
public:
wxGDIImageRefData()
{
m_width = m_height = m_depth = 0;
m_handle = 0;
}
wxGDIImageRefData(const wxGDIImageRefData& data) : wxGDIRefData()
{
m_width = data.m_width;
m_height = data.m_height;
m_depth = data.m_depth;
// can't copy handles like this, derived class copy ctor must do it!
m_handle = NULL;
}
// accessors
virtual bool IsOk() const wxOVERRIDE { return m_handle != 0; }
void SetSize(int w, int h) { m_width = w; m_height = h; }
// free the resources we allocated
virtual void Free() = 0;
// for compatibility, the member fields are public
// the size of the image
int m_width, m_height;
// the depth of the image
int m_depth;
// the handle to it
union
{
WXHANDLE m_handle; // for untyped access
WXHBITMAP m_hBitmap;
WXHICON m_hIcon;
WXHCURSOR m_hCursor;
};
};
// ----------------------------------------------------------------------------
// wxGDIImage: this class supports GDI image handlers which may be registered
// dynamically and will be used for loading/saving the images in the specified
// format. It also falls back to wxImage if no appropriate image is found.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImage : public wxGDIObject
{
public:
// handlers list interface
static wxGDIImageHandlerList& GetHandlers() { return ms_handlers; }
static void AddHandler(wxGDIImageHandler *handler);
static void InsertHandler(wxGDIImageHandler *handler);
static bool RemoveHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& extension, long type);
static wxGDIImageHandler *FindHandler(long type);
static void InitStandardHandlers();
static void CleanUpHandlers();
// access to the ref data casted to the right type
wxGDIImageRefData *GetGDIImageData() const
{ return (wxGDIImageRefData *)m_refData; }
// accessors
WXHANDLE GetHandle() const
{ return IsNull() ? 0 : GetGDIImageData()->m_handle; }
void SetHandle(WXHANDLE handle)
{ AllocExclusive(); GetGDIImageData()->m_handle = handle; }
int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_width; }
int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_height; }
int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_depth; }
wxSize GetSize() const
{
return IsNull() ? wxSize(0,0) :
wxSize(GetGDIImageData()->m_width, GetGDIImageData()->m_height);
}
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_INLINE(void SetWidth(int w), AllocExclusive(); GetGDIImageData()->m_width = w; )
wxDEPRECATED_INLINE(void SetHeight(int h), AllocExclusive(); GetGDIImageData()->m_height = h; )
wxDEPRECATED_INLINE(void SetDepth(int d), AllocExclusive(); GetGDIImageData()->m_depth = d; )
wxDEPRECATED_INLINE(void SetSize(int w, int h), AllocExclusive(); GetGDIImageData()->SetSize(w, h); )
wxDEPRECATED_INLINE(void SetSize(const wxSize& size), AllocExclusive(); GetGDIImageData()->SetSize(size.x, size.y); )
#endif // WXWIN_COMPATIBILITY_3_0
// forward some of base class virtuals to wxGDIImageRefData
bool FreeResource(bool force = false) wxOVERRIDE;
virtual WXHANDLE GetResourceHandle() const wxOVERRIDE;
protected:
// create the data for the derived class here
virtual wxGDIImageRefData *CreateData() const = 0;
// implement the wxGDIObject method in terms of our, more specific, one
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE { return CreateData(); }
// we can't [efficiently] clone objects of this class
virtual wxGDIRefData *
CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const wxOVERRIDE
{
wxFAIL_MSG( wxT("must be implemented if used") );
return NULL;
}
static wxGDIImageHandlerList ms_handlers;
};
// ----------------------------------------------------------------------------
// wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImageHandler : public wxObject
{
public:
// ctor
wxGDIImageHandler() { m_type = wxBITMAP_TYPE_INVALID; }
wxGDIImageHandler(const wxString& name,
const wxString& ext,
wxBitmapType type)
: m_name(name), m_extension(ext), m_type(type) { }
// accessors
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetType(wxBitmapType type) { m_type = type; }
const wxString& GetName() const { return m_name; }
const wxString& GetExtension() const { return m_extension; }
wxBitmapType GetType() const { return m_type; }
// real handler operations: to implement in derived classes
virtual bool Create(wxGDIImage *image,
const void* data,
wxBitmapType flags,
int width, int height, int depth = 1) = 0;
virtual bool Load(wxGDIImage *image,
const wxString& name,
wxBitmapType flags,
int desiredWidth, int desiredHeight) = 0;
virtual bool Save(const wxGDIImage *image,
const wxString& name,
wxBitmapType type) const = 0;
protected:
wxString m_name;
wxString m_extension;
wxBitmapType m_type;
};
#endif // _WX_MSW_GDIIMAGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/radiobut.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/radiobut.h
// Purpose: wxRadioButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBUT_H_
#define _WX_RADIOBUT_H_
#include "wx/msw/ownerdrawnbutton.h"
class WXDLLIMPEXP_CORE wxRadioButton : public wxMSWOwnerDrawnButton<wxControl>
{
public:
// ctors and creation functions
wxRadioButton() { Init(); }
wxRadioButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr)
{
Init();
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr);
// implement the radio button interface
virtual void SetValue(bool value);
virtual bool GetValue() const;
// implementation only from now on
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// Implement wxMSWOwnerDrawnButtonBase methods.
virtual int MSWGetButtonStyle() const wxOVERRIDE;
virtual void MSWOnButtonResetOwnerDrawn() wxOVERRIDE;
virtual int MSWGetButtonCheckedFlag() const wxOVERRIDE;
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) wxOVERRIDE;
private:
// common part of all ctors
void Init();
// we need to store the state internally as the result of GetValue()
// sometimes gets out of sync in WM_COMMAND handler
bool m_isChecked;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxRadioButton);
};
#endif // _WX_RADIOBUT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/radiobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/radiobox.h
// Purpose: wxRadioBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBOX_H_
#define _WX_RADIOBOX_H_
#include "wx/statbox.h"
class WXDLLIMPEXP_FWD_CORE wxSubwindows;
// ----------------------------------------------------------------------------
// wxRadioBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioBox : public wxStaticBox, public wxRadioBoxBase
{
public:
wxRadioBox() { Init(); }
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, n, choices, majorDim,
style, val, name);
}
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, choices, majorDim,
style, val, name);
}
virtual ~wxRadioBox();
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
// implement the radiobox interface
virtual void SetSelection(int n) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE { return m_selectedButton; }
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& label) wxOVERRIDE;
virtual bool Enable(unsigned int n, bool enable = true) wxOVERRIDE;
virtual bool Show(unsigned int n, bool show = true) wxOVERRIDE;
virtual bool IsItemEnabled(unsigned int n) const wxOVERRIDE;
virtual bool IsItemShown(unsigned int n) const wxOVERRIDE;
virtual int GetItemFromPoint(const wxPoint& pt) const wxOVERRIDE;
// override some base class methods
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool CanBeFocused() const wxOVERRIDE;
virtual void SetFocus() wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual bool HasToolTips() const wxOVERRIDE;
#endif // wxUSE_TOOLTIPS
#if wxUSE_HELP
// override virtual function with a platform-independent implementation
virtual wxString GetHelpTextAtPoint(const wxPoint & pt, wxHelpEvent::Origin origin) const wxOVERRIDE
{
return wxRadioBoxBase::DoGetHelpTextAtPoint( this, pt, origin );
}
#endif // wxUSE_HELP
virtual bool Reparent(wxWindowBase *newParent) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
void SetLabelFont(const wxFont& WXUNUSED(font)) {}
void SetButtonFont(const wxFont& font) { SetFont(font); }
// implementation only from now on
// -------------------------------
// This function can be used to check if the given radio button HWND
// belongs to one of our radio boxes. If it doesn't, NULL is returned.
static wxRadioBox *GetFromRadioButtonHWND(WXHWND hwnd);
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
void Command(wxCommandEvent& event) wxOVERRIDE;
void SendNotificationEvent();
protected:
// common part of all ctors
void Init();
// subclass one radio button
void SubclassRadioButton(WXHWND hWndBtn);
// get the max size of radio buttons
wxSize GetMaxButtonSize() const;
// get the total size occupied by the radio box buttons
wxSize GetTotalButtonSize(const wxSize& sizeBtn) const;
// Adjust all the buttons to the new window size.
void PositionAllButtons(int x, int y, int width, int height);
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetItemToolTip(unsigned int n, wxToolTip * tooltip) wxOVERRIDE;
#endif
virtual WXHRGN MSWGetRegionWithoutChildren() wxOVERRIDE;
// resolve ambiguity in base classes
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxRadioBoxBase::GetDefaultBorder(); }
// the buttons we contain
wxSubwindows *m_radioButtons;
// and the special dummy button used only as a tab group boundary
WXHWND m_dummyHwnd;
wxWindowIDRef m_dummyId;
// currently selected button or wxNOT_FOUND if none
int m_selectedButton;
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
wxDECLARE_NO_COPY_CLASS(wxRadioBox);
};
#endif
// _WX_RADIOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/hyperlink.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/hyperlink.h
// Purpose: Hyperlink control
// Author: Rickard Westerlund
// Created: 2010-08-04
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_HYPERLINK_H_
#define _WX_MSW_HYPERLINK_H_
#include "wx/generic/hyperlink.h"
// ----------------------------------------------------------------------------
// wxHyperlinkCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxHyperlinkCtrl : public wxGenericHyperlinkCtrl
{
public:
// Default constructor (for two-step construction).
wxHyperlinkCtrl() { }
// Constructor.
wxHyperlinkCtrl(wxWindow *parent,
wxWindowID id,
const wxString& label, const wxString& url,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHL_DEFAULT_STYLE,
const wxString& name = wxHyperlinkCtrlNameStr)
{
(void)Create(parent, id, label, url, pos, size, style, name);
}
// Creation function (for two-step construction).
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label, const wxString& url,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHL_DEFAULT_STYLE,
const wxString& name = wxHyperlinkCtrlNameStr);
// overridden base class methods
// -----------------------------
virtual void SetURL(const wxString &url) wxOVERRIDE;
virtual void SetLabel(const wxString &label) wxOVERRIDE;
protected:
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
private:
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS( wxHyperlinkCtrl );
};
#endif // _WX_MSW_HYPERLINK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/stdpaths.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stdpaths.h
// Purpose: wxStandardPaths for Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-10-19
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STDPATHS_H_
#define _WX_MSW_STDPATHS_H_
struct _GUID;
// ----------------------------------------------------------------------------
// wxStandardPaths
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStandardPaths : public wxStandardPathsBase
{
public:
// implement base class pure virtuals
virtual wxString GetExecutablePath() const wxOVERRIDE;
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
virtual wxString GetDataDir() const wxOVERRIDE;
virtual wxString GetUserDataDir() const wxOVERRIDE;
virtual wxString GetUserLocalDataDir() const wxOVERRIDE;
virtual wxString GetPluginsDir() const wxOVERRIDE;
virtual wxString GetUserDir(Dir userDir) const wxOVERRIDE;
virtual wxString MakeConfigFileName(const wxString& basename,
ConfigFileConv conv = ConfigFileConv_Ext
) const wxOVERRIDE;
// MSW-specific methods
// This class supposes that data, plugins &c files are located under the
// program directory which is the directory containing the application
// binary itself. But sometimes this binary may be in a subdirectory of the
// main program directory, e.g. this happens in at least the following
// common cases:
// 1. The program is in "bin" subdirectory of the installation directory.
// 2. The program is in "debug" subdirectory of the directory containing
// sources and data files during development
//
// By calling this function you instruct the class to remove the last
// component of the path if it matches its argument. Notice that it may be
// called more than once, e.g. you can call both IgnoreAppSubDir("bin") and
// IgnoreAppSubDir("debug") to take care of both production and development
// cases above but that each call will only remove the last path component.
// Finally note that the argument can contain wild cards so you can also
// call IgnoreAppSubDir("vc*msw*") to ignore all build directories at once
// when using wxWidgets-inspired output directories names.
void IgnoreAppSubDir(const wxString& subdirPattern);
// This function is used to ignore all common build directories and is
// called from the ctor -- use DontIgnoreAppSubDir() to undo this.
void IgnoreAppBuildSubDirs();
// Undo the effects of all preceding IgnoreAppSubDir() calls.
void DontIgnoreAppSubDir();
// Returns the directory corresponding to the specified Windows shell CSIDL
static wxString MSWGetShellDir(int csidl);
protected:
// Ctor is protected, use wxStandardPaths::Get() instead of instantiating
// objects of this class directly.
//
// It calls IgnoreAppBuildSubDirs() and also sets up the object to use
// both vendor and application name by default.
wxStandardPaths();
// get the path corresponding to the given standard CSIDL_XXX constant
static wxString DoGetDirectory(int csidl);
static wxString DoGetKnownFolder(const _GUID& rfid);
// return the directory of the application itself
wxString GetAppDir() const;
// directory returned by GetAppDir()
mutable wxString m_appDir;
};
// ----------------------------------------------------------------------------
// wxStandardPathsWin16: this class is for internal use only
// ----------------------------------------------------------------------------
// override config file locations to be compatible with the values used by
// wxFileConfig (dating from Win16 days which explains the class name)
class WXDLLIMPEXP_BASE wxStandardPathsWin16 : public wxStandardPaths
{
public:
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
};
#endif // _WX_MSW_STDPATHS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/checklst.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/checklst.h
// Purpose: wxCheckListBox class - a listbox with checkable items
// Author: Vadim Zeitlin
// Modified by:
// Created: 16.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef __CHECKLST__H_
#define __CHECKLST__H_
#if !wxUSE_OWNER_DRAWN
#error "wxCheckListBox class requires owner-drawn functionality."
#endif
class WXDLLIMPEXP_FWD_CORE wxOwnerDrawn;
class WXDLLIMPEXP_FWD_CORE wxCheckListBoxItem; // fwd decl, defined in checklst.cpp
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
public:
// ctors
wxCheckListBox();
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// items may be checked
virtual bool IsChecked(unsigned int uiIndex) const wxOVERRIDE;
virtual void Check(unsigned int uiIndex, bool bCheck = true) wxOVERRIDE;
virtual void Toggle(unsigned int uiIndex);
// we create our items ourselves and they have non-standard size,
// so we need to override these functions
virtual wxOwnerDrawn *CreateLboxItem(size_t n) wxOVERRIDE;
virtual bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item) wxOVERRIDE;
protected:
// pressing space or clicking the check box toggles the item
void OnKeyDown(wxKeyEvent& event);
void OnLeftClick(wxMouseEvent& event);
// send an "item checked" event
void SendEvent(unsigned int uiIndex)
{
wxCommandEvent event(wxEVT_CHECKLISTBOX, GetId());
event.SetInt(uiIndex);
event.SetEventObject(this);
event.SetString(GetString(uiIndex));
ProcessCommand(event);
}
wxSize DoGetBestClientSize() const wxOVERRIDE;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckListBox);
};
#endif //_CHECKLST_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/htmlhelp.h | /*
* wx/msw/htmlhelp.h
* Copyright 2004 Jacek Caban
*
* Originally written for the Wine project, and issued under
* the wxWindows licence by kind permission of the author.
*
* Licence: wxWindows licence
*/
#ifndef __HTMLHELP_H__
#define __HTMLHELP_H__
#define HH_DISPLAY_TOPIC 0x00
#define HH_HELP_FINDER 0x00
#define HH_DISPLAY_TOC 0x01
#define HH_DISPLAY_INDEX 0x02
#define HH_DISPLAY_SEARCH 0x03
#define HH_SET_WIN_TYPE 0x04
#define HH_GET_WIN_TYPE 0x05
#define HH_GET_WIN_HANDLE 0x06
#define HH_ENUM_INFO_TYPE 0x07
#define HH_SET_INFO_TYPE 0x08
#define HH_SYNC 0x09
#define HH_RESERVED1 0x0A
#define HH_RESERVED2 0x0B
#define HH_RESERVED3 0x0C
#define HH_KEYWORD_LOOKUP 0x0D
#define HH_DISPLAY_TEXT_POPUP 0x0E
#define HH_HELP_CONTEXT 0x0F
#define HH_TP_HELP_CONTEXTMENU 0x10
#define HH_TP_HELP_WM_HELP 0x11
#define HH_CLOSE_ALL 0x12
#define HH_ALINK_LOOKUP 0x13
#define HH_GET_LAST_ERROR 0x14
#define HH_ENUM_CATEGORY 0x15
#define HH_ENUM_CATEGORY_IT 0x16
#define HH_RESET_IT_FILTER 0x17
#define HH_SET_INCLUSIVE_FILTER 0x18
#define HH_SET_EXCLUSIVE_FILTER 0x19
#define HH_INITIALIZE 0x1C
#define HH_UNINITIALIZE 0x1D
#define HH_PRETRANSLATEMESSAGE 0xFD
#define HH_SET_GLOBAL_PROPERTY 0xFC
#define HHWIN_PROP_TAB_AUTOHIDESHOW 0x00000001
#define HHWIN_PROP_ONTOP 0x00000002
#define HHWIN_PROP_NOTITLEBAR 0x00000004
#define HHWIN_PROP_NODEF_STYLES 0x00000008
#define HHWIN_PROP_NODEF_EXSTYLES 0x00000010
#define HHWIN_PROP_TRI_PANE 0x00000020
#define HHWIN_PROP_NOTB_TEXT 0x00000040
#define HHWIN_PROP_POST_QUIT 0x00000080
#define HHWIN_PROP_AUTO_SYNC 0x00000100
#define HHWIN_PROP_TRACKING 0x00000200
#define HHWIN_PROP_TAB_SEARCH 0x00000400
#define HHWIN_PROP_TAB_HISTORY 0x00000800
#define HHWIN_PROP_TAB_FAVORITES 0x00001000
#define HHWIN_PROP_CHANGE_TITLE 0x00002000
#define HHWIN_PROP_NAV_ONLY_WIN 0x00004000
#define HHWIN_PROP_NO_TOOLBAR 0x00008000
#define HHWIN_PROP_MENU 0x00010000
#define HHWIN_PROP_TAB_ADVSEARCH 0x00020000
#define HHWIN_PROP_USER_POS 0x00040000
#define HHWIN_PROP_TAB_CUSTOM1 0x00080000
#define HHWIN_PROP_TAB_CUSTOM2 0x00100000
#define HHWIN_PROP_TAB_CUSTOM3 0x00200000
#define HHWIN_PROP_TAB_CUSTOM4 0x00400000
#define HHWIN_PROP_TAB_CUSTOM5 0x00800000
#define HHWIN_PROP_TAB_CUSTOM6 0x01000000
#define HHWIN_PROP_TAB_CUSTOM7 0x02000000
#define HHWIN_PROP_TAB_CUSTOM8 0x04000000
#define HHWIN_PROP_TAB_CUSTOM9 0x08000000
#define HHWIN_TB_MARGIN 0x10000000
#define HHWIN_PARAM_PROPERTIES 0x00000002
#define HHWIN_PARAM_STYLES 0x00000004
#define HHWIN_PARAM_EXSTYLES 0x00000008
#define HHWIN_PARAM_RECT 0x00000010
#define HHWIN_PARAM_NAV_WIDTH 0x00000020
#define HHWIN_PARAM_SHOWSTATE 0x00000040
#define HHWIN_PARAM_INFOTYPES 0x00000080
#define HHWIN_PARAM_TB_FLAGS 0x00000100
#define HHWIN_PARAM_EXPANSION 0x00000200
#define HHWIN_PARAM_TABPOS 0x00000400
#define HHWIN_PARAM_TABORDER 0x00000800
#define HHWIN_PARAM_HISTORY_COUNT 0x00001000
#define HHWIN_PARAM_CUR_TAB 0x00002000
#define HHWIN_BUTTON_EXPAND 0x00000002
#define HHWIN_BUTTON_BACK 0x00000004
#define HHWIN_BUTTON_FORWARD 0x00000008
#define HHWIN_BUTTON_STOP 0x00000010
#define HHWIN_BUTTON_REFRESH 0x00000020
#define HHWIN_BUTTON_HOME 0x00000040
#define HHWIN_BUTTON_BROWSE_FWD 0x00000080
#define HHWIN_BUTTON_BROWSE_BCK 0x00000100
#define HHWIN_BUTTON_NOTES 0x00000200
#define HHWIN_BUTTON_CONTENTS 0x00000400
#define HHWIN_BUTTON_SYNC 0x00000800
#define HHWIN_BUTTON_OPTIONS 0x00001000
#define HHWIN_BUTTON_PRINT 0x00002000
#define HHWIN_BUTTON_INDEX 0x00004000
#define HHWIN_BUTTON_SEARCH 0x00008000
#define HHWIN_BUTTON_HISTORY 0x00010000
#define HHWIN_BUTTON_FAVORITES 0x00020000
#define HHWIN_BUTTON_JUMP1 0x00040000
#define HHWIN_BUTTON_JUMP2 0x00080000
#define HHWIN_BUTTON_ZOOM 0x00100000
#define HHWIN_BUTTON_TOC_NEXT 0x00200000
#define HHWIN_BUTTON_TOC_PREV 0x00400000
#define HHWIN_DEF_BUTTONS \
(HHWIN_BUTTON_EXPAND | HHWIN_BUTTON_BACK | HHWIN_BUTTON_OPTIONS | HHWIN_BUTTON_PRINT)
#define IDTB_EXPAND 200
#define IDTB_CONTRACT 201
#define IDTB_STOP 202
#define IDTB_REFRESH 203
#define IDTB_BACK 204
#define IDTB_HOME 205
#define IDTB_SYNC 206
#define IDTB_PRINT 207
#define IDTB_OPTIONS 208
#define IDTB_FORWARD 209
#define IDTB_NOTES 210
#define IDTB_BROWSE_FWD 211
#define IDTB_BROWSE_BACK 212
#define IDTB_CONTENTS 213
#define IDTB_INDEX 214
#define IDTB_SEARCH 215
#define IDTB_HISTORY 216
#define IDTB_FAVORITES 217
#define IDTB_JUMP1 218
#define IDTB_JUMP2 219
#define IDTB_CUSTOMIZE 221
#define IDTB_ZOOM 222
#define IDTB_TOC_NEXT 223
#define IDTB_TOC_PREV 224
#define HHN_FIRST (0U-860U)
#define HHN_LAST (0U-879U)
#define HHN_NAVCOMPLETE HHN_FIRST
#define HHN_TRACK (HHN_FIRST-1)
#define HHN_WINDOW_CREATE (HHN_FIRST-2)
#ifdef __cplusplus
extern "C" {
#endif
typedef struct tagHH_NOTIFY {
NMHDR hdr;
PCSTR pszurl;
} HH_NOTIFY;
typedef struct tagHH_POPUPA {
int cbStruct;
HINSTANCE hinst;
UINT idString;
LPCSTR pszText;
POINT pt;
COLORREF clrForeground;
COLORREF clrBackground;
RECT rcMargins;
LPCSTR pszFont;
} HH_POPUPA;
typedef struct tagHH_POPUPW {
int cbStruct;
HINSTANCE hinst;
UINT idString;
LPCWSTR pszText;
POINT pt;
COLORREF clrForeground;
COLORREF clrBackground;
RECT rcMargins;
LPCWSTR pszFont;
} HH_POPUPW;
#ifdef _UNICODE
typedef HH_POPUPW HH_POPUP;
#else
typedef HH_POPUPA HH_POPUP;
#endif
typedef struct tagHH_ALINKA {
int cbStruct;
BOOL fReserved;
LPCSTR pszKeywords;
LPCSTR pszUrl;
LPCSTR pszMsgText;
LPCSTR pszMsgTitle;
LPCSTR pszWindow;
BOOL fIndexOnFail;
} HH_ALINKA;
typedef struct tagHH_ALINKW {
int cbStruct;
BOOL fReserved;
LPCWSTR pszKeywords;
LPCWSTR pszUrl;
LPCWSTR pszMsgText;
LPCWSTR pszMsgTitle;
LPCWSTR pszWindow;
BOOL fIndexOnFail;
} HH_ALINKW;
#ifdef _UNICODE
typedef HH_ALINKW HH_ALINK;
typedef HH_ALINKW HH_AKLINK;
#else
typedef HH_ALINKA HH_ALINK;
typedef HH_ALINKA HH_AKLINK;
#endif
enum {
HHWIN_NAVTYPE_TOC,
HHWIN_NAVTYPE_INDEX,
HHWIN_NAVTYPE_SEARCH,
HHWIN_NAVTYPE_FAVORITES,
HHWIN_NAVTYPE_HISTORY,
HHWIN_NAVTYPE_AUTHOR,
HHWIN_NAVTYPE_CUSTOM_FIRST = 11
};
enum {
IT_INCLUSIVE,
IT_EXCLUSIVE,
IT_HIDDEN
};
typedef struct tagHH_ENUM_IT {
int cbStruct;
int iType;
LPCSTR pszCatName;
LPCSTR pszITName;
LPCSTR pszITDescription;
} HH_ENUM_IT, *PHH_ENUM_IT;
typedef struct tagHH_ENUM_CAT {
int cbStruct;
LPCSTR pszCatName;
LPCSTR pszCatDescription;
} HH_ENUM_CAT, *PHH_ENUM_CAT;
typedef struct tagHH_SET_INFOTYPE {
int cbStruct;
LPCSTR pszCatName;
LPCSTR pszInfoTypeName;
} HH_SET_INFOTYPE;
typedef DWORD HH_INFOTYPE, *PHH_INFOTYPE;
enum {
HHWIN_NAVTAB_TOP,
HHWIN_NAVTAB_LEFT,
HHWIN_NAVTAB_BOTTOM
};
#define HH_MAX_TABS 19
enum {
HH_TAB_CONTENTS,
HH_TAB_INDEX,
HH_TAB_SEARCH,
HH_TAB_FAVORITES,
HH_TAB_HISTORY,
HH_TAB_AUTHOR,
HH_TAB_CUSTOM_FIRST = 11,
HH_TAB_CUSTOM_LAST = HH_MAX_TABS
};
#define HH_MAX_TABS_CUSTOM (HH_TAB_CUSTOM_LAST-HH_TAB_CUSTOM_FIRST+1)
#define HH_FTS_DEFAULT_PROXIMITY -1
typedef struct tagHH_FTS_QUERYA {
int cbStruct;
BOOL fUniCodeStrings;
LPCSTR pszSearchQuery;
LONG iProximity;
BOOL fStemmedSearch;
BOOL fTitleOnly;
BOOL fExecute;
LPCSTR pszWindow;
} HH_FTS_QUERYA;
typedef struct tagHH_FTS_QUERYW {
int cbStruct;
BOOL fUniCodeStrings;
LPCWSTR pszSearchQuery;
LONG iProximity;
BOOL fStemmedSearch;
BOOL fTitleOnly;
BOOL fExecute;
LPCWSTR pszWindow;
} HH_FTS_QUERYW;
#ifdef _UNICODE
typedef HH_FTS_QUERYW HH_FTS_QUERY;
#else
typedef HH_FTS_QUERYA HH_FTS_QUERY;
#endif
typedef struct tagHH_WINTYPEA {
int cbStruct;
BOOL fUniCodeStrings;
LPCSTR pszType;
DWORD fsValidMembers;
DWORD fsWinProperties;
LPCSTR pszCaption;
DWORD dwStyles;
DWORD dwExStyles;
RECT rcWindowPos;
int nShowState;
HWND hwndHelp;
HWND hwndCaller;
PHH_INFOTYPE paInfoTypes;
HWND hwndToolBar;
HWND hwndNavigation;
HWND hwndHTML;
int iNavWidth;
RECT rcHTML;
LPCSTR pszToc;
LPCSTR pszIndex;
LPCSTR pszFile;
LPCSTR pszHome;
DWORD fsToolBarFlags;
BOOL fNotExpanded;
int curNavType;
int tabpos;
int idNotify;
BYTE tabOrder[HH_MAX_TABS+1];
int cHistory;
LPCSTR pszJump1;
LPCSTR pszJump2;
LPCSTR pszUrlJump1;
LPCSTR pszUrlJump2;
RECT rcMinSize;
int cbInfoTypes;
LPCSTR pszCustomTabs;
} HH_WINTYPEA, *PHH_WINTYPEA;
typedef struct tagHH_WINTYPEW {
int cbStruct;
BOOL fUniCodeStrings;
LPCWSTR pszType;
DWORD fsValidMembers;
DWORD fsWinProperties;
LPCWSTR pszCaption;
DWORD dwStyles;
DWORD dwExStyles;
RECT rcWindowPos;
int nShowState;
HWND hwndHelp;
HWND hwndCaller;
PHH_INFOTYPE paInfoTypes;
HWND hwndToolBar;
HWND hwndNavigation;
HWND hwndHTML;
int iNavWidth;
RECT rcHTML;
LPCWSTR pszToc;
LPCWSTR pszIndex;
LPCWSTR pszFile;
LPCWSTR pszHome;
DWORD fsToolBarFlags;
BOOL fNotExpanded;
int curNavType;
int tabpos;
int idNotify;
BYTE tabOrder[HH_MAX_TABS+1];
int cHistory;
LPCWSTR pszJump1;
LPCWSTR pszJump2;
LPCWSTR pszUrlJump1;
LPCWSTR pszUrlJump2;
RECT rcMinSize;
int cbInfoTypes;
LPCWSTR pszCustomTabs;
} HH_WINTYPEW, *PHH_WINTYPEW;
#ifdef _UNICODE
typedef HH_WINTYPEW HH_WINTYPE;
#else
typedef HH_WINTYPEA HH_WINTYPE;
#endif
enum {
HHACT_TAB_CONTENTS,
HHACT_TAB_INDEX,
HHACT_TAB_SEARCH,
HHACT_TAB_HISTORY,
HHACT_TAB_FAVORITES,
HHACT_EXPAND,
HHACT_CONTRACT,
HHACT_BACK,
HHACT_FORWARD,
HHACT_STOP,
HHACT_REFRESH,
HHACT_HOME,
HHACT_SYNC,
HHACT_OPTIONS,
HHACT_PRINT,
HHACT_HIGHLIGHT,
HHACT_CUSTOMIZE,
HHACT_JUMP1,
HHACT_JUMP2,
HHACT_ZOOM,
HHACT_TOC_NEXT,
HHACT_TOC_PREV,
HHACT_NOTES,
HHACT_LAST_ENUM
};
typedef struct tagHH_NTRACKA {
NMHDR hdr;
PCSTR pszCurUrl;
int idAction;
PHH_WINTYPEA phhWinType;
} HH_NTRACKA;
typedef struct tagHH_NTRACKW {
NMHDR hdr;
PCSTR pszCurUrl;
int idAction;
PHH_WINTYPEW phhWinType;
} HH_NTRACKW;
#ifdef _UNICODE
typedef HH_NTRACKW HH_NTRACK;
#else
typedef HH_NTRACKA HH_NTRACK;
#endif
HWND WINAPI HtmlHelpA(HWND,LPCSTR,UINT,DWORD);
HWND WINAPI HtmlHelpA(HWND,LPCSTR,UINT,DWORD);
#define HtmlHelp WINELIB_NAME_AW(HtmlHelp)
#define ATOM_HTMLHELP_API_ANSI (LPTSTR)14
#define ATOM_HTMLHELP_API_UNICODE (LPTSTR)15
typedef enum tagHH_GPROPID {
HH_GPROPID_SINGLETHREAD = 1,
HH_GPROPID_TOOLBAR_MARGIN = 2,
HH_GPROPID_UI_LANGUAGE = 3,
HH_GPROPID_CURRENT_SUBSET = 4,
HH_GPROPID_CONTENT_LANGUAGE = 5
} HH_GPROPID;
#ifdef __WIDL_OAIDL_H
typedef struct tagHH_GLOBAL_PROPERTY
{
HH_GPROPID id;
VARIANT var;
} HH_GLOBAL_PROPERTY ;
#endif /* __WIDL_OAIDL_H */
#ifdef __cplusplus
}
#endif
#endif /* __HTMLHELP_H__ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/listbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/listbox.h
// Purpose: wxListBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTBOX_H_
#define _WX_LISTBOX_H_
#if wxUSE_LISTBOX
// ----------------------------------------------------------------------------
// simple types
// ----------------------------------------------------------------------------
#if wxUSE_OWNER_DRAWN
class WXDLLIMPEXP_FWD_CORE wxOwnerDrawn;
// define the array of list box items
#include "wx/dynarray.h"
WX_DEFINE_EXPORTED_ARRAY_PTR(wxOwnerDrawn *, wxListBoxItemsArray);
#endif // wxUSE_OWNER_DRAWN
// forward declaration for GetSelections()
class WXDLLIMPEXP_FWD_BASE wxArrayInt;
// ----------------------------------------------------------------------------
// List box control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxListBox : public wxListBoxBase
{
public:
// ctors and such
wxListBox() { Init(); }
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Init();
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Init();
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
virtual ~wxListBox();
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& s) wxOVERRIDE;
virtual int FindString(const wxString& s, bool bCase = false) const wxOVERRIDE;
virtual bool IsSelected(int n) const wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual int GetSelections(wxArrayInt& aSelections) const wxOVERRIDE;
// return the index of the item at this position or wxNOT_FOUND
int HitTest(const wxPoint& pt) const { return DoHitTestList(pt); }
int HitTest(wxCoord x, wxCoord y) const { return DoHitTestList(wxPoint(x, y)); }
virtual void EnsureVisible(int n) wxOVERRIDE;
virtual int GetTopItem() const wxOVERRIDE;
virtual int GetCountPerPage() const wxOVERRIDE;
// ownerdrawn wxListBox and wxCheckListBox support
#if wxUSE_OWNER_DRAWN
// override base class virtuals
virtual bool SetFont(const wxFont &font) wxOVERRIDE;
bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item) wxOVERRIDE;
bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE;
// plug-in for derived classes
virtual wxOwnerDrawn *CreateLboxItem(size_t n);
// allows to get the item and use SetXXX functions to set it's appearance
wxOwnerDrawn *GetItem(size_t n) const { return m_aItems[n]; }
// get the index of the given item
int GetItemIndex(wxOwnerDrawn *item) const { return m_aItems.Index(item); }
// get rect of the given item index
bool GetItemRect(size_t n, wxRect& rect) const;
// redraw the given item
bool RefreshItem(size_t n);
#endif // wxUSE_OWNER_DRAWN
// Windows-specific code to update the horizontal extent of the listbox, if
// necessary. If s is non-empty, the horizontal extent is increased to the
// length of this string if it's currently too short, otherwise the maximum
// extent of all strings is used. In any case calls InvalidateBestSize()
virtual void SetHorizontalExtent(const wxString& s = wxEmptyString);
// Windows callbacks
bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// under XP when using "transition effect for menus and tooltips" if we
// return true for WM_PRINTCLIENT here then it causes noticeable slowdown
virtual bool MSWShouldPropagatePrintChild() wxOVERRIDE
{
return false;
}
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL)
{
return GetCompositeControlsDefaultAttributes(variant);
}
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
virtual void OnInternalIdle() wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual void DoSetSelection(int n, bool select) wxOVERRIDE;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual void DoSetFirstItem(int n) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
// this can't be called DoHitTest() because wxWindow already has this method
virtual int DoHitTestList(const wxPoint& point) const;
// free memory (common part of Clear() and dtor)
void Free();
unsigned int m_noItems;
#if wxUSE_OWNER_DRAWN
// control items
wxListBoxItemsArray m_aItems;
#endif
private:
// common part of all ctors
void Init();
// call this when items are added to or deleted from the listbox or an
// items text changes
void MSWOnItemsChanged();
// flag indicating whether the max horizontal extent should be updated,
// i.e. if we need to call SetHorizontalExtent() from OnInternalIdle()
bool m_updateHorizontalExtent;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxListBox);
};
#endif // wxUSE_LISTBOX
#endif
// _WX_LISTBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/textentry.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/textentry.h
// Purpose: wxMSW-specific wxTextEntry implementation
// Author: Vadim Zeitlin
// Created: 2007-09-26
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TEXTENTRY_H_
#define _WX_MSW_TEXTENTRY_H_
class wxTextAutoCompleteData; // private class used only by wxTextEntry itself
// ----------------------------------------------------------------------------
// wxTextEntry: common part of wxComboBox and (single line) wxTextCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTextEntry : public wxTextEntryBase
{
public:
wxTextEntry();
virtual ~wxTextEntry();
// implement wxTextEntryBase pure virtual methods
virtual void WriteText(const wxString& text) wxOVERRIDE;
virtual void Remove(long from, long to) wxOVERRIDE;
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
virtual void SetInsertionPoint(long pos) wxOVERRIDE;
virtual long GetInsertionPoint() const wxOVERRIDE;
virtual long GetLastPosition() const wxOVERRIDE;
virtual void SetSelection(long from, long to) wxOVERRIDE
{ DoSetSelection(from, to); }
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
virtual void SetEditable(bool editable) wxOVERRIDE;
virtual void SetMaxLength(unsigned long len) wxOVERRIDE;
virtual void ForceUpper() wxOVERRIDE;
#if wxUSE_UXTHEME
virtual bool SetHint(const wxString& hint) wxOVERRIDE;
virtual wxString GetHint() const wxOVERRIDE;
#endif // wxUSE_UXTHEME
protected:
virtual wxString DoGetValue() const wxOVERRIDE;
// this is really a hook for multiline text controls as the single line
// ones don't need to ever scroll to show the selection but having it here
// allows us to put Remove() in the base class
enum
{
SetSel_NoScroll = 0, // don't do anything special
SetSel_Scroll = 1 // default: scroll to make the selection visible
};
virtual void DoSetSelection(long from, long to, int flags = SetSel_Scroll);
// margins functions
virtual bool DoSetMargins(const wxPoint& pt) wxOVERRIDE;
virtual wxPoint DoGetMargins() const wxOVERRIDE;
// auto-completion uses COM under Windows so they won't work without
// wxUSE_OLE as OleInitialize() is not called then
#if wxUSE_OLE
virtual bool DoAutoCompleteStrings(const wxArrayString& choices) wxOVERRIDE;
#if wxUSE_DYNLIB_CLASS
virtual bool DoAutoCompleteFileNames(int flags) wxOVERRIDE;
#endif // wxUSE_DYNLIB_CLASS
virtual bool DoAutoCompleteCustom(wxTextCompleter *completer) wxOVERRIDE;
#endif // wxUSE_OLE
private:
// implement this to return the HWND of the EDIT control
virtual WXHWND GetEditHWND() const = 0;
#if wxUSE_OLE
// This method is called to process special keys such as Return and Tab
// before they're consumed by the auto-completer. Notice that it is only
// called if we do need to process the key, i.e. if the corresponding
// wxTE_PROCESS_XXX style is set in the associated object.
//
// It is not pure virtual because it won't get called if the derived class
// doesn't use auto-completer, but it does need to be overridden if it can
// be called and the default implementation asserts if this is not the case.
virtual void MSWProcessSpecialKey(wxKeyEvent& event);
// Get the auto-complete object creating it if necessary. Returns NULL if
// creating it failed.
wxTextAutoCompleteData *GetOrCreateCompleter();
// Various auto-completion-related stuff, only used if any of AutoComplete()
// methods are called. Use the function above to access it.
wxTextAutoCompleteData *m_autoCompleteData;
// It needs to call our GetEditableWindow() and GetEditHWND() methods.
friend class wxTextAutoCompleteData;
#endif // wxUSE_OLE
};
// We don't need the generic version.
#define wxHAS_NATIVE_TEXT_FORCEUPPER
#endif // _WX_MSW_TEXTENTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/wrapwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapwin.h
// Purpose: Wrapper around <windows.h>, to be included instead of it
// Author: Vaclav Slavik
// Created: 2003/07/22
// Copyright: (c) 2003 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WRAPWIN_H_
#define _WX_WRAPWIN_H_
#include "wx/platform.h"
// before including windows.h, define version macros at (currently) maximal
// values because we do all our checks at run-time anyhow
#include "wx/msw/winver.h"
// strict type checking to detect conversion from HFOO to HBAR at compile-time
#ifndef STRICT
#define STRICT 1
#endif
// this macro tells windows.h to not define min() and max() as macros: we need
// this as otherwise they conflict with standard C++ functions
#ifndef NOMINMAX
#define NOMINMAX
#endif // NOMINMAX
// For IPv6 support, we must include winsock2.h before winsock.h, and
// windows.h include winsock.h so do it before including it
#if wxUSE_IPV6
#include <winsock2.h>
#endif
// Disable any warnings inside Windows headers.
#ifdef __VISUALC__
#pragma warning(push, 1)
#endif
#include <windows.h>
#ifdef __VISUALC__
#pragma warning(pop)
#endif
// #undef the macros defined in winsows.h which conflict with code elsewhere
#include "wx/msw/winundef.h"
#endif // _WX_WRAPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/fontdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/fontdlg.h
// Purpose: wxFontDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_FONTDLG_H_
#define _WX_MSW_FONTDLG_H_
// ----------------------------------------------------------------------------
// wxFontDialog
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFontDialog : public wxFontDialogBase
{
public:
wxFontDialog() : wxFontDialogBase() { /* must be Create()d later */ }
wxFontDialog(wxWindow *parent)
: wxFontDialogBase(parent) { Create(parent); }
wxFontDialog(wxWindow *parent, const wxFontData& data)
: wxFontDialogBase(parent, data) { Create(parent, data); }
virtual int ShowModal() wxOVERRIDE;
virtual void SetTitle(const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
protected:
wxString m_title;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxFontDialog);
};
#endif
// _WX_MSW_FONTDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/filedlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/filedlg.h
// Purpose: wxFileDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FILEDLG_H_
#define _WX_FILEDLG_H_
//-------------------------------------------------------------------------
// wxFileDialog
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDialog: public wxFileDialogBase
{
public:
wxFileDialog(wxWindow *parent,
const wxString& message = wxFileSelectorPromptStr,
const wxString& defaultDir = wxEmptyString,
const wxString& defaultFile = wxEmptyString,
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = wxFD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& sz = wxDefaultSize,
const wxString& name = wxFileDialogNameStr);
virtual void GetPaths(wxArrayString& paths) const wxOVERRIDE;
virtual void GetFilenames(wxArrayString& files) const wxOVERRIDE;
virtual bool SupportsExtraControl() const wxOVERRIDE { return true; }
void MSWOnInitDialogHook(WXHWND hwnd);
virtual int ShowModal() wxOVERRIDE;
// wxMSW-specific implementation from now on
// -----------------------------------------
// called from the hook procedure on CDN_INITDONE reception
virtual void MSWOnInitDone(WXHWND hDlg);
// called from the hook procedure on CDN_SELCHANGE.
void MSWOnSelChange(WXHWND hDlg);
protected:
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoCentre(int dir) wxOVERRIDE;
virtual void DoGetSize( int *width, int *height ) const wxOVERRIDE;
virtual void DoGetPosition( int *x, int *y ) const wxOVERRIDE;
private:
wxArrayString m_fileNames;
// remember if our SetPosition() or Centre() (which requires special
// treatment) was called
bool m_bMovedWindow;
int m_centreDir; // nothing to do if 0
wxDECLARE_DYNAMIC_CLASS(wxFileDialog);
wxDECLARE_NO_COPY_CLASS(wxFileDialog);
};
#endif // _WX_FILEDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/gccpriv.h | /*
Name: wx/msw/gccpriv.h
Purpose: MinGW/Cygwin definitions
Author: Vadim Zeitlin
Modified by:
Created:
Copyright: (c) Vadim Zeitlin
Licence: wxWindows Licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_MSW_GCCPRIV_H_
#define _WX_MSW_GCCPRIV_H_
#if defined(__MINGW32__) && !defined(__GNUWIN32__)
#define __GNUWIN32__
#endif
#if defined(__MINGW32__)
/*
Include the header defining __MINGW32_{MAJ,MIN}OR_VERSION but check
that UNICODE or _UNICODE is already defined, as _mingw.h relies on them
being set and we'd get weird compilation errors later if it is included
without them being defined, better give a clearer error right now.
*/
#if !defined(UNICODE)
#ifndef wxUSE_UNICODE
#error "wxUSE_UNICODE must be defined before including this header."
#endif
#if wxUSE_UNICODE
#error "UNICODE must be defined before including this header."
#endif
#endif
/*
MinGW 5.3.0 (and presumably later) predefines _WIN32_WINNT and WINVER
in sdkddkver.h included from _mingw.h to very low (Windows 2000!)
values. We really want to predefine them ourselves instead, so do it
before including _mingw.h.
*/
#include "wx/msw/winver.h"
#include <_mingw.h>
/*
MinGW-w64 project provides compilers for both Win32 and Win64 but only
defines the same __MINGW32__ symbol for the former as MinGW32 toolchain
which is quite different (notably doesn't provide many SDK headers that
MinGW-w64 does include). So we define a separate symbol which, unlike
the predefined __MINGW64__, can be used to detect this toolchain in
both 32 and 64 bit builds.
And define __MINGW32_TOOLCHAIN__ for consistency and also because it's
convenient as we often want to have some workarounds only for the (old)
MinGW32 but not (newer) MinGW-w64, which still predefines __MINGW32__.
*/
#ifdef __MINGW64_VERSION_MAJOR
#ifndef __MINGW64_TOOLCHAIN__
#define __MINGW64_TOOLCHAIN__
#endif
#else
#ifndef __MINGW32_TOOLCHAIN__
#define __MINGW32_TOOLCHAIN__
#endif
#endif
#define wxCHECK_MINGW32_VERSION( major, minor ) \
( ( ( __MINGW32_MAJOR_VERSION > (major) ) \
|| ( __MINGW32_MAJOR_VERSION == (major) && __MINGW32_MINOR_VERSION >= (minor) ) ) )
#else
#define wxCHECK_MINGW32_VERSION( major, minor ) (0)
#endif
#if defined( __MINGW32__ ) && !defined(__WINE__) && !defined( HAVE_W32API_H )
#if __MINGW32_MAJOR_VERSION >= 1
#define HAVE_W32API_H
#endif
#elif defined( __CYGWIN__ ) && !defined( HAVE_W32API_H )
#if ( __GNUC__ > 2 )
#define HAVE_W32API_H
#endif
#endif
/* check for MinGW/Cygwin w32api version ( releases >= 0.5, only ) */
#if defined( HAVE_W32API_H )
#include <w32api.h>
#endif
#if defined(__W32API_MAJOR_VERSION) && defined(__W32API_MINOR_VERSION)
#define wxCHECK_W32API_VERSION( major, minor ) \
( ( ( __W32API_MAJOR_VERSION > (major) ) \
|| ( __W32API_MAJOR_VERSION == (major) && __W32API_MINOR_VERSION >= (minor) ) ) )
#else
#define wxCHECK_W32API_VERSION( major, minor ) (0)
#endif
/* Cygwin 1.0 */
#if defined(__CYGWIN__) && ((__GNUC__==2) && (__GNUC_MINOR__==9))
#define __CYGWIN10__
#endif
/*
Traditional MinGW (but not MinGW-w64 nor TDM-GCC) omits many POSIX
functions from their headers when compiled with __STRICT_ANSI__ defined.
Unfortunately this means that they are not available when using -std=c++98
(not very common) or -std=c++11 (much more so), but we still need them even
in this case. As the intention behind using -std=c++11 is probably to get
the new C++11 features and not disable the use of POSIX functions, we just
manually declare the functions we need in this case if necessary.
*/
#ifdef __MINGW32_TOOLCHAIN__
/*
The macro below is used in wx/wxcrtbase.h included from C regex library
code, so make sure it compiles in non-C++ code too.
*/
#ifdef __cplusplus
#define wxEXTERNC extern "C"
#else
#define wxEXTERNC
#endif
/*
This macro is somewhat unusual as it takes the list of parameters
inside parentheses and includes semicolon inside it as putting the
semicolon outside wouldn't do the right thing when this macro is empty.
*/
#define wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params) \
wxEXTERNC _CRTIMP rettype __cdecl __MINGW_NOTHROW func params ;
#ifdef __STRICT_ANSI__
#define wxNEEDS_STRICT_ANSI_WORKAROUNDS
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params) \
wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params)
/*
There is a bug resulting in a compilation error in MinGW standard
math.h header, see https://sourceforge.net/p/mingw/bugs/2250/, work
around it here because math.h is also included from several other
standard headers (e.g. <algorithm>) and we don't want to duplicate this
hack everywhere this happens.
*/
wxDECL_FOR_STRICT_MINGW32(double, _hypot, (double, double))
#else
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params)
#endif
#else
#define wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params)
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params)
#endif
#endif
/* _WX_MSW_GCCPRIV_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/apptrait.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/apptrait.h
// Purpose: class implementing wxAppTraits for MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 21.06.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_APPTRAIT_H_
#define _WX_MSW_APPTRAIT_H_
// ----------------------------------------------------------------------------
// wxGUI/ConsoleAppTraits: must derive from wxAppTraits, not wxAppTraitsBase
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxConsoleAppTraits : public wxConsoleAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
virtual void *BeforeChildWaitLoop() wxOVERRIDE;
virtual void AfterChildWaitLoop(void *data) wxOVERRIDE;
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif // wxUSE_TIMER
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() wxOVERRIDE;
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags) wxOVERRIDE;
#endif // wxUSE_THREADS
virtual bool CanUseStderr() wxOVERRIDE { return true; }
virtual bool WriteToStderr(const wxString& text) wxOVERRIDE;
};
#if wxUSE_GUI
#if defined(__WXMSW__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
virtual void *BeforeChildWaitLoop() wxOVERRIDE;
virtual void AfterChildWaitLoop(void *data) wxOVERRIDE;
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif // wxUSE_TIMER
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() wxOVERRIDE;
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags) wxOVERRIDE;
#endif // wxUSE_THREADS
wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const wxOVERRIDE;
virtual bool CanUseStderr() wxOVERRIDE;
virtual bool WriteToStderr(const wxString& text) wxOVERRIDE;
};
#elif defined(__WXGTK__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop();
virtual void *BeforeChildWaitLoop() { return NULL; }
virtual void AfterChildWaitLoop(void *WXUNUSED(data)) { }
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer);
#endif
#if wxUSE_THREADS && defined(__WXGTK20__)
virtual void MutexGuiEnter();
virtual void MutexGuiLeave();
#endif
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() { return true; }
virtual WXDWORD WaitForThread(WXHANDLE hThread, int WXUNUSED(flags))
{ return DoSimpleWaitForThread(hThread); }
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const;
virtual bool CanUseStderr() { return false; }
virtual bool WriteToStderr(const wxString& WXUNUSED(text)) { return false; }
};
#elif defined(__WXQT__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop();
virtual void *BeforeChildWaitLoop() { return NULL; }
virtual void AfterChildWaitLoop(void*) { }
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer);
#endif
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() { return true; }
virtual WXDWORD WaitForThread(WXHANDLE hThread, int WXUNUSED(flags))
{ return DoSimpleWaitForThread(hThread); }
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const;
virtual bool CanUseStderr() { return false; }
virtual bool WriteToStderr(const wxString&) { return false; }
};
#endif
#endif // wxUSE_GUI
#endif // _WX_MSW_APPTRAIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/spinbutt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/spinbutt.h
// Purpose: wxSpinButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SPINBUTT_H_
#define _WX_SPINBUTT_H_
#include "wx/control.h"
#include "wx/event.h"
#if wxUSE_SPINBTN
class WXDLLIMPEXP_CORE wxSpinButton : public wxSpinButtonBase
{
public:
// construction
wxSpinButton() { }
wxSpinButton(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME)
{
Create(parent, id, pos, size, style, name);
}
virtual ~wxSpinButton();
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME);
// accessors
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int val) wxOVERRIDE;
virtual void SetRange(int minVal, int maxVal) wxOVERRIDE;
// implementation
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
// a wxSpinButton can't do anything useful with focus, only wxSpinCtrl can
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// ensure that the control displays a value in the current range
virtual void NormalizeValue();
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxSpinButton);
};
#endif // wxUSE_SPINBTN
#endif // _WX_SPINBUTT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/helpbest.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpbest.h
// Purpose: Tries to load MS HTML Help, falls back to wxHTML upon failure
// Author: Mattia Barbon
// Modified by:
// Created: 02/04/2001
// Copyright: (c) Mattia Barbon
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPBEST_H_
#define _WX_HELPBEST_H_
#if wxUSE_HELP && wxUSE_MS_HTML_HELP \
&& wxUSE_WXHTML_HELP && !defined(__WXUNIVERSAL__)
#include "wx/helpbase.h"
#include "wx/html/helpfrm.h" // for wxHF_DEFAULT_STYLE
class WXDLLIMPEXP_HTML wxBestHelpController: public wxHelpControllerBase
{
public:
wxBestHelpController(wxWindow* parentWindow = NULL,
int style = wxHF_DEFAULT_STYLE)
: wxHelpControllerBase(parentWindow),
m_helpControllerType(wxUseNone),
m_helpController(NULL),
m_style(style)
{
}
virtual ~wxBestHelpController() { delete m_helpController; }
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE
{
return m_helpController->LoadFile( GetValidFilename( file ) );
}
virtual bool DisplayContents() wxOVERRIDE
{
return m_helpController->DisplayContents();
}
virtual bool DisplaySection(int sectionNo) wxOVERRIDE
{
return m_helpController->DisplaySection( sectionNo );
}
virtual bool DisplaySection(const wxString& section) wxOVERRIDE
{
return m_helpController->DisplaySection( section );
}
virtual bool DisplayBlock(long blockNo) wxOVERRIDE
{
return m_helpController->DisplayBlock( blockNo );
}
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE
{
return m_helpController->DisplayContextPopup( contextId );
}
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos) wxOVERRIDE
{
return m_helpController->DisplayTextPopup( text, pos );
}
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE
{
return m_helpController->KeywordSearch( k, mode );
}
virtual bool Quit() wxOVERRIDE
{
return m_helpController->Quit();
}
// Allows one to override the default settings for the help frame.
virtual void SetFrameParameters(const wxString& title,
const wxSize& size,
const wxPoint& pos = wxDefaultPosition,
bool newFrameEachTime = false) wxOVERRIDE
{
m_helpController->SetFrameParameters( title, size, pos,
newFrameEachTime );
}
// Obtains the latest settings used by the help frame and the help frame.
virtual wxFrame *GetFrameParameters(wxSize *size = NULL,
wxPoint *pos = NULL,
bool *newFrameEachTime = NULL) wxOVERRIDE
{
return m_helpController->GetFrameParameters( size, pos,
newFrameEachTime );
}
/// Set the window that can optionally be used for the help window's parent.
virtual void SetParentWindow(wxWindow* win) wxOVERRIDE { m_helpController->SetParentWindow(win); }
/// Get the window that can optionally be used for the help window's parent.
virtual wxWindow* GetParentWindow() const wxOVERRIDE { return m_helpController->GetParentWindow(); }
protected:
// Append/change extension if necessary.
wxString GetValidFilename(const wxString& file) const;
protected:
enum HelpControllerType { wxUseNone, wxUseHtmlHelp, wxUseChmHelp };
HelpControllerType m_helpControllerType;
wxHelpControllerBase* m_helpController;
int m_style;
wxDECLARE_DYNAMIC_CLASS(wxBestHelpController);
wxDECLARE_NO_COPY_CLASS(wxBestHelpController);
};
#endif // wxUSE_HELP && wxUSE_MS_HTML_HELP && wxUSE_WXHTML_HELP
#endif
// _WX_HELPBEST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/registry.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/registry.h
// Purpose: Registry classes and functions
// Author: Vadim Zeitlin
// Modified by:
// Created: 03.04.1998
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_REGISTRY_H_
#define _WX_MSW_REGISTRY_H_
#include "wx/defs.h"
#if wxUSE_REGKEY
class WXDLLIMPEXP_FWD_BASE wxOutputStream;
// ----------------------------------------------------------------------------
// class wxRegKey encapsulates window HKEY handle
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxRegKey
{
public:
// NB: do _not_ change the values of elements in these enumerations!
// registry value types (with comments from winnt.h)
enum ValueType
{
Type_None, // No value type
Type_String, // Unicode nul terminated string
Type_Expand_String, // Unicode nul terminated string
// (with environment variable references)
Type_Binary, // Free form binary
Type_Dword, // 32-bit number
Type_Dword_little_endian // 32-bit number
= Type_Dword, // (same as Type_DWORD)
Type_Dword_big_endian, // 32-bit number
Type_Link, // Symbolic Link (unicode)
Type_Multi_String, // Multiple Unicode strings
Type_Resource_list, // Resource list in the resource map
Type_Full_resource_descriptor, // Resource list in the hardware description
Type_Resource_requirements_list // ???
};
// predefined registry keys
enum StdKey
{
HKCR, // classes root
HKCU, // current user
HKLM, // local machine
HKUSR, // users
HKPD, // (obsolete under XP and later)
HKCC, // current config
HKDD, // (obsolete under XP and later)
HKMAX
};
// access mode for the key
enum AccessMode
{
Read, // read-only
Write // read and write
};
// Different registry views supported under WOW64.
enum WOW64ViewMode
{
// 32 bit registry for 32 bit applications, 64 bit registry
// for 64 bit ones.
WOW64ViewMode_Default,
// Can be used in 64 bit apps to access 32 bit registry,
// has no effect (i.e. treated as default) in 32 bit apps.
WOW64ViewMode_32,
// Can be used in 32 bit apps to access 64 bit registry,
// has no effect (i.e. treated as default) in 64 bit apps.
WOW64ViewMode_64
};
// information about standard (predefined) registry keys
// number of standard keys
static const size_t nStdKeys;
// get the name of a standard key
static const wxChar *GetStdKeyName(size_t key);
// get the short name of a standard key
static const wxChar *GetStdKeyShortName(size_t key);
// get StdKey from root HKEY
static StdKey GetStdKeyFromHkey(WXHKEY hkey);
// extracts the std key prefix from the string (return value) and
// leaves only the part after it (i.e. modifies the string passed!)
static StdKey ExtractKeyName(wxString& str);
// ctors
// root key is set to HKCR (the only root key under Win16)
wxRegKey(WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the full name of the key (i.e. starting with HKEY_xxx...)
wxRegKey(const wxString& strKey,
WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the name of key under (standard key) keyParent
wxRegKey(StdKey keyParent,
const wxString& strKey,
WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the name of key under (previously created) keyParent
wxRegKey(const wxRegKey& keyParent, const wxString& strKey);
// dtor closes the key
~wxRegKey();
// change key (closes the previously opened key if any)
// the name is absolute, i.e. should start with HKEY_xxx
void SetName(const wxString& strKey);
// the name is relative to the parent key
void SetName(StdKey keyParent, const wxString& strKey);
// the name is relative to the parent key
void SetName(const wxRegKey& keyParent, const wxString& strKey);
// hKey should be opened and will be closed in wxRegKey dtor
void SetHkey(WXHKEY hKey);
// get information about the key
// get the (full) key name. Abbreviate std root keys if bShortPrefix.
wxString GetName(bool bShortPrefix = true) const;
// Retrieves the registry view used by this key.
WOW64ViewMode GetView() const { return m_viewMode; }
// return true if the key exists
bool Exists() const;
// get the info about key (any number of these pointers may be NULL)
bool GetKeyInfo(size_t *pnSubKeys, // number of subkeys
size_t *pnMaxKeyLen, // max length of subkey name
size_t *pnValues, // number of values
size_t *pnMaxValueLen) const;
// return true if the key is opened
bool IsOpened() const { return m_hKey != 0; }
// for "if ( !key ) wxLogError(...)" kind of expressions
operator bool() const { return m_dwLastError == 0; }
// operations on the key itself
// explicitly open the key (will be automatically done by all functions
// which need the key to be opened if the key is not opened yet)
bool Open(AccessMode mode = Write);
// create the key: will fail if the key already exists and !bOkIfExists
bool Create(bool bOkIfExists = true);
// rename a value from old name to new one
bool RenameValue(const wxString& szValueOld, const wxString& szValueNew);
// rename the key
bool Rename(const wxString& szNewName);
// copy value to another key possibly changing its name (by default it will
// remain the same)
bool CopyValue(const wxString& szValue, wxRegKey& keyDst,
const wxString& szNewName = wxEmptyString);
// copy the entire contents of the key recursively to another location
bool Copy(const wxString& szNewName);
// same as Copy() but using a key and not the name
bool Copy(wxRegKey& keyDst);
// close the key (will be automatically done in dtor)
bool Close();
// deleting keys/values
// deletes this key and all of it's subkeys/values
bool DeleteSelf();
// deletes the subkey with all of it's subkeys/values recursively
bool DeleteKey(const wxString& szKey);
// deletes the named value (may be empty string to remove the default value)
bool DeleteValue(const wxString& szValue);
// access to values and subkeys
// get value type
ValueType GetValueType(const wxString& szValue) const;
// returns true if the value contains a number (else it's some string)
bool IsNumericValue(const wxString& szValue) const;
// assignment operators set the default value of the key
wxRegKey& operator=(const wxString& strValue)
{ SetValue(wxEmptyString, strValue); return *this; }
// query the default value of the key: implicitly or explicitly
wxString QueryDefaultValue() const;
operator wxString() const { return QueryDefaultValue(); }
// named values
// set the string value
bool SetValue(const wxString& szValue, const wxString& strValue);
// retrieve the string value
bool QueryValue(const wxString& szValue, wxString& strValue) const
{ return QueryValue(szValue, strValue, false); }
// retrieve raw string value
bool QueryRawValue(const wxString& szValue, wxString& strValue) const
{ return QueryValue(szValue, strValue, true); }
// retrieve either raw or expanded string value
bool QueryValue(const wxString& szValue, wxString& strValue, bool raw) const;
// set the numeric value
bool SetValue(const wxString& szValue, long lValue);
// return the numeric value
bool QueryValue(const wxString& szValue, long *plValue) const;
// set the binary value
bool SetValue(const wxString& szValue, const wxMemoryBuffer& buf);
// return the binary value
bool QueryValue(const wxString& szValue, wxMemoryBuffer& buf) const;
// query existence of a key/value
// return true if value exists
bool HasValue(const wxString& szKey) const;
// return true if given subkey exists
bool HasSubKey(const wxString& szKey) const;
// return true if any subkeys exist
bool HasSubkeys() const;
// return true if any values exist
bool HasValues() const;
// return true if the key is empty (nothing under this key)
bool IsEmpty() const { return !HasSubkeys() && !HasValues(); }
// enumerate values and subkeys
bool GetFirstValue(wxString& strValueName, long& lIndex);
bool GetNextValue (wxString& strValueName, long& lIndex) const;
bool GetFirstKey (wxString& strKeyName , long& lIndex);
bool GetNextKey (wxString& strKeyName , long& lIndex) const;
// export the contents of this key and all its subkeys to the given file
// (which won't be overwritten, it's an error if it already exists)
//
// note that we export the key in REGEDIT4 format, not RegSaveKey() binary
// format nor newer REGEDIT5 one
bool Export(const wxString& filename) const;
// same as above but write to the given (opened) stream
bool Export(wxOutputStream& ostr) const;
// for wxRegConfig usage only: preallocate some memory for the name
void ReserveMemoryForName(size_t bytes) { m_strKey.reserve(bytes); }
private:
// common part of all ctors
void Init()
{
m_hKey = (WXHKEY) NULL;
m_dwLastError = 0;
}
// recursive helper for Export()
bool DoExport(wxOutputStream& ostr) const;
// export a single value
bool DoExportValue(wxOutputStream& ostr, const wxString& name) const;
// return the text representation (in REGEDIT4 format) of the value with the
// given name
wxString FormatValue(const wxString& name) const;
WXHKEY m_hKey, // our handle
m_hRootKey; // handle of the top key (i.e. StdKey)
wxString m_strKey; // key name (relative to m_hRootKey)
WOW64ViewMode m_viewMode; // which view to select under WOW64
AccessMode m_mode; // valid only if key is opened
long m_dwLastError; // last error (0 if none)
wxDECLARE_NO_COPY_CLASS(wxRegKey);
};
#endif // wxUSE_REGKEY
#endif // _WX_MSW_REGISTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/statbmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/statbmp.h
// Purpose: wxStaticBitmap class for wxMSW
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATBMP_H_
#define _WX_STATBMP_H_
#include "wx/control.h"
#include "wx/icon.h"
#include "wx/bitmap.h"
extern WXDLLIMPEXP_DATA_CORE(const char) wxStaticBitmapNameStr[];
// a control showing an icon or a bitmap
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
public:
wxStaticBitmap() { Init(); }
wxStaticBitmap(wxWindow *parent,
wxWindowID id,
const wxGDIImage& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr)
{
Init();
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxGDIImage& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual ~wxStaticBitmap() { Free(); }
virtual void SetIcon(const wxIcon& icon) wxOVERRIDE { SetImage(&icon); }
virtual void SetBitmap(const wxBitmap& bitmap) wxOVERRIDE { SetImage(&bitmap); }
virtual wxBitmap GetBitmap() const wxOVERRIDE;
virtual wxIcon GetIcon() const wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// ctor/dtor helpers
void Init();
void Free();
// true if icon/bitmap is valid
bool ImageIsOk() const;
void SetImage(const wxGDIImage* image);
void SetImageNoCopy( wxGDIImage* image );
// draw the bitmap ourselves here if the OS can't do it correctly (if it
// can we leave it to it)
void DoPaintManually(wxPaintEvent& event);
void WXHandleSize(wxSizeEvent& event);
// we can have either an icon or a bitmap
bool m_isIcon;
wxGDIImage *m_image;
// handle used in last call to STM_SETIMAGE
WXHANDLE m_currentHandle;
private:
// Flag indicating whether we own m_currentHandle, i.e. should delete it.
bool m_ownsCurrentHandle;
// Replace the image at the native control level with the given HBITMAP or
// HICON (which can be 0) and destroy the previous image if necessary.
void MSWReplaceImageHandle(WXLPARAM handle);
// Delete the current handle only if we own it.
void DeleteCurrentHandleIfNeeded();
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxStaticBitmap);
};
#endif
// _WX_STATBMP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/slider.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/slider.h
// Purpose: wxSlider class implementation using trackbar control
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SLIDER_H_
#define _WX_SLIDER_H_
class WXDLLIMPEXP_FWD_CORE wxSubwindows;
// Slider
class WXDLLIMPEXP_CORE wxSlider : public wxSliderBase
{
public:
wxSlider() { Init(); }
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)
{
Init();
(void)Create(parent, id, value, minValue, maxValue,
pos, size, style, validator, name);
}
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 ~wxSlider();
// slider methods
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int) wxOVERRIDE;
void SetRange(int minValue, int maxValue) wxOVERRIDE;
int GetMin() const wxOVERRIDE { return m_rangeMin; }
int GetMax() const wxOVERRIDE { return m_rangeMax; }
// Win32-specific slider methods
int GetTickFreq() const wxOVERRIDE { return m_tickFreq; }
void SetPageSize(int pageSize) wxOVERRIDE;
int GetPageSize() const wxOVERRIDE;
void ClearSel() wxOVERRIDE;
void ClearTicks() wxOVERRIDE;
void SetLineSize(int lineSize) wxOVERRIDE;
int GetLineSize() const wxOVERRIDE;
int GetSelEnd() const wxOVERRIDE;
int GetSelStart() const wxOVERRIDE;
void SetSelection(int minPos, int maxPos) wxOVERRIDE;
void SetThumbLength(int len) wxOVERRIDE;
int GetThumbLength() const wxOVERRIDE;
void SetTick(int tickPos) wxOVERRIDE;
// implementation only from now on
WXHWND GetStaticMin() const;
WXHWND GetStaticMax() const;
WXHWND GetEditValue() const;
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE;
// we should let background show through the slider (and its labels)
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Enable(bool show = true) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// format an integer value as string
static wxString Format(int n) { return wxString::Format(wxT("%d"), n); }
// get the boundig box for the slider and possible labels
wxRect GetBoundingBox() const;
// Get the height and, if the pointers are non NULL, widths of both labels.
//
// Notice that the return value will be 0 if we don't have wxSL_LABELS
// style but we do fill widthMin and widthMax even if we don't have
// wxSL_MIN_MAX_LABELS style set so the caller should account for it.
int GetLabelsSize(int *widthMin = NULL, int *widthMax = NULL) const;
// overridden base class virtuals
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
WXHBRUSH DoMSWControlColor(WXHDC pDC, wxColour colBg, WXHWND hWnd) wxOVERRIDE;
// the labels windows, if any
wxSubwindows *m_labels;
// Last background brush we returned from DoMSWControlColor(), see there.
WXHBRUSH m_hBrushBg;
int m_rangeMin;
int m_rangeMax;
int m_pageSize;
int m_lineSize;
int m_tickFreq;
// flag needed to detect whether we're getting THUMBRELEASE event because
// of dragging the thumb or scrolling the mouse wheel
bool m_isDragging;
// Platform-specific implementation of SetTickFreq
virtual void DoSetTickFreq(int freq) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxSlider);
};
#endif // _WX_SLIDER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/crashrpt.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/crashrpt.h
// Purpose: helpers for the structured exception handling (SEH) under Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 13.07.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CRASHRPT_H_
#define _WX_MSW_CRASHRPT_H_
#include "wx/defs.h"
#if wxUSE_CRASHREPORT
struct _EXCEPTION_POINTERS;
// ----------------------------------------------------------------------------
// crash report generation flags
// ----------------------------------------------------------------------------
enum
{
// we always report where the crash occurred
wxCRASH_REPORT_LOCATION = 0,
// if this flag is given, the call stack is dumped
//
// this results in dump/crash report as small as possible, this is the
// default flag
wxCRASH_REPORT_STACK = 1,
// if this flag is given, the values of the local variables are dumped
//
// note that with the current implementation it requires dumping the full
// process address space and so this will result in huge dump file and will
// take some time to generate
//
// it's probably not a good idea to use this by default, start with default
// mini dump and ask your users to set WX_CRASH_FLAGS environment variable
// to 2 or 4 if you need more information in the dump
wxCRASH_REPORT_LOCALS = 2,
// if this flag is given, the values of all global variables are dumped
//
// this creates a much larger mini dump than just wxCRASH_REPORT_STACK but
// still much smaller than wxCRASH_REPORT_LOCALS one
wxCRASH_REPORT_GLOBALS = 4,
// default is to create the smallest possible crash report
wxCRASH_REPORT_DEFAULT = wxCRASH_REPORT_LOCATION | wxCRASH_REPORT_STACK
};
// ----------------------------------------------------------------------------
// wxCrashContext: information about the crash context
// ----------------------------------------------------------------------------
struct WXDLLIMPEXP_BASE wxCrashContext
{
// initialize this object with the given information or from the current
// global exception info which is only valid inside wxApp::OnFatalException
wxCrashContext(_EXCEPTION_POINTERS *ep = NULL);
// get the name for this exception code
wxString GetExceptionString() const;
// exception code
size_t code;
// exception address
void *addr;
// machine-specific registers vaues
struct
{
#ifdef __INTEL__
wxInt32 eax, ebx, ecx, edx, esi, edi,
ebp, esp, eip,
cs, ds, es, fs, gs, ss,
flags;
#endif // __INTEL__
} regs;
};
// ----------------------------------------------------------------------------
// wxCrashReport: this class is used to create crash reports
// ----------------------------------------------------------------------------
struct WXDLLIMPEXP_BASE wxCrashReport
{
// set the name of the file to which the report is written, it is
// constructed from the .exe name by default
static void SetFileName(const wxString& filename);
// return the current file name
static wxString GetFileName();
// write the exception report to the file, return true if it could be done
// or false otherwise
//
// if ep pointer is NULL, the global exception info which is valid only
// inside wxApp::OnFatalException() is used
static bool Generate(int flags = wxCRASH_REPORT_DEFAULT,
_EXCEPTION_POINTERS *ep = NULL);
// generate a crash report from outside of wxApp::OnFatalException(), this
// can be used to take "snapshots" of the program in wxApp::OnAssert() for
// example
static bool GenerateNow(int flags = wxCRASH_REPORT_DEFAULT);
};
#endif // wxUSE_CRASHREPORT
#endif // _WX_MSW_CRASHRPT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/menuitem.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/menuitem.h
// Purpose: wxMenuItem class
// Author: Vadim Zeitlin
// Modified by:
// Created: 11.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _MENUITEM_H
#define _MENUITEM_H
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/bitmap.h"
#if wxUSE_OWNER_DRAWN
#include "wx/ownerdrw.h"
struct tagRECT;
#endif
// ----------------------------------------------------------------------------
// wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuItem : public wxMenuItemBase
#if wxUSE_OWNER_DRAWN
, public wxOwnerDrawn
#endif
{
public:
// ctor & dtor
wxMenuItem(wxMenu *parentMenu = NULL,
int id = wxID_SEPARATOR,
const wxString& name = wxEmptyString,
const wxString& help = wxEmptyString,
wxItemKind kind = wxITEM_NORMAL,
wxMenu *subMenu = NULL);
virtual ~wxMenuItem();
// override base class virtuals
virtual void SetItemLabel(const wxString& strName) wxOVERRIDE;
virtual void Enable(bool bDoEnable = true) wxOVERRIDE;
virtual void Check(bool bDoCheck = true) wxOVERRIDE;
virtual bool IsChecked() const wxOVERRIDE;
// unfortunately needed to resolve ambiguity between
// wxMenuItemBase::IsCheckable() and wxOwnerDrawn::IsCheckable()
bool IsCheckable() const { return wxMenuItemBase::IsCheckable(); }
// the id for a popup menu is really its menu handle (as required by
// ::AppendMenu() API), so this function will return either the id or the
// menu handle depending on what we are
//
// notice that it also returns the id as an unsigned int, as required by
// Win32 API
WXWPARAM GetMSWId() const;
#if WXWIN_COMPATIBILITY_2_8
// compatibility only, don't use in new code
wxDEPRECATED(
wxMenuItem(wxMenu *parentMenu,
int id,
const wxString& text,
const wxString& help,
bool isCheckable,
wxMenu *subMenu = NULL)
);
#endif
void SetBitmaps(const wxBitmap& bmpChecked,
const wxBitmap& bmpUnchecked = wxNullBitmap)
{
DoSetBitmap(bmpChecked, true);
DoSetBitmap(bmpUnchecked, false);
}
void SetBitmap(const wxBitmap& bmp, bool bChecked = true)
{
DoSetBitmap(bmp, bChecked);
}
const wxBitmap& GetBitmap(bool bChecked = true) const
{ return (bChecked ? m_bmpChecked : m_bmpUnchecked); }
#if wxUSE_OWNER_DRAWN
void SetDisabledBitmap(const wxBitmap& bmpDisabled)
{
m_bmpDisabled = bmpDisabled;
SetOwnerDrawn(true);
}
const wxBitmap& GetDisabledBitmap() const
{ return m_bmpDisabled; }
int MeasureAccelWidth() const;
// override wxOwnerDrawn base class virtuals
virtual wxString GetName() const wxOVERRIDE;
virtual bool OnMeasureItem(size_t *pwidth, size_t *pheight) wxOVERRIDE;
virtual bool OnDrawItem(wxDC& dc, const wxRect& rc, wxODAction act, wxODStatus stat) wxOVERRIDE;
protected:
virtual void GetFontToUse(wxFont& font) const wxOVERRIDE;
virtual void GetColourToUse(wxODStatus stat, wxColour& colText, wxColour& colBack) const wxOVERRIDE;
private:
// helper function for draw std menu check mark
void DrawStdCheckMark(WXHDC hdc, const tagRECT* rc, wxODStatus stat);
// helper function to determine if the item must be owner-drawn
bool MSWMustUseOwnerDrawn();
#endif // wxUSE_OWNER_DRAWN
enum BitmapKind
{
Normal,
Checked,
Unchecked
};
// helper function to get a handle for bitmap associated with item
WXHBITMAP GetHBitmapForMenu(BitmapKind kind) const;
// helper function to set/change the bitmap
void DoSetBitmap(const wxBitmap& bmp, bool bChecked);
private:
// common part of all ctors
void Init();
// Return the item position in the menu containing it.
//
// Returns -1 if the item is not attached to a menu or if we can't find its
// position (which is not really supposed to ever happen).
int MSGetMenuItemPos() const;
// item bitmaps
wxBitmap m_bmpChecked, // bitmap to put near the item
m_bmpUnchecked; // (checked is used also for 'uncheckable' items)
#if wxUSE_OWNER_DRAWN
wxBitmap m_bmpDisabled;
#endif // wxUSE_OWNER_DRAWN
// Give wxMenu access to our MSWMustUseOwnerDrawn() and GetHBitmapForMenu().
friend class wxMenu;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuItem);
};
#endif //_MENUITEM_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/ownerdrawnbutton.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ownerdrawnbutton.h
// Purpose: Common base class for wxCheckBox and wxRadioButton
// Author: Vadim Zeitlin
// Created: 2014-05-04
// Copyright: (c) 2014 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_OWNERDRAWNBUTTON_H_
#define _WX_MSW_OWNERDRAWNBUTTON_H_
// ----------------------------------------------------------------------------
// wxMSWOwnerDrawnButton: base class for any kind of Windows buttons
// ----------------------------------------------------------------------------
// This class contains the type-independent part of wxMSWOwnerDrawnButton and
// is implemented in src/msw/control.cpp.
//
// Notice that this class is internal implementation detail only and is
// intentionally not documented. Ideally it wouldn't be even exported from the
// DLL but this somehow breaks building of applications using wxWidgets with
// Intel compiler using LTCG, so we do export it.
class WXDLLIMPEXP_CORE wxMSWOwnerDrawnButtonBase
{
protected:
// Ctor takes the back pointer to the real window, must be non-NULL.
wxMSWOwnerDrawnButtonBase(wxWindow* win) :
m_win(win)
{
m_isPressed =
m_isHot = false;
}
// Explicitly define the destructor even if it's trivial to make it
// protected. This avoids compiler warnings about the fact that this class
// has virtual functions, but no virtual destructor without making the dtor
// virtual which is not needed here as objects are never deleted via
// pointers to this class (and protected dtor enforces this).
//
// Unfortunately g++ 3.4.5 still complains about the dtor being non virtual
// even if it is protected, but actually does not give any warnings if the
// dtor is not defined at all, so work around this 3.4.5 bug inside our
// general g++ workaround.
#if wxCHECK_GCC_VERSION(4, 0)
~wxMSWOwnerDrawnButtonBase() { }
#endif // g++ 4.0+
// Make the control owner drawn if necessary to implement support for the
// given foreground colour.
void MSWMakeOwnerDrawnIfNecessary(const wxColour& colFg);
// Return true if the control is currently owner drawn.
bool MSWIsOwnerDrawn() const;
// Draw the button if the message information about which is provided in
// the given DRAWITEMSTRUCT asks us to do it, otherwise just return false.
bool MSWDrawButton(WXDRAWITEMSTRUCT *item);
// Methods which must be overridden in the derived concrete class.
// Return the style to use for the non-owner-drawn button.
virtual int MSWGetButtonStyle() const = 0;
// Called after reverting button to non-owner drawn state, provides a hook
// for wxCheckBox-specific hack.
virtual void MSWOnButtonResetOwnerDrawn() { }
// Return the flags (such as wxCONTROL_CHECKED) to use for the control when
// drawing it. Notice that this class already takes care of the common
// logic and sets the other wxCONTROL_XXX flags on its own, this method
// really only needs to return the flags depending on the checked state.
virtual int MSWGetButtonCheckedFlag() const = 0;
// Actually draw the check or radio bitmap, typically just by using the
// appropriate wxRendererNative method.
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) = 0;
private:
// Make the control owner drawn or reset it to normal style.
void MSWMakeOwnerDrawn(bool ownerDrawn);
// Event handlers used to update the appearance of owner drawn button.
void OnMouseEnterOrLeave(wxMouseEvent& event);
void OnMouseLeft(wxMouseEvent& event);
void OnFocus(wxFocusEvent& event);
// The real window.
wxWindow* const m_win;
// true if the checkbox is currently pressed
bool m_isPressed;
// true if mouse is currently over the control
bool m_isHot;
wxDECLARE_NO_COPY_CLASS(wxMSWOwnerDrawnButtonBase);
};
// This class uses a weak version of CRTP, i.e. it's a template class taking
// the base class that the class deriving from it would normally derive from.
template <class T>
class wxMSWOwnerDrawnButton
: public T,
private wxMSWOwnerDrawnButtonBase
{
private:
typedef T Base;
public:
wxMSWOwnerDrawnButton() : wxMSWOwnerDrawnButtonBase(this)
{
}
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE
{
if ( !Base::SetForegroundColour(colour) )
return false;
MSWMakeOwnerDrawnIfNecessary(colour);
return true;
}
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE
{
return MSWDrawButton(item) || Base::MSWOnDraw(item);
}
protected:
bool IsOwnerDrawn() const { return MSWIsOwnerDrawn(); }
};
#endif // _WX_MSW_OWNERDRAWNBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/panel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/panel.h
// Purpose: wxMSW-specific wxPanel class.
// Author: Vadim Zeitlin
// Created: 2011-03-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PANEL_H_
#define _WX_MSW_PANEL_H_
class WXDLLIMPEXP_FWD_CORE wxBrush;
// ----------------------------------------------------------------------------
// wxPanel
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPanel : public wxPanelBase
{
public:
wxPanel() { }
wxPanel(wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, winid, pos, size, style, name);
}
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR(
wxPanel(wxWindow *parent,
int x, int y, int width, int height,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, wxID_ANY, wxPoint(x, y), wxSize(width, height), style, name);
}
)
#endif // WXWIN_COMPATIBILITY_2_8
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxPanel);
};
#endif // _WX_MSW_PANEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/calctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/calctrl.h
// Purpose: wxCalendarCtrl control implementation for MSW
// Author: Vadim Zeitlin
// Copyright: (C) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CALCTRL_H_
#define _WX_MSW_CALCTRL_H_
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);
}
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) wxOVERRIDE;
virtual wxDateTime GetDate() const wxOVERRIDE;
virtual bool SetDateRange(const wxDateTime& lowerdate = wxDefaultDateTime,
const wxDateTime& upperdate = wxDefaultDateTime) wxOVERRIDE;
virtual bool GetDateRange(wxDateTime *lowerdate, wxDateTime *upperdate) const wxOVERRIDE;
virtual bool EnableMonthChange(bool enable = true) wxOVERRIDE;
virtual void Mark(size_t day, bool mark) wxOVERRIDE;
virtual void SetHoliday(size_t day) wxOVERRIDE;
virtual wxCalendarHitTestResult HitTest(const wxPoint& pos,
wxDateTime *date = NULL,
wxDateTime::WeekDay *wd = NULL) wxOVERRIDE;
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
void MSWOnClick(wxMouseEvent& event);
void MSWOnDoubleClick(wxMouseEvent& event);
private:
void Init();
// bring the control in sync with m_marks
void UpdateMarks();
// set first day of week in the control to correspond to our
// wxCAL_MONDAY_FIRST flag
void UpdateFirstDayOfWeek();
// reset holiday information
virtual void ResetHolidayAttrs() wxOVERRIDE { m_holidays = 0; }
// redisplay holidays
virtual void RefreshHolidays() wxOVERRIDE { UpdateMarks(); }
// current date, we need to store it instead of simply retrieving it from
// the control as needed in order to be able to generate the correct events
// from MSWOnNotify()
wxDateTime m_date;
// bit field containing the state (marked or not) of all days in the month
wxUint32 m_marks;
// the same but indicating whether a day is a holiday or not
wxUint32 m_holidays;
wxDECLARE_DYNAMIC_CLASS(wxCalendarCtrl);
wxDECLARE_NO_COPY_CLASS(wxCalendarCtrl);
};
#endif // _WX_MSW_CALCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/wrapcdlg.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapcdlg.h
// Purpose: Wrapper for the standard <commdlg.h> header
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 22.03.2005
// Copyright: (c) 2005 Wlodzimierz Skiba
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WRAPCDLG_H_
#define _WX_MSW_WRAPCDLG_H_
#include "wx/defs.h"
#include "wx/msw/wrapwin.h"
#include "wx/msw/private.h"
#include "wx/msw/missing.h"
#if wxUSE_COMMON_DIALOGS
#include <commdlg.h>
#endif
#include "wx/msw/winundef.h"
#endif // _WX_MSW_WRAPCDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/toolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/toolbar.h
// Purpose: wxToolBar class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TBAR95_H_
#define _WX_MSW_TBAR95_H_
#if wxUSE_TOOLBAR
#include "wx/dynarray.h"
#include "wx/imaglist.h"
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
// ctors and dtor
wxToolBar() { Init(); }
wxToolBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr);
virtual ~wxToolBar();
// override/implement base class virtuals
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
virtual void SetToolBitmapSize(const wxSize& size) wxOVERRIDE;
virtual wxSize GetToolSize() const wxOVERRIDE;
virtual void SetRows(int nRows) wxOVERRIDE;
virtual void SetToolNormalBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolDisabledBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolPacking(int packing) wxOVERRIDE;
// implementation only from now on
// -------------------------------
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
void OnMouseEvent(wxMouseEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
void OnEraseBackground(wxEraseEvent& event);
void SetFocus() wxOVERRIDE {}
static WXHBITMAP MapBitmap(WXHBITMAP bitmap, int width, int height);
// override WndProc mainly to process WM_SIZE
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
virtual bool MSWEraseBgHook(WXHDC hDC) wxOVERRIDE;
virtual WXHBRUSH MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child) wxOVERRIDE;
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled = wxNullBitmap,
wxItemKind kind = wxITEM_NORMAL,
wxObject *clientData = NULL,
const wxString& shortHelp = wxEmptyString,
const wxString& longHelp = wxEmptyString) wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// create the native toolbar control
bool MSWCreateToolbar(const wxPoint& pos, const wxSize& size);
// recreate the control completely
void Recreate();
// implement base class pure virtuals
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) wxOVERRIDE;
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
// return the appropriate size and flags for the toolbar control
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// handlers for various events
bool HandleSize(WXWPARAM wParam, WXLPARAM lParam);
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
bool HandlePaint(WXWPARAM wParam, WXLPARAM lParam);
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
void HandleMouseMove(WXWPARAM wParam, WXLPARAM lParam);
// should be called whenever the toolbar size changes
void UpdateSize();
// create m_disabledImgList (but doesn't fill it), set it to NULL if it is
// unneeded
void CreateDisabledImageList();
// get the Windows toolbar style of this control
long GetMSWToolbarStyle() const;
// set native toolbar padding
void MSWSetPadding(WXWORD padding);
// the big bitmap containing all bitmaps of the toolbar buttons
WXHBITMAP m_hBitmap;
// the image list with disabled images, may be NULL if we use
// system-provided versions of them
wxImageList *m_disabledImgList;
// the total number of toolbar elements
size_t m_nButtons;
// the sum of the sizes of the fixed items (i.e. excluding stretchable
// spaces) in the toolbar direction
int m_totalFixedSize;
// the tool the cursor is in
wxToolBarToolBase *m_pInTool;
private:
// makes sure tool bitmap size is sufficient for all tools
void AdjustToolBitmapSize();
// update the sizes of stretchable spacers to consume all extra space we
// have
void UpdateStretchableSpacersSize();
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
// do erase the toolbar background, always do it for the entire control as
// the caller sets the clipping region correctly to exclude parts which
// should not be erased
void MSWDoEraseBackground(WXHDC hDC);
// return the brush to use for erasing the toolbar background
WXHBRUSH MSWGetToolbarBgBrush();
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
wxDECLARE_NO_COPY_CLASS(wxToolBar);
};
#endif // wxUSE_TOOLBAR
#endif // _WX_MSW_TBAR95_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/helpchm.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpchm.h
// Purpose: Help system: MS HTML Help implementation
// Author: Julian Smart
// Modified by:
// Created: 16/04/2000
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_HELPCHM_H_
#define _WX_MSW_HELPCHM_H_
#if wxUSE_MS_HTML_HELP
#include "wx/helpbase.h"
class WXDLLIMPEXP_CORE wxCHMHelpController : public wxHelpControllerBase
{
public:
wxCHMHelpController(wxWindow* parentWindow = NULL): wxHelpControllerBase(parentWindow) { }
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE;
virtual bool DisplayContents() wxOVERRIDE;
virtual bool DisplaySection(int sectionNo) wxOVERRIDE;
virtual bool DisplaySection(const wxString& section) wxOVERRIDE;
virtual bool DisplayBlock(long blockNo) wxOVERRIDE;
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE;
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos) wxOVERRIDE;
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE;
virtual bool Quit() wxOVERRIDE;
wxString GetHelpFile() const { return m_helpFile; }
// helper of DisplayTextPopup(), also used in wxSimpleHelpProvider::ShowHelp
static bool ShowContextHelpPopup(const wxString& text,
const wxPoint& pos,
wxWindow *window);
protected:
// get the name of the CHM file we use from our m_helpFile
wxString GetValidFilename() const;
// Call HtmlHelp() with the provided parameters (both overloads do the same
// thing but allow to avoid casts in the calling code) and return false
// (but don't crash) if HTML help is unavailable
static bool CallHtmlHelp(wxWindow *win, const wxChar *str,
unsigned cmd, WXWPARAM param);
static bool CallHtmlHelp(wxWindow *win, const wxChar *str,
unsigned cmd, const void *param = NULL)
{
return CallHtmlHelp(win, str, cmd, reinterpret_cast<WXWPARAM>(param));
}
// even simpler wrappers using GetParentWindow() and GetValidFilename() as
// the first 2 HtmlHelp() parameters
bool CallHtmlHelp(unsigned cmd, WXWPARAM param)
{
return CallHtmlHelp(GetParentWindow(), GetValidFilename().t_str(),
cmd, param);
}
bool CallHtmlHelp(unsigned cmd, const void *param = NULL)
{
return CallHtmlHelp(cmd, reinterpret_cast<WXWPARAM>(param));
}
// wrapper around CallHtmlHelp(HH_DISPLAY_TEXT_POPUP): only one of text and
// contextId parameters can be non-NULL/non-zero
static bool DoDisplayTextPopup(const wxChar *text,
const wxPoint& pos,
int contextId,
wxWindow *window);
wxString m_helpFile;
wxDECLARE_DYNAMIC_CLASS(wxCHMHelpController);
};
#endif // wxUSE_MS_HTML_HELP
#endif // _WX_MSW_HELPCHM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win64/include/wx/msw/gauge.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/gauge.h
// Purpose: wxGauge implementation for MSW
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_GAUGE_H_
#define _WX_MSW_GAUGE_H_
#if wxUSE_GAUGE
extern WXDLLIMPEXP_DATA_CORE(const char) wxGaugeNameStr[];
// Group box
class WXDLLIMPEXP_CORE wxGauge : public wxGaugeBase
{
public:
wxGauge() { }
wxGauge(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr)
{
(void)Create(parent, id, range, pos, size, style, validator, name);
}
virtual ~wxGauge();
bool Create(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr);
// set gauge range/value
virtual void SetRange(int range) wxOVERRIDE;
virtual void SetValue(int pos) wxOVERRIDE;
// overridden base class virtuals
virtual bool SetForegroundColour(const wxColour& col) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& col) wxOVERRIDE;
virtual void Pulse() wxOVERRIDE;
WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
private:
// returns true if the control is currently in indeterminate (a.k.a.
// "marquee") mode
bool IsInIndeterminateMode() const;
// switch to/from indeterminate mode
void SetIndeterminateMode();
void SetDeterminateMode();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxGauge);
};
#endif // wxUSE_GAUGE
#endif // _WX_MSW_GAUGE_H_
| h |
Subsets and Splits