repo_name
stringclasses 10
values | file_path
stringlengths 29
222
| content
stringlengths 24
926k
| extention
stringclasses 5
values |
|---|---|---|---|
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/frame.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/frame.h
// Purpose: wxFrame class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FRAME_H_
#define _WX_FRAME_H_
#if wxUSE_TASKBARBUTTON
class WXDLLIMPEXP_FWD_CORE wxTaskBarButton;
#endif
class WXDLLIMPEXP_CORE wxFrame : public wxFrameBase
{
public:
// construction
wxFrame() { Init(); }
wxFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual ~wxFrame();
// implement base class pure virtuals
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) wxOVERRIDE;
// implementation only from now on
// -------------------------------
// event handlers
void OnSysColourChanged(wxSysColourChangedEvent& event);
// Toolbar
#if wxUSE_TOOLBAR
virtual wxToolBar* CreateToolBar(long style = -1,
wxWindowID id = wxID_ANY,
const wxString& name = wxToolBarNameStr) wxOVERRIDE;
#endif // wxUSE_TOOLBAR
// Status bar
#if wxUSE_STATUSBAR
virtual wxStatusBar* OnCreateStatusBar(int number = 1,
long style = wxSTB_DEFAULT_STYLE,
wxWindowID id = 0,
const wxString& name = wxStatusLineNameStr) wxOVERRIDE;
// Hint to tell framework which status bar to use: the default is to use
// native one for the platforms which support it (Win32), the generic one
// otherwise
// TODO: should this go into a wxFrameworkSettings class perhaps?
static void UseNativeStatusBar(bool useNative)
{ m_useNativeStatusBar = useNative; }
static bool UsesNativeStatusBar()
{ return m_useNativeStatusBar; }
#endif // wxUSE_STATUSBAR
// event handlers
bool HandleSize(int x, int y, WXUINT flag);
bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);
// tooltip management
#if wxUSE_TOOLTIPS
WXHWND GetToolTipCtrl() const { return m_hwndToolTip; }
void SetToolTipCtrl(WXHWND hwndTT) { m_hwndToolTip = hwndTT; }
#endif // tooltips
// override the base class function to handle iconized/maximized frames
virtual void SendSizeEvent(int flags = 0) wxOVERRIDE;
virtual wxPoint GetClientAreaOrigin() const wxOVERRIDE;
// override base class version to add menu bar accel processing
virtual bool MSWTranslateMessage(WXMSG *msg) wxOVERRIDE
{
return MSWDoTranslateMessage(this, msg);
}
// window proc for the frames
virtual WXLRESULT MSWWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam) wxOVERRIDE;
#if wxUSE_MENUS
// get the currently active menu: this is the same as the frame menu for
// normal frames but is overridden by wxMDIParentFrame
virtual WXHMENU MSWGetActiveMenu() const { return m_hMenu; }
virtual bool HandleMenuSelect(WXWORD nItem, WXWORD nFlags, WXHMENU hMenu) wxOVERRIDE;
virtual bool DoSendMenuOpenCloseEvent(wxEventType evtType, wxMenu* menu) wxOVERRIDE;
// Look up the menu in the menu bar.
virtual wxMenu* MSWFindMenuFromHMENU(WXHMENU hMenu) wxOVERRIDE;
#endif // wxUSE_MENUS
#if wxUSE_TASKBARBUTTON
// Return the taskbar button of the window.
//
// 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 the initialization of taskbar button failed.
wxTaskBarButton* MSWGetTaskBarButton();
#endif // wxUSE_TASKBARBUTTON
protected:
// common part of all ctors
void Init();
// override base class virtuals
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
#if wxUSE_MENUS_NATIVE
// perform MSW-specific action when menubar is changed
virtual void AttachMenuBar(wxMenuBar *menubar) wxOVERRIDE;
// a plug in for MDI frame classes which need to do something special when
// the menubar is set
virtual void InternalSetMenuBar();
#endif // wxUSE_MENUS_NATIVE
// propagate our state change to all child frames
void IconizeChildFrames(bool bIconize);
// the real implementation of MSWTranslateMessage(), also used by
// wxMDIChildFrame
bool MSWDoTranslateMessage(wxFrame *frame, WXMSG *msg);
virtual bool IsMDIChild() const { return false; }
// get default (wxWidgets) icon for the frame
virtual WXHICON GetDefaultIcon() const;
#if wxUSE_TOOLBAR
virtual void PositionToolBar() wxOVERRIDE;
#endif // wxUSE_TOOLBAR
#if wxUSE_STATUSBAR
virtual void PositionStatusBar() wxOVERRIDE;
static bool m_useNativeStatusBar;
#endif // wxUSE_STATUSBAR
#if wxUSE_MENUS
// frame menu, NULL if none
WXHMENU m_hMenu;
// The number of currently opened menus: 0 initially, 1 when a top level
// menu is opened, 2 when its submenu is opened and so on.
int m_menuDepth;
#endif // wxUSE_MENUS
private:
#if wxUSE_TOOLTIPS
WXHWND m_hwndToolTip;
#endif // tooltips
// used by IconizeChildFrames(), see comments there
bool m_wasMinimized;
#if wxUSE_TASKBARBUTTON
wxTaskBarButton* m_taskBarButton;
#endif
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxFrame);
};
#endif
// _WX_FRAME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/bmpcbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/bmpcbox.h
// Purpose: wxBitmapComboBox
// Author: Jaakko Salli
// Created: 2008-04-06
// Copyright: (c) 2008 Jaakko Salli
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_BMPCBOX_H_
#define _WX_MSW_BMPCBOX_H_
#include "wx/combobox.h"
// ----------------------------------------------------------------------------
// wxBitmapComboBox: a wxComboBox that allows images to be shown
// in front of string items.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxBitmapComboBox : public wxComboBox,
public wxBitmapComboBoxBase
{
public:
// ctors and such
wxBitmapComboBox() : wxComboBox(), wxBitmapComboBoxBase()
{
Init();
}
wxBitmapComboBox(wxWindow *parent,
wxWindowID id = wxID_ANY,
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 = wxBitmapComboBoxNameStr)
: wxComboBox(),
wxBitmapComboBoxBase()
{
Init();
(void)Create(parent, id, value, pos, size, n,
choices, style, validator, name);
}
wxBitmapComboBox(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxBitmapComboBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
int n,
const wxString choices[],
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxBitmapComboBoxNameStr);
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 = wxBitmapComboBoxNameStr);
virtual ~wxBitmapComboBox();
// Sets the image for the given item.
virtual void SetItemBitmap(unsigned int n, const wxBitmap& bitmap) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
// Adds item with image to the end of the combo box.
int Append(const wxString& item, const wxBitmap& bitmap = wxNullBitmap);
int Append(const wxString& item, const wxBitmap& bitmap, void *clientData);
int Append(const wxString& item, const wxBitmap& bitmap, wxClientData *clientData);
// Inserts item with image into the list before pos. Not valid for wxCB_SORT
// styles, use Append instead.
int Insert(const wxString& item, const wxBitmap& bitmap, unsigned int pos);
int Insert(const wxString& item, const wxBitmap& bitmap,
unsigned int pos, void *clientData);
int Insert(const wxString& item, const wxBitmap& bitmap,
unsigned int pos, wxClientData *clientData);
protected:
WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE;
virtual bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item) wxOVERRIDE;
// Event handlers
void OnSize(wxSizeEvent& event);
virtual wxItemContainer* GetItemContainer() wxOVERRIDE { return this; }
virtual wxWindow* GetControl() wxOVERRIDE { return this; }
// wxItemContainer implementation
virtual int DoInsertItems(const wxArrayStringsAdapter & items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual bool OnAddBitmap(const wxBitmap& bitmap) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
void RecreateControl();
private:
void Init();
bool m_inResize;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxBitmapComboBox);
};
#endif // _WX_MSW_BMPCBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/statusbar.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/statusbar.h
// Purpose: native implementation of wxStatusBar
// Author: Vadim Zeitlin
// Modified by:
// Created: 04.04.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STATUSBAR_H_
#define _WX_MSW_STATUSBAR_H_
#if wxUSE_NATIVE_STATUSBAR
#include "wx/vector.h"
#include "wx/tooltip.h"
class WXDLLIMPEXP_FWD_CORE wxClientDC;
class WXDLLIMPEXP_CORE wxStatusBar : public wxStatusBarBase
{
public:
// ctors and such
wxStatusBar();
wxStatusBar(wxWindow *parent,
wxWindowID id = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr)
{
m_pDC = NULL;
(void)Create(parent, id, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
long style = wxSTB_DEFAULT_STYLE,
const wxString& name = wxStatusBarNameStr);
virtual ~wxStatusBar();
// implement base class methods
virtual void SetFieldsCount(int number = 1, const int *widths = NULL) wxOVERRIDE;
virtual void SetStatusWidths(int n, const int widths_field[]) wxOVERRIDE;
virtual void SetStatusStyles(int n, const int styles[]) wxOVERRIDE;
virtual void SetMinHeight(int height) wxOVERRIDE;
virtual bool GetFieldRect(int i, wxRect& rect) const wxOVERRIDE;
virtual int GetBorderX() const wxOVERRIDE;
virtual int GetBorderY() const wxOVERRIDE;
// override some wxWindow virtual methods too
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual WXLRESULT MSWWindowProc(WXUINT nMsg,
WXWPARAM wParam,
WXLPARAM lParam) wxOVERRIDE;
protected:
// implement base class pure virtual method
virtual void DoUpdateStatusText(int number) wxOVERRIDE;
// override some base class virtuals
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual bool MSWProcessMessage(WXMSG* pMsg) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result) wxOVERRIDE;
#endif
// implementation of the public SetStatusWidths()
void MSWUpdateFieldsWidths();
// used by DoUpdateStatusText()
wxClientDC *m_pDC;
#if wxUSE_TOOLTIPS
// the tooltips used when wxSTB_SHOW_TIPS is given
wxVector<wxToolTip*> m_tooltips;
#endif
private:
struct MSWBorders
{
int horz,
vert,
between;
};
// retrieve all status bar borders using SB_GETBORDERS
MSWBorders MSWGetBorders() const;
// return the size of the border between the fields
int MSWGetBorderWidth() const;
struct MSWMetrics
{
int gripWidth,
textMargin;
};
// return the various status bar metrics
static const MSWMetrics& MSWGetMetrics();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStatusBar);
};
#endif // wxUSE_NATIVE_STATUSBAR
#endif // _WX_MSW_STATUSBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/statbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/statbox.h
// Purpose: wxStaticBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STATBOX_H_
#define _WX_MSW_STATBOX_H_
#include "wx/compositewin.h"
// Group box
class WXDLLIMPEXP_CORE wxStaticBox : public wxCompositeWindowSettersOnly<wxStaticBoxBase>
{
public:
wxStaticBox()
: wxCompositeWindowSettersOnly<wxStaticBoxBase>()
{
}
wxStaticBox(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr)
: wxCompositeWindowSettersOnly<wxStaticBoxBase>()
{
Create(parent, id, label, pos, size, style, name);
}
wxStaticBox(wxWindow* parent, wxWindowID id,
wxWindow* label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticBoxNameStr)
: wxCompositeWindowSettersOnly<wxStaticBoxBase>()
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
wxWindow* label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
/// Implementation only
virtual void GetBordersForSizer(int *borderTop, int *borderOther) const wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) 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 DoGetBestSize() const wxOVERRIDE;
public:
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
protected:
virtual wxWindowList GetCompositeWindowParts() const wxOVERRIDE;
// return the region with all the windows inside this static box excluded
virtual WXHRGN MSWGetRegionWithoutChildren();
// remove the parts which are painted by static box itself from the given
// region which is embedded in a rectangle (0, 0)-(w, h)
virtual void MSWGetRegionWithoutSelf(WXHRGN hrgn, int w, int h);
// paint the given rectangle with our background brush/colour
virtual void PaintBackground(wxDC& dc, const struct tagRECT& rc);
// paint the foreground of the static box
virtual void PaintForeground(wxDC& dc, const struct tagRECT& rc);
void OnPaint(wxPaintEvent& event);
private:
void PositionLabelWindow();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticBox);
};
// Indicate that we have the ctor overload taking wxWindow as label.
#define wxHAS_WINDOW_LABEL_IN_STATIC_BOX
#endif // _WX_MSW_STATBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/richmsgdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/richmsgdlg.h
// Purpose: wxRichMessageDialog
// Author: Rickard Westerlund
// Created: 2010-07-04
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_RICHMSGDLG_H_
#define _WX_MSW_RICHMSGDLG_H_
class WXDLLIMPEXP_CORE wxRichMessageDialog : public wxGenericRichMessageDialog
{
public:
wxRichMessageDialog(wxWindow *parent,
const wxString& message,
const wxString& caption = wxMessageBoxCaptionStr,
long style = wxOK | wxCENTRE)
: wxGenericRichMessageDialog(parent, message, caption, style)
{ }
// overridden base class method showing the native task dialog if possible
virtual int ShowModal() wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxRichMessageDialog);
};
#endif // _WX_MSW_RICHMSGDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/control.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/control.h
// Purpose: wxControl class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CONTROL_H_
#define _WX_CONTROL_H_
#include "wx/dynarray.h"
// General item class
class WXDLLIMPEXP_CORE wxControl : public wxControlBase
{
public:
wxControl() { }
wxControl(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr);
// Simulates an event
virtual void Command(wxCommandEvent& event) wxOVERRIDE { ProcessCommand(event); }
// implementation from now on
// --------------------------
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// Calls the callback and appropriate event handlers
bool ProcessCommand(wxCommandEvent& event);
// MSW-specific
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
// For ownerdraw items
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *WXUNUSED(item)) { return false; }
virtual bool MSWOnMeasure(WXMEASUREITEMSTRUCT *WXUNUSED(item)) { return false; }
const wxArrayLong& GetSubcontrols() const { return m_subControls; }
// default handling of WM_CTLCOLORxxx: this is public so that wxWindow
// could call it
virtual WXHBRUSH MSWControlColor(WXHDC pDC, WXHWND hWnd);
// default style for the control include WS_TABSTOP if it AcceptsFocus()
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
// Hook for common controls for which we don't want to set the default font
// as if we do set it, the controls don't update their font size
// automatically in response to WM_SETTINGCHANGE if it's changed in the
// display properties in the control panel, so avoid doing this for them.
virtual bool MSWShouldSetDefaultFont() const { return true; }
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE;
// return default best size (doesn't really make any sense, override this)
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// create the control of the given Windows class: this is typically called
// from Create() method of the derived class passing its label, pos and
// size parameter (style parameter is not needed because m_windowStyle is
// supposed to had been already set and so is used instead when this
// function is called)
bool MSWCreateControl(const wxChar *classname,
const wxString& label,
const wxPoint& pos,
const wxSize& size);
// NB: the method below is deprecated now, with MSWGetStyle() the method
// above should be used instead! Once all the controls are updated to
// implement MSWGetStyle() this version will disappear.
//
// create the control of the given class with the given style (combination
// of WS_XXX flags, i.e. Windows style, not wxWidgets one), returns
// false if creation failed
//
// All parameters except classname and style are optional, if the
// size/position are not given, they should be set later with SetSize()
// and, label (the title of the window), of course, is left empty. The
// extended style is determined from the style and the app 3D settings
// automatically if it's not specified explicitly.
bool MSWCreateControl(const wxChar *classname,
WXDWORD style,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& label = wxEmptyString,
WXDWORD exstyle = (WXDWORD)-1);
// call this from the derived class MSWControlColor() if you want to show
// the control greyed out (and opaque)
WXHBRUSH MSWControlColorDisabled(WXHDC pDC);
// common part of the 3 functions above: pass wxNullColour to use the
// appropriate background colour (meaning ours or our parents) or a fixed
// one
virtual WXHBRUSH DoMSWControlColor(WXHDC pDC, wxColour colBg, WXHWND hWnd);
// Look in our GetSubcontrols() for the windows with the given ID.
virtual wxWindow *MSWFindItem(long id, WXHWND hWnd) const wxOVERRIDE;
// for controls like radiobuttons which are really composite this array
// holds the ids (not HWNDs!) of the sub controls
wxArrayLong m_subControls;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxControl);
};
#endif // _WX_CONTROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/fdrepdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/fdrepdlg.h
// Purpose: wxFindReplaceDialog class
// Author: Markus Greither
// Modified by: 31.07.01: VZ: integrated into wxWidgets
// Created: 23/03/2001
// Copyright: (c) Markus Greither
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_FDREPDLG_H_
#define _WX_MSW_FDREPDLG_H_
// ----------------------------------------------------------------------------
// wxFindReplaceDialog: dialog for searching / replacing text
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFindReplaceDialog : public wxFindReplaceDialogBase
{
public:
// ctors and such
wxFindReplaceDialog() { Init(); }
wxFindReplaceDialog(wxWindow *parent,
wxFindReplaceData *data,
const wxString &title,
int style = 0);
bool Create(wxWindow *parent,
wxFindReplaceData *data,
const wxString &title,
int style = 0);
virtual ~wxFindReplaceDialog();
// implementation only from now on
wxFindReplaceDialogImpl *GetImpl() const { return m_impl; }
// override some base class virtuals
virtual bool Show(bool show = true) wxOVERRIDE;
virtual void SetTitle( const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
protected:
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
void Init();
wxString m_title;
wxFindReplaceDialogImpl *m_impl;
wxDECLARE_DYNAMIC_CLASS(wxFindReplaceDialog);
wxDECLARE_NO_COPY_CLASS(wxFindReplaceDialog);
};
#endif // _WX_MSW_FDREPDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/chkconf.h | /*
* Name: wx/msw/chkconf.h
* Purpose: Compiler-specific configuration checking
* Author: Julian Smart
* Modified by:
* Created: 01/02/97
* Copyright: (c) Julian Smart
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_MSW_CHKCONF_H_
#define _WX_MSW_CHKCONF_H_
/* ensure that MSW-specific settings are defined */
#ifndef wxUSE_ACTIVEX
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_ACTIVEX must be defined."
# else
# define wxUSE_ACTIVEX 0
# endif
#endif /* !defined(wxUSE_ACTIVEX) */
#ifndef wxUSE_WINRT
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_WINRT must be defined."
# else
# define wxUSE_WINRT 0
# endif
#endif /* !defined(wxUSE_ACTIVEX) */
#ifndef wxUSE_CRASHREPORT
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_CRASHREPORT must be defined."
# else
# define wxUSE_CRASHREPORT 0
# endif
#endif /* !defined(wxUSE_CRASHREPORT) */
#ifndef wxUSE_DBGHELP
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_DBGHELP must be defined"
# else
# define wxUSE_DBGHELP 1
# endif
#endif /* wxUSE_DBGHELP */
#ifndef wxUSE_DC_CACHEING
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_DC_CACHEING must be defined"
# else
# define wxUSE_DC_CACHEING 1
# endif
#endif /* wxUSE_DC_CACHEING */
#ifndef wxUSE_DIALUP_MANAGER
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_DIALUP_MANAGER must be defined."
# else
# define wxUSE_DIALUP_MANAGER 0
# endif
#endif /* !defined(wxUSE_DIALUP_MANAGER) */
#ifndef wxUSE_MS_HTML_HELP
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_MS_HTML_HELP must be defined."
# else
# define wxUSE_MS_HTML_HELP 0
# endif
#endif /* !defined(wxUSE_MS_HTML_HELP) */
#ifndef wxUSE_INICONF
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_INICONF must be defined."
# else
# define wxUSE_INICONF 0
# endif
#endif /* !defined(wxUSE_INICONF) */
#ifndef wxUSE_OLE
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_OLE must be defined."
# else
# define wxUSE_OLE 0
# endif
#endif /* !defined(wxUSE_OLE) */
#ifndef wxUSE_OLE_AUTOMATION
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_OLE_AUTOMATION must be defined."
# else
# define wxUSE_OLE_AUTOMATION 0
# endif
#endif /* !defined(wxUSE_OLE_AUTOMATION) */
#ifndef wxUSE_TASKBARICON_BALLOONS
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_TASKBARICON_BALLOONS must be defined."
# else
# define wxUSE_TASKBARICON_BALLOONS 0
# endif
#endif /* wxUSE_TASKBARICON_BALLOONS */
#ifndef wxUSE_TASKBARBUTTON
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_TASKBARBUTTON must be defined."
# else
# define wxUSE_TASKBARBUTTON 0
# endif
#endif /* wxUSE_TASKBARBUTTON */
#ifndef wxUSE_UXTHEME
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_UXTHEME must be defined."
# else
# define wxUSE_UXTHEME 0
# endif
#endif /* wxUSE_UXTHEME */
/*
* Unfortunately we can't use compiler TLS support if the library can be used
* inside a dynamically loaded DLL under Windows XP, as this can result in hard
* to diagnose crashes due to the bugs in Windows TLS support, see #13116.
*
* So we disable it unless we can be certain that the code will never run under
* XP, as is the case if we're using a compiler which doesn't support XP such
* as MSVC 11+, unless it's used with the special "_xp" toolset, in which case
* _USING_V110_SDK71_ is defined.
*
* However defining wxUSE_COMPILER_TLS as 2 overrides this safety check, see
* the comments in wx/setup.h.
*/
#if wxUSE_COMPILER_TLS == 1
#if !wxCHECK_VISUALC_VERSION(11) || defined(_USING_V110_SDK71_)
#undef wxUSE_COMPILER_TLS
#define wxUSE_COMPILER_TLS 0
#endif
#endif
/*
* disable the settings which don't work for some compilers
*/
/*
* All of the settings below require SEH support (__try/__catch) and can't work
* without it.
*/
#if !defined(_MSC_VER) && \
(!defined(__BORLANDC__) || __BORLANDC__ < 0x0550)
# undef wxUSE_ON_FATAL_EXCEPTION
# define wxUSE_ON_FATAL_EXCEPTION 0
# undef wxUSE_CRASHREPORT
# define wxUSE_CRASHREPORT 0
#endif /* compiler doesn't support SEH */
#if defined(__GNUWIN32__)
/* These don't work as expected for mingw32 and cygwin32 */
# undef wxUSE_MEMORY_TRACING
# define wxUSE_MEMORY_TRACING 0
# undef wxUSE_GLOBAL_MEMORY_OPERATORS
# define wxUSE_GLOBAL_MEMORY_OPERATORS 0
# undef wxUSE_DEBUG_NEW_ALWAYS
# define wxUSE_DEBUG_NEW_ALWAYS 0
/* some Cygwin versions don't have wcslen */
# if defined(__CYGWIN__) || defined(__CYGWIN32__)
# if ! ((__GNUC__>2) ||((__GNUC__==2) && (__GNUC_MINOR__>=95)))
# undef wxUSE_WCHAR_T
# define wxUSE_WCHAR_T 0
# endif
#endif
#endif /* __GNUWIN32__ */
/* MinGW32 doesn't provide wincred.h defining the API needed by this */
#ifdef __MINGW32_TOOLCHAIN__
#undef wxUSE_SECRETSTORE
#define wxUSE_SECRETSTORE 0
#endif
#if wxUSE_SPINCTRL
# if !wxUSE_SPINBTN
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxSpinCtrl requires wxSpinButton on MSW"
# else
# undef wxUSE_SPINBTN
# define wxUSE_SPINBTN 1
# endif
# endif
#endif
/* wxMSW-specific checks: notice that this file is also used with wxUniv
and can even be used with wxGTK, when building it under Windows.
*/
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
# if !wxUSE_OWNER_DRAWN
# undef wxUSE_CHECKLISTBOX
# define wxUSE_CHECKLISTBOX 0
# endif
# if !wxUSE_CHECKLISTBOX
# undef wxUSE_REARRANGECTRL
# define wxUSE_REARRANGECTRL 0
# endif
#endif
/*
Compiler-specific checks.
*/
/* Borland */
#ifdef __BORLANDC__
#if __BORLANDC__ < 0x500
/* BC++ 4.0 can't compile JPEG library */
# undef wxUSE_LIBJPEG
# define wxUSE_LIBJPEG 0
#endif
/* wxUSE_DEBUG_NEW_ALWAYS = 1 not compatible with BC++ in DLL mode */
#if defined(WXMAKINGDLL) || defined(WXUSINGDLL)
# undef wxUSE_DEBUG_NEW_ALWAYS
# define wxUSE_DEBUG_NEW_ALWAYS 0
#endif
#endif /* __BORLANDC__ */
/*
un/redefine the options which we can't compile (after checking that they're
defined
*/
#ifdef __WINE__
# if wxUSE_ACTIVEX
# undef wxUSE_ACTIVEX
# define wxUSE_ACTIVEX 0
# endif /* wxUSE_ACTIVEX */
#endif /* __WINE__ */
/*
Currently wxUSE_GRAPHICS_CONTEXT is only enabled with MSVC by default, so
only check for wxUSE_ACTIVITYINDICATOR dependency on it if it can be
enabled, otherwise turn the latter off to allow the library to compile.
*/
#if !wxUSE_GRAPHICS_CONTEXT && !defined(_MSC_VER)
# undef wxUSE_ACTIVITYINDICATOR
# define wxUSE_ACTIVITYINDICATOR 0
#endif /* !wxUSE_ACTIVITYINDICATOR && !_MSC_VER */
/* check settings consistency for MSW-specific ones */
#if wxUSE_CRASHREPORT && !wxUSE_ON_FATAL_EXCEPTION
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_CRASHREPORT requires wxUSE_ON_FATAL_EXCEPTION"
# else
# undef wxUSE_CRASHREPORT
# define wxUSE_CRASHREPORT 0
# endif
#endif /* wxUSE_CRASHREPORT */
#if !wxUSE_VARIANT
# if wxUSE_ACTIVEX
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxActiveXContainer requires wxVariant"
# else
# undef wxUSE_ACTIVEX
# define wxUSE_ACTIVEX 0
# endif
# endif
# if wxUSE_OLE_AUTOMATION
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxAutomationObject requires wxVariant"
# else
# undef wxUSE_OLE_AUTOMATION
# define wxUSE_OLE_AUTOMATION 0
# endif
# endif
#endif /* !wxUSE_VARIANT */
#if !wxUSE_DATAOBJ
# if wxUSE_OLE
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_OLE requires wxDataObject"
# else
# undef wxUSE_OLE
# define wxUSE_OLE 0
# endif
# endif
#endif /* !wxUSE_DATAOBJ */
#if !wxUSE_DYNAMIC_LOADER
# if wxUSE_MS_HTML_HELP
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_MS_HTML_HELP requires wxUSE_DYNAMIC_LOADER."
# else
# undef wxUSE_MS_HTML_HELP
# define wxUSE_MS_HTML_HELP 0
# endif
# endif
# if wxUSE_DIALUP_MANAGER
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_DIALUP_MANAGER requires wxUSE_DYNAMIC_LOADER."
# else
# undef wxUSE_DIALUP_MANAGER
# define wxUSE_DIALUP_MANAGER 0
# endif
# endif
#endif /* !wxUSE_DYNAMIC_LOADER */
#if !wxUSE_DYNLIB_CLASS
# if wxUSE_DBGHELP
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_DBGHELP requires wxUSE_DYNLIB_CLASS"
# else
# undef wxUSE_DBGHELP
# define wxUSE_DBGHELP 0
# endif
# endif
# if wxUSE_DC_TRANSFORM_MATRIX
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_DC_TRANSFORM_MATRIX requires wxUSE_DYNLIB_CLASS"
# else
# undef wxUSE_DC_TRANSFORM_MATRIX
# define wxUSE_DC_TRANSFORM_MATRIX 0
# endif
# endif
# if wxUSE_UXTHEME
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_UXTHEME requires wxUSE_DYNLIB_CLASS"
# else
# undef wxUSE_UXTHEME
# define wxUSE_UXTHEME 0
# endif
# endif
# if wxUSE_MEDIACTRL
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_MEDIACTRL requires wxUSE_DYNLIB_CLASS"
# else
# undef wxUSE_MEDIACTRL
# define wxUSE_MEDIACTRL 0
# endif
# endif
# if wxUSE_INKEDIT
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_INKEDIT requires wxUSE_DYNLIB_CLASS"
# else
# undef wxUSE_INKEDIT
# define wxUSE_INKEDIT 0
# endif
# endif
#endif /* !wxUSE_DYNLIB_CLASS */
#if !wxUSE_OLE
# if wxUSE_ACTIVEX
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxActiveXContainer requires wxUSE_OLE"
# else
# undef wxUSE_ACTIVEX
# define wxUSE_ACTIVEX 0
# endif
# endif
# if wxUSE_OLE_AUTOMATION
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxAutomationObject requires wxUSE_OLE"
# else
# undef wxUSE_OLE_AUTOMATION
# define wxUSE_OLE_AUTOMATION 0
# endif
# endif
# if wxUSE_DRAG_AND_DROP
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_DRAG_AND_DROP requires wxUSE_OLE"
# else
# undef wxUSE_DRAG_AND_DROP
# define wxUSE_DRAG_AND_DROP 0
# endif
# endif
#endif /* !wxUSE_OLE */
#if !wxUSE_ACTIVEX
# if wxUSE_MEDIACTRL
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxMediaCtl requires wxActiveXContainer"
# else
# undef wxUSE_MEDIACTRL
# define wxUSE_MEDIACTRL 0
# endif
# endif
# if wxUSE_WEBVIEW
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxWebView requires wxActiveXContainer under MSW"
# else
# undef wxUSE_WEBVIEW
# define wxUSE_WEBVIEW 0
# endif
# endif
#endif /* !wxUSE_ACTIVEX */
#if wxUSE_ACTIVITYINDICATOR && !wxUSE_GRAPHICS_CONTEXT
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_ACTIVITYINDICATOR requires wxGraphicsContext"
# else
# undef wxUSE_ACTIVITYINDICATOR
# define wxUSE_ACTIVITYINDICATOR 0
# endif
#endif /* wxUSE_ACTIVITYINDICATOR */
#if wxUSE_STACKWALKER && !wxUSE_DBGHELP
/*
Don't give an error in this case because wxUSE_DBGHELP could be 0
because the compiler just doesn't support it, there is really no other
choice than to disable wxUSE_STACKWALKER too in this case.
Unfortunately we can't distinguish between the missing compiler support
and explicitly disabling wxUSE_DBGHELP (which would ideally result in
an error if wxUSE_STACKWALKER is not disabled too), but it's better to
avoid giving a compiler error in the former case even if it means not
giving it neither in the latter one.
*/
#undef wxUSE_STACKWALKER
#define wxUSE_STACKWALKER 0
#endif /* wxUSE_STACKWALKER && !wxUSE_DBGHELP */
#if !wxUSE_THREADS
# if wxUSE_FSWATCHER
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxFileSystemWatcher requires wxThread under MSW"
# else
# undef wxUSE_FSWATCHER
# define wxUSE_FSWATCHER 0
# endif
# endif
#endif /* !wxUSE_THREADS */
#if !wxUSE_OLE_AUTOMATION
# if wxUSE_WEBVIEW
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxWebView requires wxUSE_OLE_AUTOMATION under MSW"
# else
# undef wxUSE_WEBVIEW
# define wxUSE_WEBVIEW 0
# endif
# endif
#endif /* !wxUSE_OLE_AUTOMATION */
#if defined(__WXUNIVERSAL__) && wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW && !wxUSE_POSTSCRIPT
# undef wxUSE_POSTSCRIPT
# define wxUSE_POSTSCRIPT 1
#endif
#endif /* _WX_MSW_CHKCONF_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dcprint.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dcprint.h
// Purpose: wxPrinterDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DCPRINT_H_
#define _WX_MSW_DCPRINT_H_
#if wxUSE_PRINTING_ARCHITECTURE
#include "wx/dcprint.h"
#include "wx/cmndata.h"
#include "wx/msw/dc.h"
// ------------------------------------------------------------------------
// wxPrinterDCImpl
//
class WXDLLIMPEXP_CORE wxPrinterDCImpl : public wxMSWDCImpl
{
public:
// Create from print data
wxPrinterDCImpl( wxPrinterDC *owner, const wxPrintData& data );
wxPrinterDCImpl( wxPrinterDC *owner, WXHDC theDC );
// override some base class virtuals
virtual bool StartDoc(const wxString& message) wxOVERRIDE;
virtual void EndDoc() wxOVERRIDE;
virtual void StartPage() wxOVERRIDE;
virtual void EndPage() wxOVERRIDE;
virtual wxRect GetPaperRect() const wxOVERRIDE;
protected:
virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask = false) wxOVERRIDE;
virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
wxCoord width, wxCoord height,
wxDC *source, wxCoord xsrc, wxCoord ysrc,
wxRasterOperationMode rop = wxCOPY, bool useMask = false,
wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) wxOVERRIDE;
virtual void DoGetSize(int *w, int *h) const wxOVERRIDE
{
GetDeviceSize(w, h);
}
// init the dc
void Init();
wxPrintData m_printData;
private:
wxDECLARE_CLASS(wxPrinterDCImpl);
wxDECLARE_NO_COPY_CLASS(wxPrinterDCImpl);
};
// Gets an HDC for the specified printer configuration
WXHDC WXDLLIMPEXP_CORE wxGetPrinterDC(const wxPrintData& data);
// ------------------------------------------------------------------------
// wxPrinterDCromHDC
//
class WXDLLIMPEXP_CORE wxPrinterDCFromHDC: public wxPrinterDC
{
public:
wxPrinterDCFromHDC( WXHDC theDC )
: wxPrinterDC(new wxPrinterDCImpl(this, theDC))
{
}
};
#endif // wxUSE_PRINTING_ARCHITECTURE
#endif // _WX_MSW_DCPRINT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/printdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/printdlg.h
// Purpose: wxPrintDialog, wxPageSetupDialog classes
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRINTDLG_H_
#define _WX_PRINTDLG_H_
#if wxUSE_PRINTING_ARCHITECTURE
#include "wx/dialog.h"
#include "wx/cmndata.h"
#include "wx/prntbase.h"
#include "wx/printdlg.h"
class WXDLLIMPEXP_FWD_CORE wxDC;
class WinPrinter;
//----------------------------------------------------------------------------
// wxWindowsPrintNativeData
//----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowsPrintNativeData: public wxPrintNativeDataBase
{
public:
wxWindowsPrintNativeData();
virtual ~wxWindowsPrintNativeData();
virtual bool TransferTo( wxPrintData &data ) wxOVERRIDE;
virtual bool TransferFrom( const wxPrintData &data ) wxOVERRIDE;
virtual bool Ok() const wxOVERRIDE { return IsOk(); }
virtual bool IsOk() const wxOVERRIDE;
void InitializeDevMode(const wxString &printerName = wxEmptyString, WinPrinter* printer = NULL);
void* GetDevMode() const { return m_devMode; }
void SetDevMode(void* data) { m_devMode = data; }
void* GetDevNames() const { return m_devNames; }
void SetDevNames(void* data) { m_devNames = data; }
private:
void* m_devMode;
void* m_devNames;
short m_customWindowsPaperId;
private:
wxDECLARE_DYNAMIC_CLASS(wxWindowsPrintNativeData);
};
// ---------------------------------------------------------------------------
// wxWindowsPrintDialog: the MSW dialog for printing
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowsPrintDialog : public wxPrintDialogBase
{
public:
wxWindowsPrintDialog(wxWindow *parent, wxPrintDialogData* data = NULL);
wxWindowsPrintDialog(wxWindow *parent, wxPrintData* data);
virtual ~wxWindowsPrintDialog();
bool Create(wxWindow *parent, wxPrintDialogData* data = NULL);
virtual int ShowModal() wxOVERRIDE;
wxPrintDialogData& GetPrintDialogData() wxOVERRIDE { return m_printDialogData; }
wxPrintData& GetPrintData() wxOVERRIDE { return m_printDialogData.GetPrintData(); }
virtual wxDC *GetPrintDC() wxOVERRIDE;
private:
wxPrintDialogData m_printDialogData;
wxPrinterDC* m_printerDC;
bool m_destroyDC;
wxWindow* m_dialogParent;
private:
bool ConvertToNative( wxPrintDialogData &data );
bool ConvertFromNative( wxPrintDialogData &data );
// holds MSW handle
void* m_printDlg;
private:
wxDECLARE_CLASS(wxWindowsPrintDialog);
wxDECLARE_NO_COPY_CLASS(wxWindowsPrintDialog);
};
// ---------------------------------------------------------------------------
// wxWindowsPageSetupDialog: the MSW page setup dialog
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowsPageSetupDialog: public wxPageSetupDialogBase
{
public:
wxWindowsPageSetupDialog();
wxWindowsPageSetupDialog(wxWindow *parent, wxPageSetupDialogData *data = NULL);
virtual ~wxWindowsPageSetupDialog();
bool Create(wxWindow *parent, wxPageSetupDialogData *data = NULL);
virtual int ShowModal() wxOVERRIDE;
bool ConvertToNative( wxPageSetupDialogData &data );
bool ConvertFromNative( wxPageSetupDialogData &data );
virtual wxPageSetupDialogData& GetPageSetupDialogData() wxOVERRIDE { return m_pageSetupData; }
private:
wxPageSetupDialogData m_pageSetupData;
wxWindow* m_dialogParent;
// holds MSW handle
void* m_pageDlg;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxWindowsPageSetupDialog);
};
#endif // wxUSE_PRINTING_ARCHITECTURE
#endif
// _WX_PRINTDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/mimetype.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/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: wxWidgets licence (part of base library)
/////////////////////////////////////////////////////////////////////////////
#ifndef _MIMETYPE_IMPL_H
#define _MIMETYPE_IMPL_H
#include "wx/defs.h"
#if wxUSE_MIMETYPE
#include "wx/mimetype.h"
// ----------------------------------------------------------------------------
// wxFileTypeImpl is the MSW version of wxFileType, this is a private class
// and is never used directly by the application
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxFileTypeImpl
{
public:
// ctor
wxFileTypeImpl() { }
// one of these Init() function must be called (ctor can't take any
// arguments because it's common)
// initialize us with our file type name and extension - in this case
// we will read all other data from the registry
void Init(const wxString& strFileType, const wxString& ext);
// implement accessor functions
bool GetExtensions(wxArrayString& extensions);
bool GetMimeType(wxString *mimeType) const;
bool GetMimeTypes(wxArrayString& mimeTypes) const;
bool GetIcon(wxIconLocation *iconLoc) const;
bool GetDescription(wxString *desc) const;
bool GetOpenCommand(wxString *openCmd,
const wxFileType::MessageParameters& params) const
{
*openCmd = GetExpandedCommand(wxS("open"), params);
return !openCmd->empty();
}
bool GetPrintCommand(wxString *printCmd,
const wxFileType::MessageParameters& params) const
{
*printCmd = GetExpandedCommand(wxS("print"), params);
return !printCmd->empty();
}
size_t GetAllCommands(wxArrayString * verbs, wxArrayString * commands,
const wxFileType::MessageParameters& params) const;
bool Unassociate();
// 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& cmd = wxEmptyString, int index = 0);
// this is called by Associate
bool SetDescription (const wxString& desc);
// This is called by all our own methods modifying the registry to let the
// Windows Shell know about the changes.
//
// It is also called from Associate() and Unassociate() which suppress the
// internally generated notifications using the method below, which is why
// it has to be public.
void MSWNotifyShell();
// Call before/after performing several registry changes in a row to
// temporarily suppress multiple notifications that would be generated for
// them and generate a single one at the end using MSWNotifyShell()
// explicitly.
void MSWSuppressNotifications(bool supress);
wxString
GetExpandedCommand(const wxString& verb,
const wxFileType::MessageParameters& params) const;
private:
// helper function: reads the command corresponding to the specified verb
// from the registry (returns an empty string if not found)
wxString GetCommand(const wxString& verb) const;
// get the registry path for the given verb
wxString GetVerbPath(const wxString& verb) const;
// check that the registry key for our extension exists, create it if it
// doesn't, return false if this failed
bool EnsureExtKeyExists();
wxString m_strFileType, // may be empty
m_ext;
bool m_suppressNotify;
// these methods are not publicly accessible (as wxMimeTypesManager
// doesn't know about them), and should only be called by Unassociate
bool RemoveOpenCommand();
bool RemoveCommand(const wxString& verb);
bool RemoveMimeType();
bool RemoveDefaultIcon();
bool RemoveDescription();
};
class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl
{
public:
// nothing to do here, we don't load any data but just go and fetch it from
// the registry when asked for
wxMimeTypesManagerImpl() { }
// implement containing class functions
wxFileType *GetFileTypeFromExtension(const wxString& ext);
wxFileType *GetOrAllocateFileTypeFromExtension(const wxString& ext);
wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
size_t EnumAllFileTypes(wxArrayString& mimetypes);
// create a new filetype association
wxFileType *Associate(const wxFileTypeInfo& ftInfo);
// create a new filetype with the given name and extension
wxFileType *CreateFileType(const wxString& filetype, const wxString& ext);
};
#endif // wxUSE_MIMETYPE
#endif
//_MIMETYPE_IMPL_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/colordlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/colordlg.h
// Purpose: wxColourDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COLORDLG_H_
#define _WX_COLORDLG_H_
#include "wx/dialog.h"
// ----------------------------------------------------------------------------
// wxColourDialog: dialog for choosing a colours
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxColourDialog : public wxDialog
{
public:
wxColourDialog() { Init(); }
wxColourDialog(wxWindow *parent, wxColourData *data = NULL)
{
Init();
Create(parent, data);
}
bool Create(wxWindow *parent, wxColourData *data = NULL);
wxColourData& GetColourData() { return m_colourData; }
// override some base class virtuals
virtual void SetTitle(const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
virtual int ShowModal() wxOVERRIDE;
// wxMSW-specific implementation from now on
// -----------------------------------------
// called from the hook procedure on WM_INITDIALOG reception
virtual void MSWOnInitDone(WXHWND hDlg);
protected:
// common part of all ctors
void Init();
virtual void DoGetPosition( int *x, int *y ) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoCentre(int dir) wxOVERRIDE;
wxColourData m_colourData;
wxString m_title;
// indicates that the dialog should be centered in this direction if non 0
// (set by DoCentre(), used by MSWOnInitDone())
int m_centreDir;
// true if DoMoveWindow() had been called
bool m_movedWindow;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxColourDialog);
};
#endif // _WX_COLORDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/button.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/button.h
// Purpose: wxButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_BUTTON_H_
#define _WX_MSW_BUTTON_H_
// ----------------------------------------------------------------------------
// Pushbutton
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxButton : public wxButtonBase
{
public:
wxButton() { Init(); }
wxButton(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Init();
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual ~wxButton();
virtual wxWindow *SetDefault() wxOVERRIDE;
// implementation from now on
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
// send a notification event, return true if processed
bool SendClickEvent();
// default button handling
void SetTmpDefault();
void UnsetTmpDefault();
// set or unset BS_DEFPUSHBUTTON style
static void SetDefaultStyle(wxButton *btn, bool on);
virtual bool DoGetAuthNeeded() const wxOVERRIDE;
virtual void DoSetAuthNeeded(bool show) wxOVERRIDE;
// true if the UAC symbol is shown
bool m_authNeeded;
private:
void Init()
{
m_authNeeded = false;
}
void OnCharHook(wxKeyEvent& event);
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxButton);
};
#endif // _WX_MSW_BUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/treectrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/treectrl.h
// Purpose: wxTreeCtrl class
// Author: Julian Smart
// Modified by: Vadim Zeitlin to be less MSW-specific on 10/10/98
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TREECTRL_H_
#define _WX_MSW_TREECTRL_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#if wxUSE_TREECTRL
#include "wx/textctrl.h"
#include "wx/dynarray.h"
#include "wx/treebase.h"
#include "wx/hashmap.h"
#ifdef __GNUWIN32__
// Cygwin windows.h defines these identifiers
#undef GetFirstChild
#undef GetNextSibling
#endif // Cygwin
// fwd decl
class WXDLLIMPEXP_FWD_CORE wxImageList;
class WXDLLIMPEXP_FWD_CORE wxDragImage;
struct WXDLLIMPEXP_FWD_CORE wxTreeViewItem;
// hash storing attributes for our items
class wxItemAttr;
WX_DECLARE_EXPORTED_VOIDPTR_HASH_MAP(wxItemAttr *, wxMapTreeAttr);
// ----------------------------------------------------------------------------
// wxTreeCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTreeCtrl : public wxTreeCtrlBase
{
public:
// creation
// --------
wxTreeCtrl() { Init(); }
wxTreeCtrl(wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTreeCtrlNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
virtual ~wxTreeCtrl();
bool Create(wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTreeCtrlNameStr);
// implement base class pure virtuals
// ----------------------------------
virtual unsigned int GetCount() const wxOVERRIDE;
virtual unsigned int GetIndent() const wxOVERRIDE;
virtual void SetIndent(unsigned int indent) wxOVERRIDE;
virtual void SetImageList(wxImageList *imageList) wxOVERRIDE;
virtual void SetStateImageList(wxImageList *imageList) wxOVERRIDE;
virtual wxString GetItemText(const wxTreeItemId& item) const wxOVERRIDE;
virtual int GetItemImage(const wxTreeItemId& item,
wxTreeItemIcon which = wxTreeItemIcon_Normal) const wxOVERRIDE;
virtual wxTreeItemData *GetItemData(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxColour GetItemTextColour(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxColour GetItemBackgroundColour(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxFont GetItemFont(const wxTreeItemId& item) const wxOVERRIDE;
virtual void SetItemText(const wxTreeItemId& item, const wxString& text) wxOVERRIDE;
virtual void SetItemImage(const wxTreeItemId& item, int image,
wxTreeItemIcon which = wxTreeItemIcon_Normal) wxOVERRIDE;
virtual void SetItemData(const wxTreeItemId& item, wxTreeItemData *data) wxOVERRIDE;
virtual void SetItemHasChildren(const wxTreeItemId& item, bool has = true) wxOVERRIDE;
virtual void SetItemBold(const wxTreeItemId& item, bool bold = true) wxOVERRIDE;
virtual void SetItemDropHighlight(const wxTreeItemId& item,
bool highlight = true) wxOVERRIDE;
virtual void SetItemTextColour(const wxTreeItemId& item,
const wxColour& col) wxOVERRIDE;
virtual void SetItemBackgroundColour(const wxTreeItemId& item,
const wxColour& col) wxOVERRIDE;
virtual void SetItemFont(const wxTreeItemId& item, const wxFont& font) wxOVERRIDE;
// item status inquiries
// ---------------------
virtual bool IsVisible(const wxTreeItemId& item) const wxOVERRIDE;
virtual bool ItemHasChildren(const wxTreeItemId& item) const wxOVERRIDE;
virtual bool IsExpanded(const wxTreeItemId& item) const wxOVERRIDE;
virtual bool IsSelected(const wxTreeItemId& item) const wxOVERRIDE;
virtual bool IsBold(const wxTreeItemId& item) const wxOVERRIDE;
virtual size_t GetChildrenCount(const wxTreeItemId& item,
bool recursively = true) const wxOVERRIDE;
// navigation
// ----------
virtual wxTreeItemId GetRootItem() const wxOVERRIDE;
virtual wxTreeItemId GetSelection() const wxOVERRIDE;
virtual size_t GetSelections(wxArrayTreeItemIds& selections) const wxOVERRIDE;
virtual wxTreeItemId GetFocusedItem() const wxOVERRIDE;
virtual void ClearFocusedItem() wxOVERRIDE;
virtual void SetFocusedItem(const wxTreeItemId& item) wxOVERRIDE;
virtual wxTreeItemId GetItemParent(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxTreeItemId GetFirstChild(const wxTreeItemId& item,
wxTreeItemIdValue& cookie) const wxOVERRIDE;
virtual wxTreeItemId GetNextChild(const wxTreeItemId& item,
wxTreeItemIdValue& cookie) const wxOVERRIDE;
virtual wxTreeItemId GetLastChild(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxTreeItemId GetNextSibling(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxTreeItemId GetFirstVisibleItem() const wxOVERRIDE;
virtual wxTreeItemId GetNextVisible(const wxTreeItemId& item) const wxOVERRIDE;
virtual wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const wxOVERRIDE;
// operations
// ----------
virtual wxTreeItemId AddRoot(const wxString& text,
int image = -1, int selectedImage = -1,
wxTreeItemData *data = NULL) wxOVERRIDE;
virtual void Delete(const wxTreeItemId& item) wxOVERRIDE;
virtual void DeleteChildren(const wxTreeItemId& item) wxOVERRIDE;
virtual void DeleteAllItems() wxOVERRIDE;
virtual void Expand(const wxTreeItemId& item) wxOVERRIDE;
virtual void Collapse(const wxTreeItemId& item) wxOVERRIDE;
virtual void CollapseAndReset(const wxTreeItemId& item) wxOVERRIDE;
virtual void Toggle(const wxTreeItemId& item) wxOVERRIDE;
virtual void Unselect() wxOVERRIDE;
virtual void UnselectAll() wxOVERRIDE;
virtual void SelectItem(const wxTreeItemId& item, bool select = true) wxOVERRIDE;
virtual void SelectChildren(const wxTreeItemId& parent) wxOVERRIDE;
virtual void EnsureVisible(const wxTreeItemId& item) wxOVERRIDE;
virtual void ScrollTo(const wxTreeItemId& item) wxOVERRIDE;
virtual wxTextCtrl *EditLabel(const wxTreeItemId& item,
wxClassInfo* textCtrlClass = wxCLASSINFO(wxTextCtrl)) wxOVERRIDE;
virtual wxTextCtrl *GetEditControl() const wxOVERRIDE;
virtual void EndEditLabel(const wxTreeItemId& WXUNUSED(item),
bool discardChanges = false) wxOVERRIDE
{
DoEndEditLabel(discardChanges);
}
virtual void SortChildren(const wxTreeItemId& item) wxOVERRIDE;
virtual bool GetBoundingRect(const wxTreeItemId& item,
wxRect& rect,
bool textOnly = false) const wxOVERRIDE;
// implementation
// --------------
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXLRESULT MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWShouldPreProcessMessage(WXMSG* msg) wxOVERRIDE;
// override some base class virtuals
virtual bool SetBackgroundColour(const wxColour &colour) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour &colour) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
virtual bool IsDoubleBuffered() const wxOVERRIDE;
virtual void SetDoubleBuffered(bool on) wxOVERRIDE;
protected:
// Implement "update locking" in a custom way for this control.
virtual void DoFreeze() wxOVERRIDE;
virtual void DoThaw() wxOVERRIDE;
virtual bool MSWShouldSetDefaultFont() const wxOVERRIDE { return false; }
// SetImageList helper
void SetAnyImageList(wxImageList *imageList, int which);
// refresh a single item
void RefreshItem(const wxTreeItemId& item);
// end edit label
void DoEndEditLabel(bool discardChanges = false);
virtual int DoGetItemState(const wxTreeItemId& item) const wxOVERRIDE;
virtual void DoSetItemState(const wxTreeItemId& item, int state) wxOVERRIDE;
virtual wxTreeItemId DoInsertItem(const wxTreeItemId& parent,
size_t pos,
const wxString& text,
int image, int selectedImage,
wxTreeItemData *data) wxOVERRIDE;
virtual wxTreeItemId DoInsertAfter(const wxTreeItemId& parent,
const wxTreeItemId& idPrevious,
const wxString& text,
int image = -1, int selImage = -1,
wxTreeItemData *data = NULL) wxOVERRIDE;
virtual wxTreeItemId DoTreeHitTest(const wxPoint& point, int& flags) const wxOVERRIDE;
// obtain the user data for the lParam member of TV_ITEM
class wxTreeItemParam *GetItemParam(const wxTreeItemId& item) const;
// update the event to include the items client data and pass it to
// HandleWindowEvent(), return true if it processed it
bool HandleTreeEvent(wxTreeEvent& event) const;
// pass the event to HandleTreeEvent() and return true if the event was
// either unprocessed or not vetoed
bool IsTreeEventAllowed(wxTreeEvent& event) const
{
return !HandleTreeEvent(event) || event.IsAllowed();
}
// generate a wxEVT_KEY_DOWN event from the specified WPARAM/LPARAM values
// having the same meaning as for WM_KEYDOWN, return true if it was
// processed
bool MSWHandleTreeKeyDownEvent(WXWPARAM wParam, WXLPARAM lParam);
// handle a key event in a multi-selection control, should be only called
// for keys which can be used to change the selection
//
// return true if the key was processed, false otherwise
bool MSWHandleSelectionKey(unsigned vkey);
// data used only while editing the item label:
wxTextCtrl *m_textCtrl; // text control in which it is edited
wxTreeItemId m_idEdited; // the item being edited
private:
// the common part of all ctors
void Init();
// helper functions
bool DoGetItem(wxTreeViewItem *tvItem) const;
void DoSetItem(wxTreeViewItem *tvItem);
void DoExpand(const wxTreeItemId& item, int flag);
void DoSelectItem(const wxTreeItemId& item, bool select = true);
void DoUnselectItem(const wxTreeItemId& item);
void DoToggleItemSelection(const wxTreeItemId& item);
void DoUnselectAll();
void DoSelectChildren(const wxTreeItemId& parent);
void DeleteTextCtrl();
// return true if the item is the hidden root one (i.e. it's the root item
// and the tree has wxTR_HIDE_ROOT style)
bool IsHiddenRoot(const wxTreeItemId& item) const;
// check if the given flags (taken from TV_HITTESTINFO structure)
// indicate a position "on item": this is less trivial than just checking
// for TVHT_ONITEM because we consider that points to the left and right of
// item text are also "on item" when wxTR_FULL_ROW_HIGHLIGHT is used as the
// item visually spans the entire breadth of the window then
bool MSWIsOnItem(unsigned flags) const;
// Delete the given item from the native control.
bool MSWDeleteItem(const wxTreeItemId& item);
// the hash storing the items attributes (indexed by item ids)
wxMapTreeAttr m_attrs;
// true if the hash above is not empty
bool m_hasAnyAttr;
#if wxUSE_DRAGIMAGE
// used for dragging
wxDragImage *m_dragImage;
#endif
// Virtual root item, if wxTR_HIDE_ROOT is set.
void* m_pVirtualRoot;
// the starting item for selection with Shift
wxTreeItemId m_htSelStart, m_htClickedItem;
wxPoint m_ptClick;
// whether dragging has started
bool m_dragStarted;
// whether focus was lost between subsequent clicks of a single item
bool m_focusLost;
// set when we are changing selection ourselves (only used in multi
// selection mode)
bool m_changingSelection;
// whether we need to trigger a state image click event
bool m_triggerStateImageClick;
// whether we need to deselect other items on mouse up
bool m_mouseUpDeselect;
friend class wxTreeItemIndirectData;
friend class wxTreeSortHelper;
wxDECLARE_DYNAMIC_CLASS(wxTreeCtrl);
wxDECLARE_NO_COPY_CLASS(wxTreeCtrl);
};
#endif // wxUSE_TREECTRL
#endif // _WX_MSW_TREECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/textctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/textctrl.h
// Purpose: wxTextCtrl class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TEXTCTRL_H_
#define _WX_TEXTCTRL_H_
class WXDLLIMPEXP_CORE wxTextCtrl : public wxTextCtrlBase
{
public:
// creation
// --------
wxTextCtrl() { Init(); }
wxTextCtrl(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTextCtrlNameStr)
{
Init();
Create(parent, id, value, pos, size, style, validator, name);
}
virtual ~wxTextCtrl();
bool Create(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTextCtrlNameStr);
// overridden wxTextEntry methods
// ------------------------------
virtual wxString GetValue() const wxOVERRIDE;
virtual wxString GetRange(long from, long to) const wxOVERRIDE;
virtual bool IsEmpty() const;
virtual void WriteText(const wxString& text) wxOVERRIDE;
virtual void AppendText(const wxString& text) wxOVERRIDE;
virtual void Clear() wxOVERRIDE;
virtual int GetLineLength(long lineNo) const wxOVERRIDE;
virtual wxString GetLineText(long lineNo) const wxOVERRIDE;
virtual int GetNumberOfLines() const wxOVERRIDE;
virtual void SetMaxLength(unsigned long len) wxOVERRIDE;
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
virtual void SetInsertionPointEnd() wxOVERRIDE;
virtual long GetInsertionPoint() const wxOVERRIDE;
virtual wxTextPos GetLastPosition() const wxOVERRIDE;
// implement base class pure virtuals
// ----------------------------------
virtual bool IsModified() const wxOVERRIDE;
virtual void MarkDirty() wxOVERRIDE;
virtual void DiscardEdits() wxOVERRIDE;
virtual bool EmulateKeyPress(const wxKeyEvent& event) wxOVERRIDE;
#if wxUSE_RICHEDIT
// apply text attribute to the range of text (only works with richedit
// controls)
virtual bool SetStyle(long start, long end, const wxTextAttr& style) wxOVERRIDE;
virtual bool SetDefaultStyle(const wxTextAttr& style) wxOVERRIDE;
virtual bool GetStyle(long position, wxTextAttr& style) wxOVERRIDE;
#endif // wxUSE_RICHEDIT
// translate between the position (which is just an index in the text ctrl
// considering all its contents as a single strings) and (x, y) coordinates
// which represent column and line.
virtual long XYToPosition(long x, long y) const wxOVERRIDE;
virtual bool PositionToXY(long pos, long *x, long *y) const wxOVERRIDE;
virtual void ShowPosition(long pos) wxOVERRIDE;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const wxOVERRIDE;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
wxTextCoord *col,
wxTextCoord *row) const wxOVERRIDE
{
return wxTextCtrlBase::HitTest(pt, col, row);
}
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
virtual wxLayoutDirection GetLayoutDirection() const wxOVERRIDE;
// Caret handling (Windows only)
bool ShowNativeCaret(bool show = true);
bool HideNativeCaret() { return ShowNativeCaret(false); }
// Implementation from now on
// --------------------------
#if wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
virtual void SetDropTarget(wxDropTarget *dropTarget) wxOVERRIDE;
#endif // wxUSE_DRAG_AND_DROP && wxUSE_RICHEDIT
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual WXHBRUSH MSWControlColor(WXHDC hDC, WXHWND hWnd) wxOVERRIDE;
#if wxUSE_RICHEDIT
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
int GetRichVersion() const { return m_verRichEdit; }
bool IsRich() const { return m_verRichEdit != 0; }
// rich edit controls are not compatible with normal ones and we must set
// the colours and font for them otherwise
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
#else
bool IsRich() const { return false; }
#endif // wxUSE_RICHEDIT
#if wxUSE_INKEDIT && wxUSE_RICHEDIT
bool IsInkEdit() const { return m_isInkEdit != 0; }
#else
bool IsInkEdit() const { return false; }
#endif
virtual void AdoptAttributesFromHWND() wxOVERRIDE;
virtual bool AcceptsFocusFromKeyboard() const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE;
// callbacks
void OnDropFiles(wxDropFilesEvent& event);
void OnChar(wxKeyEvent& event); // Process 'enter' if required
void OnCut(wxCommandEvent& event);
void OnCopy(wxCommandEvent& event);
void OnPaste(wxCommandEvent& event);
void OnUndo(wxCommandEvent& event);
void OnRedo(wxCommandEvent& event);
void OnDelete(wxCommandEvent& event);
void OnSelectAll(wxCommandEvent& event);
void OnUpdateCut(wxUpdateUIEvent& event);
void OnUpdateCopy(wxUpdateUIEvent& event);
void OnUpdatePaste(wxUpdateUIEvent& event);
void OnUpdateUndo(wxUpdateUIEvent& event);
void OnUpdateRedo(wxUpdateUIEvent& event);
void OnUpdateDelete(wxUpdateUIEvent& event);
void OnUpdateSelectAll(wxUpdateUIEvent& event);
// Show a context menu for Rich Edit controls (the standard
// EDIT control has one already)
void OnContextMenu(wxContextMenuEvent& event);
#if wxUSE_RICHEDIT
// Create context menu for RICHEDIT controls. This may be called once during
// the control's lifetime or every time the menu is shown, depending on
// implementation.
virtual wxMenu *MSWCreateContextMenu();
#endif // wxUSE_RICHEDIT
// be sure the caret remains invisible if the user
// called HideNativeCaret() before
void OnSetFocus(wxFocusEvent& event);
// intercept WM_GETDLGCODE
virtual bool MSWHandleMessage(WXLRESULT *result,
WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam) wxOVERRIDE;
virtual bool MSWShouldPreProcessMessage(WXMSG* pMsg) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// creates the control of appropriate class (plain or rich edit) with the
// styles corresponding to m_windowStyle
//
// this is used by ctor/Create() and when we need to recreate the control
// later
bool MSWCreateText(const wxString& value,
const wxPoint& pos,
const wxSize& size);
virtual void DoSetValue(const wxString &value, int flags = 0) wxOVERRIDE;
virtual wxPoint DoPositionToCoords(long pos) const wxOVERRIDE;
// return true if this control has a user-set limit on amount of text (i.e.
// the limit is due to a previous call to SetMaxLength() and not built in)
bool HasSpaceLimit(unsigned int *len) const;
#if wxUSE_RICHEDIT && !wxUSE_UNICODE
// replace the selection or the entire control contents with the given text
// in the specified encoding
bool StreamIn(const wxString& value, wxFontEncoding encoding, bool selOnly);
// get the contents of the control out as text in the given encoding
wxString StreamOut(wxFontEncoding encoding, bool selOnly = false) const;
#endif // wxUSE_RICHEDIT
// replace the contents of the selection or of the entire control with the
// given text
void DoWriteText(const wxString& text,
int flags = SetValue_SendEvent | SetValue_SelectionOnly);
// set the selection (possibly without scrolling the caret into view)
void DoSetSelection(long from, long to, int flags) wxOVERRIDE;
// get the length of the line containing the character at the given
// position
long GetLengthOfLineContainingPos(long pos) const;
// send TEXT_UPDATED event, return true if it was handled, false otherwise
bool SendUpdateEvent();
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
#if wxUSE_RICHEDIT
// Apply the character-related parts of wxTextAttr to the given selection
// or the entire control if start == end == -1.
//
// This function is private and should only be called for rich edit
// controls and with (from, to) already in correct order, i.e. from <= to.
bool MSWSetCharFormat(const wxTextAttr& attr, long from = -1, long to = -1);
// Same as above for paragraph-related parts of wxTextAttr. Note that this
// can only be applied to the selection as RichEdit doesn't support setting
// the paragraph styles globally.
bool MSWSetParaFormat(const wxTextAttr& attr, long from, long to);
// Send wxEVT_CONTEXT_MENU event from here if the control doesn't do it on
// its own.
void OnRightUp(wxMouseEvent& event);
// we're using RICHEDIT (and not simple EDIT) control if this field is not
// 0, it also gives the version of the RICHEDIT control being used
// (although not directly: 1 is for 1.0, 2 is for either 2.0 or 3.0 as we
// can't nor really need to distinguish between them and 4 is for 4.1)
int m_verRichEdit;
#endif // wxUSE_RICHEDIT
// number of EN_UPDATE events sent by Windows when we change the controls
// text ourselves: we want this to be exactly 1
int m_updatesCount;
private:
virtual void EnableTextChangedEvents(bool enable) wxOVERRIDE
{
m_updatesCount = enable ? -1 : -2;
}
// implement wxTextEntry pure virtual: it implements all the operations for
// the simple EDIT controls
virtual WXHWND GetEditHWND() const wxOVERRIDE { return m_hWnd; }
#if wxUSE_OLE
virtual void MSWProcessSpecialKey(wxKeyEvent& event) wxOVERRIDE;
#endif // wxUSE_OLE
void OnKeyDown(wxKeyEvent& event);
// Used by EN_MAXTEXT handler to increase the size limit (will do nothing
// if the current limit is big enough). Should never be called directly.
//
// Returns true if we increased the limit to allow entering more text,
// false if we hit the limit set by SetMaxLength() and so didn't change it.
bool AdjustSpaceLimit();
wxMenu* m_privateContextMenu;
bool m_isNativeCaretShown;
#if wxUSE_INKEDIT && wxUSE_RICHEDIT
int m_isInkEdit;
#endif
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTextCtrl);
};
#endif // _WX_TEXTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/enhmeta.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/enhmeta.h
// Purpose: wxEnhMetaFile class for Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 13.01.00
// Copyright: (c) 2000 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_ENHMETA_H_
#define _WX_MSW_ENHMETA_H_
#include "wx/defs.h"
#if wxUSE_ENH_METAFILE
#include "wx/dc.h"
#include "wx/gdiobj.h"
#if wxUSE_DATAOBJ
#include "wx/dataobj.h"
#endif
// ----------------------------------------------------------------------------
// wxEnhMetaFile: encapsulation of Win32 HENHMETAFILE
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxEnhMetaFile : public wxGDIObject
{
public:
wxEnhMetaFile(const wxString& file = wxEmptyString) : m_filename(file)
{ Init(); }
wxEnhMetaFile(const wxEnhMetaFile& metafile) : wxGDIObject()
{ Init(); Assign(metafile); }
wxEnhMetaFile& operator=(const wxEnhMetaFile& metafile)
{ Free(); Assign(metafile); return *this; }
virtual ~wxEnhMetaFile()
{ Free(); }
// display the picture stored in the metafile on the given DC
bool Play(wxDC *dc, wxRect *rectBound = NULL);
// accessors
virtual bool IsOk() const wxOVERRIDE { return m_hMF != 0; }
wxSize GetSize() const;
int GetWidth() const { return GetSize().x; }
int GetHeight() const { return GetSize().y; }
const wxString& GetFileName() const { return m_filename; }
// copy the metafile to the clipboard: the width and height parameters are
// for backwards compatibility (with wxMetaFile) only, they are ignored by
// this method
bool SetClipboard(int width = 0, int height = 0);
// Detach the HENHMETAFILE from this object, i.e. don't delete the handle
// in the dtor -- the caller is now responsible for doing this, e.g. using
// Free() method below.
WXHANDLE Detach() { WXHANDLE h = m_hMF; m_hMF = 0; return h; }
// Destroy the given HENHMETAFILE object.
static void Free(WXHANDLE handle);
// implementation
WXHANDLE GetHENHMETAFILE() const { return m_hMF; }
void SetHENHMETAFILE(WXHANDLE hMF) { Free(); m_hMF = hMF; }
protected:
void Init();
void Free() { Free(m_hMF); }
void Assign(const wxEnhMetaFile& mf);
// we don't use these functions (but probably should) but have to implement
// them as they're pure virtual in the base class
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxString m_filename;
WXHANDLE m_hMF;
wxDECLARE_DYNAMIC_CLASS(wxEnhMetaFile);
};
// ----------------------------------------------------------------------------
// wxEnhMetaFileDC: allows to create a wxEnhMetaFile
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxEnhMetaFileDC : public wxDC
{
public:
// the ctor parameters specify the filename (empty for memory metafiles),
// the metafile picture size and the optional description/comment
wxEnhMetaFileDC(const wxString& filename = wxEmptyString,
int width = 0, int height = 0,
const wxString& description = wxEmptyString);
// as above, but takes reference DC as first argument to take resolution,
// size, font metrics etc. from
explicit
wxEnhMetaFileDC(const wxDC& referenceDC,
const wxString& filename = wxEmptyString,
int width = 0, int height = 0,
const wxString& description = wxEmptyString);
// obtain a pointer to the new metafile (caller should delete it)
wxEnhMetaFile *Close();
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxEnhMetaFileDC);
};
#if wxUSE_DATAOBJ
// ----------------------------------------------------------------------------
// wxEnhMetaFileDataObject is a specialization of wxDataObject for enh metafile
// ----------------------------------------------------------------------------
// notice that we want to support both CF_METAFILEPICT and CF_ENHMETAFILE and
// so we derive from wxDataObject and not from wxDataObjectSimple
class WXDLLIMPEXP_CORE wxEnhMetaFileDataObject : public wxDataObject
{
public:
// ctors
wxEnhMetaFileDataObject() { }
wxEnhMetaFileDataObject(const wxEnhMetaFile& 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 wxEnhMetaFile& metafile)
{ m_metafile = metafile; }
virtual wxEnhMetaFile GetMetafile() const
{ return m_metafile; }
// implement base class pure virtuals
virtual wxDataFormat GetPreferredFormat(Direction dir) const wxOVERRIDE;
virtual size_t GetFormatCount(Direction dir) const wxOVERRIDE;
virtual void GetAllFormats(wxDataFormat *formats, Direction dir) const wxOVERRIDE;
virtual size_t GetDataSize(const wxDataFormat& format) const wxOVERRIDE;
virtual bool GetDataHere(const wxDataFormat& format, void *buf) const wxOVERRIDE;
virtual bool SetData(const wxDataFormat& format, size_t len,
const void *buf) wxOVERRIDE;
protected:
wxEnhMetaFile m_metafile;
wxDECLARE_NO_COPY_CLASS(wxEnhMetaFileDataObject);
};
// ----------------------------------------------------------------------------
// wxEnhMetaFileSimpleDataObject does derive from wxDataObjectSimple which
// makes it more convenient to use (it can be used with wxDataObjectComposite)
// at the price of not supoprting any more CF_METAFILEPICT but only
// CF_ENHMETAFILE
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxEnhMetaFileSimpleDataObject : public wxDataObjectSimple
{
public:
// ctors
wxEnhMetaFileSimpleDataObject() : wxDataObjectSimple(wxDF_ENHMETAFILE) { }
wxEnhMetaFileSimpleDataObject(const wxEnhMetaFile& metafile)
: wxDataObjectSimple(wxDF_ENHMETAFILE), 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 SetEnhMetafile(const wxEnhMetaFile& metafile)
{ m_metafile = metafile; }
virtual wxEnhMetaFile GetEnhMetafile() 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;
virtual size_t GetDataSize(const wxDataFormat& WXUNUSED(format)) const wxOVERRIDE
{ return GetDataSize(); }
virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
void *buf) const wxOVERRIDE
{ return GetDataHere(buf); }
virtual bool SetData(const wxDataFormat& WXUNUSED(format),
size_t len, const void *buf) wxOVERRIDE
{ return SetData(len, buf); }
protected:
wxEnhMetaFile m_metafile;
wxDECLARE_NO_COPY_CLASS(wxEnhMetaFileSimpleDataObject);
};
#endif // wxUSE_DATAOBJ
#endif // wxUSE_ENH_METAFILE
#endif // _WX_MSW_ENHMETA_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ownerdrw.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ownerdrw.h
// Purpose: wxOwnerDrawn class
// Author: Marcin Malich
// Modified by:
// Created: 2009-09-22
// Copyright: (c) 2009 Marcin Malich <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OWNERDRW_H_
#define _WX_OWNERDRW_H_
#if wxUSE_OWNER_DRAWN
class WXDLLIMPEXP_CORE wxOwnerDrawn : public wxOwnerDrawnBase
{
public:
wxOwnerDrawn() {}
virtual ~wxOwnerDrawn() {}
virtual bool OnDrawItem(wxDC& dc, const wxRect& rc,
wxODAction act, wxODStatus stat) wxOVERRIDE;
};
#endif // wxUSE_OWNER_DRAWN
#endif // _WX_OWNERDRW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/fswatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/fswatcher.h
// Purpose: wxMSWFileSystemWatcher
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FSWATCHER_MSW_H_
#define _WX_FSWATCHER_MSW_H_
#include "wx/defs.h"
#if wxUSE_FSWATCHER
class WXDLLIMPEXP_BASE wxMSWFileSystemWatcher : public wxFileSystemWatcherBase
{
public:
wxMSWFileSystemWatcher();
wxMSWFileSystemWatcher(const wxFileName& path,
int events = wxFSW_EVENT_ALL);
// Override the base class function to provide a much more efficient
// implementation for it using the platform native support for watching the
// entire directory trees.
virtual bool AddTree(const wxFileName& path, int events = wxFSW_EVENT_ALL,
const wxString& filter = wxEmptyString) wxOVERRIDE;
protected:
bool Init();
};
#endif // wxUSE_FSWATCHER
#endif /* _WX_FSWATCHER_MSW_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/uuid.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/uuid.h
// Purpose: encapsulates an UUID with some added helper functions
// Author: Vadim Zeitlin
// Modified by:
// Created: 11.07.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
//
// Notes: you should link your project with RPCRT4.LIB!
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OLEUUID_H
#define _WX_OLEUUID_H
#include "wx/chartype.h"
// ------------------------------------------------------------------
// UUID (Universally Unique IDentifier) definition
// ------------------------------------------------------------------
// ----- taken from RPC.H
#ifndef UUID_DEFINED // in some cases RPC.H will be already
typedef struct
{
unsigned long Data1;
unsigned short Data2;
unsigned short Data3;
unsigned char Data4[8];
} UUID; // UUID = GUID = CLSID = LIBID = IID
#endif // UUID_DEFINED
#ifndef GUID_DEFINED
typedef UUID GUID;
#define UUID_DEFINED // prevent redefinition
#endif // GUID_DEFINED
typedef unsigned char uchar;
// ------------------------------------------------------------------
// a class to store UUID and it's string representation
// ------------------------------------------------------------------
// uses RPC functions to create/convert Universally Unique Identifiers
class WXDLLIMPEXP_CORE Uuid
{
private:
UUID m_uuid;
wxUChar *m_pszUuid; // this string is alloc'd and freed by RPC
wxChar *m_pszCForm; // this string is allocated in Set/Create
void UuidToCForm();
// function used to set initial state by all ctors
void Init() { m_pszUuid = NULL; m_pszCForm = NULL; }
public:
// ctors & dtor
Uuid() { Init(); }
Uuid(const wxChar *pc) { Init(); Set(pc); }
Uuid(const UUID &uuid) { Init(); Set(uuid); }
~Uuid();
// copy ctor and assignment operator needed for this class
Uuid(const Uuid& uuid);
Uuid& operator=(const Uuid& uuid);
// create a brand new UUID
void Create();
// set value of UUID
bool Set(const wxChar *pc); // from a string, returns true if ok
void Set(const UUID& uuid); // from another UUID (never fails)
// comparison operators
bool operator==(const Uuid& uuid) const;
bool operator!=(const Uuid& uuid) const { return !(*this == uuid); }
// accessors
operator const UUID*() const { return &m_uuid; }
operator const wxChar*() const { return (wxChar *)(m_pszUuid); }
// return string representation of the UUID in the C form
// (as in DEFINE_GUID macro)
const wxChar *CForm() const { return m_pszCForm; }
};
#endif //_WX_OLEUUID_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/activex.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/activex.h
// Purpose: wxActiveXContainer class
// Author: Ryan Norton <[email protected]>
// Modified by:
// Created: 8/18/05
// Copyright: (c) Ryan Norton
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// Definitions
// ============================================================================
#ifndef _WX_MSW_OLE_ACTIVEXCONTAINER_H_
#define _WX_MSW_OLE_ACTIVEXCONTAINER_H_
#if wxUSE_ACTIVEX
//---------------------------------------------------------------------------
// wx includes
//---------------------------------------------------------------------------
#include "wx/msw/ole/oleutils.h" // wxBasicString &c
#include "wx/msw/ole/uuid.h"
#include "wx/window.h"
#include "wx/variant.h"
class FrameSite;
//---------------------------------------------------------------------------
// MSW COM includes
//---------------------------------------------------------------------------
#include <oleidl.h>
#include <olectl.h>
#include <exdisp.h>
#include <docobj.h>
#ifndef STDMETHOD
#define STDMETHOD(funcname) virtual HRESULT wxSTDCALL funcname
#endif
//
// These defines are from another ole header - but its not in the
// latest sdk. Also the ifndef DISPID_READYSTATE is here because at
// least on my machine with the latest sdk olectl.h defines these 3
//
#ifndef DISPID_READYSTATE
#define DISPID_READYSTATE (-525)
#define DISPID_READYSTATECHANGE (-609)
#define DISPID_AMBIENT_TRANSFERPRIORITY (-728)
#endif
#define DISPID_AMBIENT_OFFLINEIFNOTCONNECTED (-5501)
#define DISPID_AMBIENT_SILENT (-5502)
#ifndef DISPID_AMBIENT_CODEPAGE
#define DISPID_AMBIENT_CODEPAGE (-725)
#define DISPID_AMBIENT_CHARSET (-727)
#endif
//---------------------------------------------------------------------------
//
// wxActiveXContainer
//
//---------------------------------------------------------------------------
template<typename I>
class wxAutoOleInterface
{
public:
typedef I Interface;
explicit wxAutoOleInterface(I *pInterface = NULL) : m_interface(pInterface)
{}
wxAutoOleInterface(REFIID riid, IUnknown *pUnk) : m_interface(NULL)
{ QueryInterface(riid, pUnk); }
wxAutoOleInterface(REFIID riid, IDispatch *pDispatch) : m_interface(NULL)
{ QueryInterface(riid, pDispatch); }
wxAutoOleInterface(REFCLSID clsid, REFIID riid) : m_interface(NULL)
{ CreateInstance(clsid, riid); }
wxAutoOleInterface(const wxAutoOleInterface& ti) : m_interface(NULL)
{ operator=(ti); }
wxAutoOleInterface& operator=(const wxAutoOleInterface& ti)
{
if ( ti.m_interface )
ti.m_interface->AddRef();
Free();
m_interface = ti.m_interface;
return *this;
}
wxAutoOleInterface& operator=(I*& ti)
{
Free();
m_interface = ti;
return *this;
}
~wxAutoOleInterface() { Free(); }
void Free()
{
if ( m_interface )
m_interface->Release();
m_interface = NULL;
}
HRESULT QueryInterface(REFIID riid, IUnknown *pUnk)
{
Free();
wxASSERT(pUnk != NULL);
return pUnk->QueryInterface(riid, (void **)&m_interface);
}
HRESULT CreateInstance(REFCLSID clsid, REFIID riid)
{
Free();
return CoCreateInstance
(
clsid,
NULL,
CLSCTX_ALL,
riid,
(void **)&m_interface
);
}
operator I*() const {return m_interface; }
I* operator->() {return m_interface; }
I** GetRef() {return &m_interface; }
bool Ok() const { return IsOk(); }
bool IsOk() const { return m_interface != NULL; }
protected:
I *m_interface;
};
#if WXWIN_COMPATIBILITY_2_8
// this macro is kept for compatibility with older wx versions
#define WX_DECLARE_AUTOOLE(wxAutoOleInterfaceType, I) \
typedef wxAutoOleInterface<I> wxAutoOleInterfaceType;
#endif // WXWIN_COMPATIBILITY_2_8
typedef wxAutoOleInterface<IDispatch> wxAutoIDispatch;
typedef wxAutoOleInterface<IOleClientSite> wxAutoIOleClientSite;
typedef wxAutoOleInterface<IUnknown> wxAutoIUnknown;
typedef wxAutoOleInterface<IOleObject> wxAutoIOleObject;
typedef wxAutoOleInterface<IOleInPlaceObject> wxAutoIOleInPlaceObject;
typedef wxAutoOleInterface<IOleInPlaceActiveObject> wxAutoIOleInPlaceActiveObject;
typedef wxAutoOleInterface<IOleDocumentView> wxAutoIOleDocumentView;
typedef wxAutoOleInterface<IViewObject> wxAutoIViewObject;
class WXDLLIMPEXP_CORE wxActiveXContainer : public wxWindow
{
public:
wxActiveXContainer(wxWindow * parent, REFIID iid, IUnknown* pUnk);
virtual ~wxActiveXContainer();
void OnSize(wxSizeEvent&);
void OnPaint(wxPaintEvent&);
void OnSetFocus(wxFocusEvent&);
void OnKillFocus(wxFocusEvent&);
virtual bool MSWTranslateMessage(WXMSG* pMsg) wxOVERRIDE;
virtual bool QueryClientSiteInterface(REFIID iid, void **_interface, const char *&desc);
protected:
friend class FrameSite;
friend class wxActiveXEvents;
FrameSite *m_frameSite;
wxAutoIDispatch m_Dispatch;
wxAutoIOleClientSite m_clientSite;
wxAutoIUnknown m_ActiveX;
wxAutoIOleObject m_oleObject;
wxAutoIOleInPlaceObject m_oleInPlaceObject;
wxAutoIOleInPlaceActiveObject m_oleInPlaceActiveObject;
wxAutoIOleDocumentView m_docView;
wxAutoIViewObject m_viewObject;
HWND m_oleObjectHWND;
bool m_bAmbientUserMode;
DWORD m_docAdviseCookie;
wxWindow* m_realparent;
void CreateActiveX(REFIID, IUnknown*);
};
///\brief Store native event parameters.
///\detail Store OLE 'Invoke' parameters for event handlers that need to access them.
/// These are the exact values for the event as they are passed to the wxActiveXContainer.
struct wxActiveXEventNativeMSW
{
DISPID dispIdMember;
REFIID riid;
LCID lcid;
WORD wFlags;
DISPPARAMS *pDispParams;
VARIANT *pVarResult;
EXCEPINFO *pExcepInfo;
unsigned int *puArgErr;
wxActiveXEventNativeMSW
(DISPID a_dispIdMember, REFIID a_riid, LCID a_lcid, WORD a_wFlags, DISPPARAMS *a_pDispParams,
VARIANT *a_pVarResult, EXCEPINFO *a_pExcepInfo, unsigned int *a_puArgErr)
:dispIdMember(a_dispIdMember), riid(a_riid), lcid(a_lcid), wFlags(a_wFlags), pDispParams(a_pDispParams),
pVarResult(a_pVarResult), pExcepInfo(a_pExcepInfo), puArgErr(a_puArgErr)
{ }
};
// Events
class WXDLLIMPEXP_CORE wxActiveXEvent : public wxCommandEvent
{
private:
friend class wxActiveXEvents;
wxVariant m_params;
DISPID m_dispid;
public:
virtual wxEvent *Clone() const wxOVERRIDE
{ return new wxActiveXEvent(*this); }
size_t ParamCount() const;
wxString ParamType(size_t idx) const
{
wxASSERT(idx < ParamCount());
return m_params[idx].GetType();
}
wxString ParamName(size_t idx) const
{
wxASSERT(idx < ParamCount());
return m_params[idx].GetName();
}
wxVariant& operator[] (size_t idx);
DISPID GetDispatchId() const
{ return m_dispid; }
wxActiveXEventNativeMSW *GetNativeParameters() const
{ return (wxActiveXEventNativeMSW*)GetClientData(); }
};
// #define wxACTIVEX_ID 14001
wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_CORE, wxEVT_ACTIVEX, wxActiveXEvent );
typedef void (wxEvtHandler::*wxActiveXEventFunction)(wxActiveXEvent&);
#define wxActiveXEventHandler(func) \
wxEVENT_HANDLER_CAST( wxActiveXEventFunction, func )
#define EVT_ACTIVEX(id, fn) wxDECLARE_EVENT_TABLE_ENTRY(wxEVT_ACTIVEX, id, -1, wxActiveXEventHandler( fn ), NULL ),
#endif // wxUSE_ACTIVEX
#endif // _WX_MSW_OLE_ACTIVEXCONTAINER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/access.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/access.h
// Purpose: declaration of the wxAccessible class
// Author: Julian Smart
// Modified by:
// Created: 2003-02-12
// Copyright: (c) 2003 Julian Smart
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ACCESS_H_
#define _WX_ACCESS_H_
#if wxUSE_ACCESSIBILITY
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
struct IAccessible;
class wxIAccessible;
class WXDLLIMPEXP_FWD_CORE wxWindow;
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// wxAccessible implements accessibility behaviour.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAccessible : public wxAccessibleBase
{
public:
wxAccessible(wxWindow *win = NULL);
virtual ~wxAccessible();
// Overridables
// Accessors
// Returns the wxIAccessible pointer
wxIAccessible* GetIAccessible() { return m_pIAccessible; }
// Returns the IAccessible standard interface pointer
IAccessible* GetIAccessibleStd();
// Operations
// Sends an event when something changes in an accessible object.
static void NotifyEvent(int eventType, wxWindow* window, wxAccObject objectType,
int objectId);
protected:
void Init();
private:
wxIAccessible * m_pIAccessible; // the pointer to COM interface
IAccessible* m_pIAccessibleStd; // the pointer to the standard COM interface,
// for default processing
wxDECLARE_NO_COPY_CLASS(wxAccessible);
};
#endif //wxUSE_ACCESSIBILITY
#endif //_WX_ACCESS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/dataobj2.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/dataobj2.h
// Purpose: second part of platform specific wxDataObject header -
// declarations of predefined wxDataObjectSimple-derived classes
// Author: Vadim Zeitlin
// Modified by:
// Created: 21.10.99
// Copyright: (c) 1999 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_OLE_DATAOBJ2_H
#define _WX_MSW_OLE_DATAOBJ2_H
// ----------------------------------------------------------------------------
// wxBitmapDataObject is a specialization of wxDataObject for bitmap data
//
// NB: in fact, under MSW we support CF_DIB (and not CF_BITMAP) clipboard
// format and we also provide wxBitmapDataObject2 for CF_BITMAP (which is
// rarely used). This is ugly, but I haven't found a solution for it yet.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapDataObject : public wxBitmapDataObjectBase
{
public:
// ctors
wxBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
: wxBitmapDataObjectBase(bitmap)
{
SetFormat(wxDF_DIB);
m_data = NULL;
}
// 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;
virtual size_t GetDataSize(const wxDataFormat& WXUNUSED(format)) const wxOVERRIDE
{ return GetDataSize(); }
virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
void *buf) const wxOVERRIDE
{ return GetDataHere(buf); }
virtual bool SetData(const wxDataFormat& WXUNUSED(format),
size_t len, const void *buf) wxOVERRIDE
{ return SetData(len, buf); }
private:
// the DIB data
void /* BITMAPINFO */ *m_data;
wxDECLARE_NO_COPY_CLASS(wxBitmapDataObject);
};
// ----------------------------------------------------------------------------
// wxBitmapDataObject2 - a data object for CF_BITMAP
//
// FIXME did I already mention it was ugly?
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapDataObject2 : public wxBitmapDataObjectBase
{
public:
// ctors
wxBitmapDataObject2(const wxBitmap& bitmap = wxNullBitmap)
: wxBitmapDataObjectBase(bitmap)
{
}
// 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;
virtual size_t GetDataSize(const wxDataFormat& WXUNUSED(format)) const wxOVERRIDE
{ return GetDataSize(); }
virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
void *buf) const wxOVERRIDE
{ return GetDataHere(buf); }
virtual bool SetData(const wxDataFormat& WXUNUSED(format),
size_t len, const void *buf) wxOVERRIDE
{ return SetData(len, buf); }
private:
wxDECLARE_NO_COPY_CLASS(wxBitmapDataObject2);
};
// ----------------------------------------------------------------------------
// wxFileDataObject - data object for CF_HDROP
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDataObject : public wxFileDataObjectBase
{
public:
wxFileDataObject() { }
// implement base class pure virtuals
virtual bool SetData(size_t len, const void *buf) wxOVERRIDE;
virtual size_t GetDataSize() const wxOVERRIDE;
virtual bool GetDataHere(void *pData) const wxOVERRIDE;
virtual void AddFile(const wxString& file);
virtual size_t GetDataSize(const wxDataFormat& WXUNUSED(format)) const wxOVERRIDE
{ return GetDataSize(); }
virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
void *buf) const wxOVERRIDE
{ return GetDataHere(buf); }
virtual bool SetData(const wxDataFormat& WXUNUSED(format),
size_t len, const void *buf) wxOVERRIDE
{ return SetData(len, buf); }
private:
wxDECLARE_NO_COPY_CLASS(wxFileDataObject);
};
// ----------------------------------------------------------------------------
// wxURLDataObject: data object for URLs
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxURLDataObject : public wxDataObjectComposite
{
public:
// initialize with URL in ctor or use SetURL later
wxURLDataObject(const wxString& url = wxEmptyString);
// return the URL as string
wxString GetURL() const;
// Set a string as the URL in the data object
void SetURL(const wxString& url);
// override to set m_textFormat
virtual bool SetData(const wxDataFormat& format,
size_t len,
const void *buf) wxOVERRIDE;
private:
// last data object we got data in
wxDataObjectSimple *m_dataObjectLast;
wxDECLARE_NO_COPY_CLASS(wxURLDataObject);
};
#endif // _WX_MSW_OLE_DATAOBJ2_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/dataform.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/dataform.h
// Purpose: declaration of the wxDataFormat class
// Author: Vadim Zeitlin
// Modified by:
// Created: 19.10.99 (extracted from msw/ole/dataobj.h)
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_OLE_DATAFORM_H
#define _WX_MSW_OLE_DATAFORM_H
// ----------------------------------------------------------------------------
// wxDataFormat identifies the single format of data
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDataFormat
{
public:
// the clipboard formats under Win32 are WORD's
typedef unsigned short NativeFormat;
wxDataFormat(NativeFormat format = wxDF_INVALID) { m_format = format; }
// we need constructors from all string types as implicit conversions to
// wxString don't apply when we already rely on implicit conversion of a,
// for example, "char *" string to wxDataFormat, and existing code does it
wxDataFormat(const wxString& format) { SetId(format); }
wxDataFormat(const char *format) { SetId(format); }
wxDataFormat(const wchar_t *format) { SetId(format); }
wxDataFormat(const wxCStrData& format) { SetId(format); }
wxDataFormat& operator=(NativeFormat format)
{ m_format = format; return *this; }
wxDataFormat& operator=(const wxDataFormat& format)
{ m_format = format.m_format; return *this; }
// default copy ctor/assignment operators ok
// comparison (must have both versions)
bool operator==(wxDataFormatId format) const;
bool operator!=(wxDataFormatId format) const;
bool operator==(const wxDataFormat& format) const;
bool operator!=(const wxDataFormat& format) const;
// 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; }
// this works with standard as well as custom ids
void SetType(NativeFormat format) { m_format = format; }
NativeFormat GetType() const { return m_format; }
// string ids are used for custom types - this SetId() must be used for
// application-specific formats
wxString GetId() const;
void SetId(const wxString& format);
// returns true if the format is one of those defined in wxDataFormatId
bool IsStandard() const { return m_format > 0 && m_format < wxDF_PRIVATE; }
private:
NativeFormat m_format;
};
#endif // _WX_MSW_OLE_DATAFORM_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/comimpl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/comimpl.h
// Purpose: COM helper routines, COM debugging support &c
// Author: Vadim Zeitlin
// Modified by:
// Created: 19.02.1998
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef WX_COMIMPL_H
#define WX_COMIMPL_H
#include "wx/defs.h"
#include "wx/msw/wrapwin.h"
// get IUnknown, REFIID &c
#include <objbase.h>
// ============================================================================
// General purpose functions and macros
// ============================================================================
// release the interface pointer (if !NULL)
inline void ReleaseInterface(IUnknown *pIUnk)
{
if ( pIUnk != NULL )
pIUnk->Release();
}
// release the interface pointer (if !NULL) and make it NULL
#define RELEASE_AND_NULL(p) if ( (p) != NULL ) { p->Release(); p = NULL; };
// return true if the iid is in the array
extern WXDLLIMPEXP_CORE bool IsIidFromList(REFIID riid, const IID *aIids[], size_t nCount);
// ============================================================================
// IUnknown implementation helpers
// ============================================================================
/*
The most dumb implementation of IUnknown methods. We don't support
aggregation nor containment, but for 99% of cases this simple
implementation is quite enough.
Usage is trivial: here is all you should have
1) DECLARE_IUNKNOWN_METHODS in your (IUnknown derived!) class declaration
2) BEGIN/END_IID_TABLE with ADD_IID in between for all interfaces you
support (at least all for which you intent to return 'this' from QI,
i.e. you should derive from IFoo if you have ADD_IID(Foo)) somewhere else
3) IMPLEMENT_IUNKNOWN_METHODS somewhere also
These macros are quite simple: AddRef and Release are trivial and QI does
lookup in a static member array of IIDs and returns 'this' if it founds
the requested interface in it or E_NOINTERFACE if not.
*/
/*
wxAutoULong: this class is used for automatically initalising m_cRef to 0
*/
class wxAutoULong
{
public:
wxAutoULong(ULONG value = 0) : m_Value(value) { }
operator ULONG&() { return m_Value; }
ULONG& operator=(ULONG value) { m_Value = value; return m_Value; }
wxAutoULong& operator++() { ++m_Value; return *this; }
const wxAutoULong operator++( int ) { wxAutoULong temp = *this; ++m_Value; return temp; }
wxAutoULong& operator--() { --m_Value; return *this; }
const wxAutoULong operator--( int ) { wxAutoULong temp = *this; --m_Value; return temp; }
private:
ULONG m_Value;
};
// declare the methods and the member variable containing reference count
// you must also define the ms_aIids array somewhere with BEGIN_IID_TABLE
// and friends (see below)
#define DECLARE_IUNKNOWN_METHODS \
public: \
STDMETHODIMP QueryInterface(REFIID, void **) wxOVERRIDE; \
STDMETHODIMP_(ULONG) AddRef() wxOVERRIDE; \
STDMETHODIMP_(ULONG) Release() wxOVERRIDE; \
private: \
static const IID *ms_aIids[]; \
wxAutoULong m_cRef
// macros for declaring supported interfaces
// NB: ADD_IID prepends IID_I whereas ADD_RAW_IID does not
#define BEGIN_IID_TABLE(cname) const IID *cname::ms_aIids[] = {
#define ADD_IID(iid) &IID_I##iid,
#define ADD_RAW_IID(iid) &iid,
#define END_IID_TABLE }
// implementation is as straightforward as possible
// Parameter: classname - the name of the class
#define IMPLEMENT_IUNKNOWN_METHODS(classname) \
STDMETHODIMP classname::QueryInterface(REFIID riid, void **ppv) \
{ \
wxLogQueryInterface(wxT(#classname), riid); \
\
if ( IsIidFromList(riid, ms_aIids, WXSIZEOF(ms_aIids)) ) { \
*ppv = this; \
AddRef(); \
\
return S_OK; \
} \
else { \
*ppv = NULL; \
\
return (HRESULT) E_NOINTERFACE; \
} \
} \
\
STDMETHODIMP_(ULONG) classname::AddRef() \
{ \
wxLogAddRef(wxT(#classname), m_cRef); \
\
return ++m_cRef; \
} \
\
STDMETHODIMP_(ULONG) classname::Release() \
{ \
wxLogRelease(wxT(#classname), m_cRef); \
\
if ( --m_cRef == wxAutoULong(0) ) { \
delete this; \
return 0; \
} \
else \
return m_cRef; \
}
// ============================================================================
// Debugging support
// ============================================================================
// VZ: I don't know it's not done for compilers other than VC++ but I leave it
// as is. Please note, though, that tracing COM interface calls may be
// incredibly useful when debugging COM programs.
#if defined(__WXDEBUG__) && defined(__VISUALC__)
// ----------------------------------------------------------------------------
// All COM specific log functions have DebugTrace level (as LogTrace)
// ----------------------------------------------------------------------------
// tries to translate riid into a symbolic name, if possible
WXDLLIMPEXP_CORE void wxLogQueryInterface(const wxChar *szInterface, REFIID riid);
// these functions print out the new value of reference counter
WXDLLIMPEXP_CORE void wxLogAddRef (const wxChar *szInterface, ULONG cRef);
WXDLLIMPEXP_CORE void wxLogRelease(const wxChar *szInterface, ULONG cRef);
#else //!__WXDEBUG__
#define wxLogQueryInterface(szInterface, riid)
#define wxLogAddRef(szInterface, cRef)
#define wxLogRelease(szInterface, cRef)
#endif //__WXDEBUG__
#endif // WX_COMIMPL_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/droptgt.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/droptgt.h
// Purpose: declaration of the wxDropTarget class
// Author: Vadim Zeitlin
// Modified by:
// Created: 06.03.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OLEDROPTGT_H
#define _WX_OLEDROPTGT_H
#if wxUSE_DRAG_AND_DROP
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class wxIDropTarget;
struct wxIDropTargetHelper;
struct IDataObject;
// ----------------------------------------------------------------------------
// An instance of the class wxDropTarget may be associated with any wxWindow
// derived object via SetDropTarget() function. If this is done, the virtual
// methods of wxDropTarget are called when something is dropped on the window.
//
// Note that wxDropTarget is an abstract base class (ABC) and you should derive
// your own class from it implementing pure virtual function in order to use it
// (all of them, including protected ones which are called by the class itself)
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDropTarget : public wxDropTargetBase
{
public:
// ctor & dtor
wxDropTarget(wxDataObject *dataObject = NULL);
virtual ~wxDropTarget();
// normally called by wxWindow on window creation/destruction, but might be
// called `manually' as well. Register() returns true on success.
bool Register(WXHWND hwnd);
void Revoke(WXHWND hwnd);
// provide default implementation for base class pure virtuals
virtual bool OnDrop(wxCoord x, wxCoord y) wxOVERRIDE;
virtual bool GetData() wxOVERRIDE;
// Can only be called during OnXXX methods.
wxDataFormat GetMatchingPair();
// implementation only from now on
// -------------------------------
// do we accept this kind of data?
bool MSWIsAcceptedData(IDataObject *pIDataSource) const;
// give us the data source from IDropTarget::Drop() - this is later used by
// GetData() when it's called from inside OnData()
void MSWSetDataSource(IDataObject *pIDataSource);
// These functions take care of all things necessary to support native drag
// images.
//
// {Init,End}DragImageSupport() are called during Register/Revoke,
// UpdateDragImageOnXXX() functions are called on the corresponding drop
// target events.
void MSWInitDragImageSupport();
void MSWEndDragImageSupport();
void MSWUpdateDragImageOnData(wxCoord x, wxCoord y, wxDragResult res);
void MSWUpdateDragImageOnDragOver(wxCoord x, wxCoord y, wxDragResult res);
void MSWUpdateDragImageOnEnter(wxCoord x, wxCoord y, wxDragResult res);
void MSWUpdateDragImageOnLeave();
private:
// helper used by IsAcceptedData() and GetData()
wxDataFormat MSWGetSupportedFormat(IDataObject *pIDataSource) const;
wxIDropTarget *m_pIDropTarget; // the pointer to our COM interface
IDataObject *m_pIDataSource; // the pointer to the source data object
wxIDropTargetHelper *m_dropTargetHelper; // the drop target helper
wxDECLARE_NO_COPY_CLASS(wxDropTarget);
};
#endif //wxUSE_DRAG_AND_DROP
#endif //_WX_OLEDROPTGT_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/oleutils.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/oleutils.h
// Purpose: OLE helper routines, OLE debugging support &c
// Author: Vadim Zeitlin
// Modified by:
// Created: 19.02.1998
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OLEUTILS_H
#define _WX_OLEUTILS_H
#include "wx/defs.h"
#if wxUSE_OLE
// ole2.h includes windows.h, so include wrapwin.h first
#include "wx/msw/wrapwin.h"
// get IUnknown, REFIID &c
#include <ole2.h>
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/variant.h"
#include "wx/msw/ole/comimpl.h"
// ============================================================================
// General purpose functions and macros
// ============================================================================
// ----------------------------------------------------------------------------
// initialize/cleanup OLE
// ----------------------------------------------------------------------------
// call OleInitialize() or CoInitialize[Ex]() depending on the platform
//
// return true if ok, false otherwise
inline bool wxOleInitialize()
{
const HRESULT
hr = ::OleInitialize(NULL);
// RPC_E_CHANGED_MODE indicates that OLE had been already initialized
// before, albeit with different mode. Don't consider it to be an error as
// we don't actually care ourselves about the mode used so this allows the
// main application to call OleInitialize() on its own before we do if it
// needs non-default mode.
if ( hr != RPC_E_CHANGED_MODE && FAILED(hr) )
{
wxLogError(wxGetTranslation("Cannot initialize OLE"));
return false;
}
return true;
}
inline void wxOleUninitialize()
{
::OleUninitialize();
}
// wrapper around BSTR type (by Vadim Zeitlin)
class WXDLLIMPEXP_CORE wxBasicString
{
public:
// Constructs with the owned BSTR set to NULL
wxBasicString() : m_bstrBuf(NULL) {}
// Constructs with the owned BSTR created from a wxString
wxBasicString(const wxString& str)
: m_bstrBuf(SysAllocString(str.wc_str(*wxConvCurrent))) {}
// Constructs with the owned BSTR as a copy of the BSTR owned by bstr
wxBasicString(const wxBasicString& bstr) : m_bstrBuf(bstr.Copy()) {}
// Frees the owned BSTR
~wxBasicString() { SysFreeString(m_bstrBuf); }
// Creates the owned BSTR from a wxString
void AssignFromString(const wxString& str);
// Returns the owned BSTR and gives up its ownership,
// the caller is responsible for freeing it
BSTR Detach();
// Returns a copy of the owned BSTR,
// the caller is responsible for freeing it
BSTR Copy() const { return SysAllocString(m_bstrBuf); }
// Returns the address of the owned BSTR, not to be called
// when wxBasicString already contains a non-NULL BSTR
BSTR* ByRef();
// Sets its BSTR to a copy of the BSTR owned by bstr
wxBasicString& operator=(const wxBasicString& bstr);
/// Returns the owned BSTR while keeping its ownership
operator BSTR() const { return m_bstrBuf; }
// retrieve a copy of our string - caller must SysFreeString() it later!
wxDEPRECATED_MSG("use Copy() instead")
BSTR Get() const { return Copy(); }
private:
// actual string
BSTR m_bstrBuf;
};
#if wxUSE_VARIANT
// Convert variants
class WXDLLIMPEXP_FWD_BASE wxVariant;
// wrapper for CURRENCY type used in VARIANT (VARIANT.vt == VT_CY)
class WXDLLIMPEXP_CORE wxVariantDataCurrency : public wxVariantData
{
public:
wxVariantDataCurrency() { VarCyFromR8(0.0, &m_value); }
wxVariantDataCurrency(CURRENCY value) { m_value = value; }
CURRENCY GetValue() const { return m_value; }
void SetValue(CURRENCY value) { m_value = value; }
virtual bool Eq(wxVariantData& data) const wxOVERRIDE;
#if wxUSE_STD_IOSTREAM
virtual bool Write(wxSTD ostream& str) const wxOVERRIDE;
#endif
virtual bool Write(wxString& str) const wxOVERRIDE;
wxVariantData* Clone() const wxOVERRIDE { return new wxVariantDataCurrency(m_value); }
virtual wxString GetType() const wxOVERRIDE { return wxS("currency"); }
DECLARE_WXANY_CONVERSION()
private:
CURRENCY m_value;
};
// wrapper for SCODE type used in VARIANT (VARIANT.vt == VT_ERROR)
class WXDLLIMPEXP_CORE wxVariantDataErrorCode : public wxVariantData
{
public:
wxVariantDataErrorCode(SCODE value = S_OK) { m_value = value; }
SCODE GetValue() const { return m_value; }
void SetValue(SCODE value) { m_value = value; }
virtual bool Eq(wxVariantData& data) const wxOVERRIDE;
#if wxUSE_STD_IOSTREAM
virtual bool Write(wxSTD ostream& str) const wxOVERRIDE;
#endif
virtual bool Write(wxString& str) const wxOVERRIDE;
wxVariantData* Clone() const wxOVERRIDE { return new wxVariantDataErrorCode(m_value); }
virtual wxString GetType() const wxOVERRIDE { return wxS("errorcode"); }
DECLARE_WXANY_CONVERSION()
private:
SCODE m_value;
};
// wrapper for SAFEARRAY, used for passing multidimensional arrays in wxVariant
class WXDLLIMPEXP_CORE wxVariantDataSafeArray : public wxVariantData
{
public:
explicit wxVariantDataSafeArray(SAFEARRAY* value = NULL)
{
m_value = value;
}
SAFEARRAY* GetValue() const { return m_value; }
void SetValue(SAFEARRAY* value) { m_value = value; }
virtual bool Eq(wxVariantData& data) const wxOVERRIDE;
#if wxUSE_STD_IOSTREAM
virtual bool Write(wxSTD ostream& str) const wxOVERRIDE;
#endif
virtual bool Write(wxString& str) const wxOVERRIDE;
wxVariantData* Clone() const wxOVERRIDE { return new wxVariantDataSafeArray(m_value); }
virtual wxString GetType() const wxOVERRIDE { return wxS("safearray"); }
DECLARE_WXANY_CONVERSION()
private:
SAFEARRAY* m_value;
};
// Used by wxAutomationObject for its wxConvertOleToVariant() calls.
enum wxOleConvertVariantFlags
{
wxOleConvertVariant_Default = 0,
// If wxOleConvertVariant_ReturnSafeArrays flag is set, SAFEARRAYs
// contained in OLE VARIANTs will be returned as wxVariants
// with wxVariantDataSafeArray type instead of wxVariants
// with the list type containing the (flattened) SAFEARRAY's elements.
wxOleConvertVariant_ReturnSafeArrays = 1
};
WXDLLIMPEXP_CORE
bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& oleVariant);
WXDLLIMPEXP_CORE
bool wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant,
long flags = wxOleConvertVariant_Default);
#endif // wxUSE_VARIANT
// Convert string to Unicode
WXDLLIMPEXP_CORE BSTR wxConvertStringToOle(const wxString& str);
// Convert string from BSTR to wxString
WXDLLIMPEXP_CORE wxString wxConvertStringFromOle(BSTR bStr);
#else // !wxUSE_OLE
// ----------------------------------------------------------------------------
// stub functions to avoid #if wxUSE_OLE in the main code
// ----------------------------------------------------------------------------
inline bool wxOleInitialize() { return false; }
inline void wxOleUninitialize() { }
#endif // wxUSE_OLE/!wxUSE_OLE
// RAII class initializing OLE in its ctor and undoing it in its dtor.
class wxOleInitializer
{
public:
wxOleInitializer()
: m_ok(wxOleInitialize())
{
}
bool IsOk() const
{
return m_ok;
}
~wxOleInitializer()
{
if ( m_ok )
wxOleUninitialize();
}
private:
const bool m_ok;
wxDECLARE_NO_COPY_CLASS(wxOleInitializer);
};
#endif //_WX_OLEUTILS_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/automtn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/automtn.h
// Purpose: OLE automation utilities
// Author: Julian Smart
// Modified by:
// Created: 11/6/98
// Copyright: (c) 1998, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_AUTOMTN_H_
#define _WX_AUTOMTN_H_
#include "wx/defs.h"
#if wxUSE_OLE_AUTOMATION
#include "wx/object.h"
#include "wx/variant.h"
typedef void WXIDISPATCH;
typedef unsigned short* WXBSTR;
typedef unsigned long WXLCID;
#ifdef GetObject
#undef GetObject
#endif
// Flags used with wxAutomationObject::GetInstance()
enum wxAutomationInstanceFlags
{
// Only use the existing instance, never create a new one.
wxAutomationInstance_UseExistingOnly = 0,
// Create a new instance if there are no existing ones.
wxAutomationInstance_CreateIfNeeded = 1,
// Do not log errors if we failed to get the existing instance because none
// is available.
wxAutomationInstance_SilentIfNone = 2
};
/*
* wxAutomationObject
* Wraps up an IDispatch pointer and invocation; does variant conversion.
*/
class WXDLLIMPEXP_CORE wxAutomationObject: public wxObject
{
public:
wxAutomationObject(WXIDISPATCH* dispatchPtr = NULL);
virtual ~wxAutomationObject();
// Set/get dispatch pointer
void SetDispatchPtr(WXIDISPATCH* dispatchPtr) { m_dispatchPtr = dispatchPtr; }
WXIDISPATCH* GetDispatchPtr() const { return m_dispatchPtr; }
bool IsOk() const { return m_dispatchPtr != NULL; }
// Get a dispatch pointer from the current object associated
// with a ProgID, such as "Excel.Application"
bool GetInstance(const wxString& progId,
int flags = wxAutomationInstance_CreateIfNeeded) const;
// Get a dispatch pointer from a new instance of the class
bool CreateInstance(const wxString& progId) const;
// Low-level invocation function. Pass either an array of variants,
// or an array of pointers to variants.
bool Invoke(const wxString& member, int action,
wxVariant& retValue, int noArgs, wxVariant args[], const wxVariant* ptrArgs[] = 0) const;
// Invoke a member function
wxVariant CallMethod(const wxString& method, int noArgs, wxVariant args[]);
wxVariant CallMethodArray(const wxString& method, int noArgs, const wxVariant **args);
// Convenience function
wxVariant CallMethod(const wxString& method,
const wxVariant& arg1 = wxNullVariant, const wxVariant& arg2 = wxNullVariant,
const wxVariant& arg3 = wxNullVariant, const wxVariant& arg4 = wxNullVariant,
const wxVariant& arg5 = wxNullVariant, const wxVariant& arg6 = wxNullVariant);
// Get/Put property
wxVariant GetProperty(const wxString& property, int noArgs = 0, wxVariant args[] = NULL) const;
wxVariant GetPropertyArray(const wxString& property, int noArgs, const wxVariant **args) const;
wxVariant GetProperty(const wxString& property,
const wxVariant& arg1, const wxVariant& arg2 = wxNullVariant,
const wxVariant& arg3 = wxNullVariant, const wxVariant& arg4 = wxNullVariant,
const wxVariant& arg5 = wxNullVariant, const wxVariant& arg6 = wxNullVariant);
bool PutPropertyArray(const wxString& property, int noArgs, const wxVariant **args);
bool PutProperty(const wxString& property, int noArgs, wxVariant args[]) ;
bool PutProperty(const wxString& property,
const wxVariant& arg1, const wxVariant& arg2 = wxNullVariant,
const wxVariant& arg3 = wxNullVariant, const wxVariant& arg4 = wxNullVariant,
const wxVariant& arg5 = wxNullVariant, const wxVariant& arg6 = wxNullVariant);
// Uses DISPATCH_PROPERTYGET
// and returns a dispatch pointer. The calling code should call Release
// on the pointer, though this could be implicit by constructing an wxAutomationObject
// with it and letting the destructor call Release.
WXIDISPATCH* GetDispatchProperty(const wxString& property, int noArgs, wxVariant args[]) const;
WXIDISPATCH* GetDispatchProperty(const wxString& property, int noArgs, const wxVariant **args) const;
// A way of initialising another wxAutomationObject with a dispatch object,
// without having to deal with nasty IDispatch pointers.
bool GetObject(wxAutomationObject& obj, const wxString& property, int noArgs = 0, wxVariant args[] = NULL) const;
bool GetObject(wxAutomationObject& obj, const wxString& property, int noArgs, const wxVariant **args) const;
// Returns the locale identifier used in automation calls. The default is
// LOCALE_SYSTEM_DEFAULT. Objects obtained by GetObject() inherit the
// locale identifier from the one that created them.
WXLCID GetLCID() const;
// Sets the locale identifier to be used in automation calls performed by
// this object. The default is LOCALE_SYSTEM_DEFAULT.
void SetLCID(WXLCID lcid);
// Returns the flags used for conversions between wxVariant and OLE
// VARIANT, see wxOleConvertVariantFlags. The default value is
// wxOleConvertVariant_Default but all the objects obtained by GetObject()
// inherit the flags from the one that created them.
long GetConvertVariantFlags() const;
// Sets the flags used for conversions between wxVariant and OLE VARIANT,
// see wxOleConvertVariantFlags (default is wxOleConvertVariant_Default.
void SetConvertVariantFlags(long flags);
public: // public for compatibility only, don't use m_dispatchPtr directly.
WXIDISPATCH* m_dispatchPtr;
private:
WXLCID m_lcid;
long m_convertVariantFlags;
wxDECLARE_NO_COPY_CLASS(wxAutomationObject);
};
#endif // wxUSE_OLE_AUTOMATION
#endif // _WX_AUTOMTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/dropsrc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/dropsrc.h
// Purpose: declaration of the wxDropSource class
// Author: Vadim Zeitlin
// Modified by:
// Created: 06.03.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OLEDROPSRC_H
#define _WX_OLEDROPSRC_H
#if wxUSE_DRAG_AND_DROP
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class wxIDropSource;
class WXDLLIMPEXP_FWD_CORE wxDataObject;
class WXDLLIMPEXP_FWD_CORE wxWindow;
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// this macro may be used instead for wxDropSource ctor arguments: it will use
// the cursor 'name' from the resources under MSW, but will expand to
// something else under GTK. If you don't use it, you will have to use #ifdef
// in the application code.
#define wxDROP_ICON(name) wxCursor(wxT(#name))
// ----------------------------------------------------------------------------
// wxDropSource is used to start the drag-&-drop operation on associated
// wxDataObject object. It's responsible for giving UI feedback while dragging.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDropSource : public wxDropSourceBase
{
public:
// ctors: if you use default ctor you must call SetData() later!
//
// NB: the "wxWindow *win" parameter is unused and is here only for wxGTK
// compatibility, as well as both icon parameters
wxDropSource(wxWindow *win = NULL,
const wxCursor &cursorCopy = wxNullCursor,
const wxCursor &cursorMove = wxNullCursor,
const wxCursor &cursorStop = wxNullCursor);
wxDropSource(wxDataObject& data,
wxWindow *win = NULL,
const wxCursor &cursorCopy = wxNullCursor,
const wxCursor &cursorMove = wxNullCursor,
const wxCursor &cursorStop = wxNullCursor);
virtual ~wxDropSource();
// do it (call this in response to a mouse button press, for example)
// params: if bAllowMove is false, data can be only copied
virtual wxDragResult DoDragDrop(int flags = wxDrag_CopyOnly) wxOVERRIDE;
// overridable: you may give some custom UI feedback during d&d operation
// in this function (it's called on each mouse move, so it shouldn't be
// too slow). Just return false if you want default feedback.
virtual bool GiveFeedback(wxDragResult effect) wxOVERRIDE;
protected:
void Init();
private:
wxIDropSource *m_pIDropSource; // the pointer to COM interface
wxDECLARE_NO_COPY_CLASS(wxDropSource);
};
#endif //wxUSE_DRAG_AND_DROP
#endif //_WX_OLEDROPSRC_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/dataobj.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ole/dataobj.h
// Purpose: declaration of the wxDataObject class
// Author: Vadim Zeitlin
// Modified by:
// Created: 10.05.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_OLE_DATAOBJ_H
#define _WX_MSW_OLE_DATAOBJ_H
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
struct IDataObject;
// ----------------------------------------------------------------------------
// wxDataObject is a "smart" and polymorphic piece of data.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDataObject : public wxDataObjectBase
{
public:
// ctor & dtor
wxDataObject();
virtual ~wxDataObject();
// retrieve IDataObject interface (for other OLE related classes)
IDataObject *GetInterface() const { return m_pIDataObject; }
// tell the object that it should be now owned by IDataObject - i.e. when
// it is deleted, it should delete us as well
void SetAutoDelete();
// return true if we support this format in "Get" direction
bool IsSupportedFormat(const wxDataFormat& format) const
{ return wxDataObjectBase::IsSupported(format, Get); }
// if this method returns false, this wxDataObject will be copied to
// the clipboard with its size prepended to it, which is compatible with
// older wx versions
//
// if returns true, then this wxDataObject will be copied to the clipboard
// without any additional information and ::HeapSize() function will be used
// to get the size of that data
virtual bool NeedsVerbatimData(const wxDataFormat& WXUNUSED(format)) const
{
// return false from here only for compatibility with earlier wx versions
return true;
}
// function to return symbolic name of clipboard format (for debug messages)
#ifdef __WXDEBUG__
static const wxChar *GetFormatName(wxDataFormat format);
#define wxGetFormatName(format) wxDataObject::GetFormatName(format)
#else // !Debug
#define wxGetFormatName(format) wxT("")
#endif // Debug/!Debug
// they need to be accessed from wxIDataObject, so made them public,
// or wxIDataObject friend
public:
virtual const void* GetSizeFromBuffer( const void* buffer, size_t* size,
const wxDataFormat& format );
virtual void* SetSizeInBuffer( void* buffer, size_t size,
const wxDataFormat& format );
virtual size_t GetBufferOffset( const wxDataFormat& format );
private:
IDataObject *m_pIDataObject; // pointer to the COM interface
wxDECLARE_NO_COPY_CLASS(wxDataObject);
};
#endif //_WX_MSW_OLE_DATAOBJ_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ole/safearray.h | ///////////////////////////////////////////////////////////////////////////////
// Name: msw/ole/safearray.h
// Purpose: Helpers for working with OLE SAFEARRAYs.
// Author: PB
// Created: 2012-09-23
// Copyright: (c) 2012 wxWidgets development team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSW_OLE_SAFEARRAY_H_
#define _MSW_OLE_SAFEARRAY_H_
#include "wx/msw/ole/oleutils.h"
#if wxUSE_OLE && wxUSE_VARIANT
/*
wxSafeArray is wxWidgets wrapper for working with MS Windows SAFEARRAYs.
It also has convenience functions for converting between SAFEARRAY
and wxVariant with list type or wxArrayString.
*/
// The base class with type-independent methods. It exists solely in order to
// reduce the template bloat.
class WXDLLIMPEXP_CORE wxSafeArrayBase
{
public:
// If owns a SAFEARRAY, it's unlocked and destroyed.
virtual ~wxSafeArrayBase() { Destroy(); }
// Unlocks and destroys the owned SAFEARRAY.
void Destroy();
// Unlocks the owned SAFEARRAY, returns it and gives up its ownership.
SAFEARRAY* Detach();
// Returns true if has a valid SAFEARRAY.
bool HasArray() const { return m_array != NULL; }
// Returns the number of dimensions.
size_t GetDim() const;
// Returns lower bound for dimension dim in bound. Dimensions start at 1.
bool GetLBound(size_t dim, long& bound) const;
// Returns upper bound for dimension dim in bound. Dimensions start at 1.
bool GetUBound(size_t dim, long& bound) const;
// Returns element count for dimension dim. Dimensions start at 1.
size_t GetCount(size_t dim) const;
protected:
// Default constructor, protected so the class can't be used on its own,
// it's only used as a base class of wxSafeArray<>.
wxSafeArrayBase()
{
m_array = NULL;
}
bool Lock();
bool Unlock();
SAFEARRAY* m_array;
};
// wxSafeArrayConvertor<> must be specialized for the type in order to allow
// using it with wxSafeArray<>.
//
// We specialize it below for the standard types.
template <VARTYPE varType>
struct wxSafeArrayConvertor {};
/**
Macro for specializing wxSafeArrayConvertor for simple types.
The template parameters are:
- externType: basic C data type, e.g. wxFloat64 or wxInt32
- varType: corresponding VARIANT type constant, e.g. VT_R8 or VT_I4.
*/
#define wxSPECIALIZE_WXSAFEARRAY_CONVERTOR_SIMPLE(externType, varType) \
template <> \
struct wxSafeArrayConvertor<varType> \
{ \
typedef externType externT; \
typedef externT internT; \
static bool ToArray(const externT& from, internT& to) \
{ \
to = from; \
return true; \
} \
static bool FromArray(const internT& from, externT& to) \
{ \
to = from; \
return true; \
} \
}
wxSPECIALIZE_WXSAFEARRAY_CONVERTOR_SIMPLE(wxInt16, VT_I2);
wxSPECIALIZE_WXSAFEARRAY_CONVERTOR_SIMPLE(wxInt32, VT_I4);
wxSPECIALIZE_WXSAFEARRAY_CONVERTOR_SIMPLE(wxFloat32, VT_R4);
wxSPECIALIZE_WXSAFEARRAY_CONVERTOR_SIMPLE(wxFloat64, VT_R8);
// Specialization for VT_BSTR using wxString.
template <>
struct wxSafeArrayConvertor<VT_BSTR>
{
typedef wxString externT;
typedef BSTR internT;
static bool ToArray(const wxString& from, BSTR& to)
{
BSTR bstr = wxConvertStringToOle(from);
if ( !bstr && !from.empty() )
{
// BSTR can be NULL for empty strings but if the string was
// not empty, it means we failed to allocate memory for it.
return false;
}
to = bstr;
return true;
}
static bool FromArray(const BSTR from, wxString& to)
{
to = wxConvertStringFromOle(from);
return true;
}
};
// Specialization for VT_VARIANT using wxVariant.
template <>
struct wxSafeArrayConvertor<VT_VARIANT>
{
typedef wxVariant externT;
typedef VARIANT internT;
static bool ToArray(const wxVariant& from, VARIANT& to)
{
return wxConvertVariantToOle(from, to);
}
static bool FromArray(const VARIANT& from, wxVariant& to)
{
return wxConvertOleToVariant(from, to);
}
};
template <VARTYPE varType>
class wxSafeArray : public wxSafeArrayBase
{
public:
typedef wxSafeArrayConvertor<varType> Convertor;
typedef typename Convertor::internT internT;
typedef typename Convertor::externT externT;
// Default constructor.
wxSafeArray()
{
m_array = NULL;
}
// Creates and locks a zero-based one-dimensional SAFEARRAY with the given
// number of elements.
bool Create(size_t count)
{
SAFEARRAYBOUND bound;
bound.lLbound = 0;
bound.cElements = count;
return Create(&bound, 1);
}
// Creates and locks a SAFEARRAY. See SafeArrayCreate() in MSDN
// documentation for more information.
bool Create(SAFEARRAYBOUND* bound, size_t dimensions)
{
wxCHECK_MSG( !m_array, false, wxS("Can't be created twice") );
m_array = SafeArrayCreate(varType, dimensions, bound);
if ( !m_array )
return false;
return Lock();
}
/**
Creates a 0-based one-dimensional SAFEARRAY from wxVariant with the
list type.
Can be called only for wxSafeArray<VT_VARIANT>.
*/
bool CreateFromListVariant(const wxVariant& variant)
{
wxCHECK(varType == VT_VARIANT, false);
wxCHECK(variant.GetType() == wxS("list"), false);
if ( !Create(variant.GetCount()) )
return false;
VARIANT* data = static_cast<VARIANT*>(m_array->pvData);
for ( size_t i = 0; i < variant.GetCount(); i++)
{
if ( !Convertor::ToArray(variant[i], data[i]) )
return false;
}
return true;
}
/**
Creates a 0-based one-dimensional SAFEARRAY from wxArrayString.
Can be called only for wxSafeArray<VT_BSTR>.
*/
bool CreateFromArrayString(const wxArrayString& strings)
{
wxCHECK(varType == VT_BSTR, false);
if ( !Create(strings.size()) )
return false;
BSTR* data = static_cast<BSTR*>(m_array->pvData);
for ( size_t i = 0; i < strings.size(); i++ )
{
if ( !Convertor::ToArray(strings[i], data[i]) )
return false;
}
return true;
}
/**
Attaches and locks an existing SAFEARRAY.
The array must have the same VARTYPE as this wxSafeArray was
instantiated with.
*/
bool Attach(SAFEARRAY* array)
{
wxCHECK_MSG(!m_array && array, false,
wxS("Can only attach a valid array to an uninitialized one") );
VARTYPE vt;
HRESULT hr = SafeArrayGetVartype(array, &vt);
if ( FAILED(hr) )
{
wxLogApiError(wxS("SafeArrayGetVarType()"), hr);
return false;
}
wxCHECK_MSG(vt == varType, false,
wxS("Attaching array of invalid type"));
m_array = array;
return Lock();
}
/**
Indices have the same row-column order as rgIndices in
SafeArrayPutElement(), i.e. they follow BASIC rules, NOT C ones.
*/
bool SetElement(long* indices, const externT& element)
{
wxCHECK_MSG( m_array, false, wxS("Uninitialized array") );
wxCHECK_MSG( indices, false, wxS("Invalid index") );
internT* data;
if ( FAILED( SafeArrayPtrOfIndex(m_array, (LONG *)indices, (void**)&data) ) )
return false;
return Convertor::ToArray(element, *data);
}
/**
Indices have the same row-column order as rgIndices in
SafeArrayPutElement(), i.e. they follow BASIC rules, NOT C ones.
*/
bool GetElement(long* indices, externT& element) const
{
wxCHECK_MSG( m_array, false, wxS("Uninitialized array") );
wxCHECK_MSG( indices, false, wxS("Invalid index") );
internT* data;
if ( FAILED( SafeArrayPtrOfIndex(m_array, (LONG *)indices, (void**)&data) ) )
return false;
return Convertor::FromArray(*data, element);
}
/**
Converts the array to a wxVariant with the list type, regardless of the
underlying SAFEARRAY type.
If the array is multidimensional, it is flattened using the algorithm
originally employed in wxConvertOleToVariant().
*/
bool ConvertToVariant(wxVariant& variant) const
{
wxCHECK_MSG( m_array, false, wxS("Uninitialized array") );
size_t dims = m_array->cDims;
size_t count = 1;
for ( size_t i = 0; i < dims; i++ )
count *= m_array->rgsabound[i].cElements;
const internT* data = static_cast<const internT*>(m_array->pvData);
externT element;
variant.ClearList();
for ( size_t i1 = 0; i1 < count; i1++ )
{
if ( !Convertor::FromArray(data[i1], element) )
{
variant.ClearList();
return false;
}
variant.Append(element);
}
return true;
}
/**
Converts an array to an ArrayString.
Can be called only for wxSafeArray<VT_BSTR>. If the array is
multidimensional, it is flattened using the algorithm originally
employed in wxConvertOleToVariant().
*/
bool ConvertToArrayString(wxArrayString& strings) const
{
wxCHECK_MSG( m_array, false, wxS("Uninitialized array") );
wxCHECK(varType == VT_BSTR, false);
size_t dims = m_array->cDims;
size_t count = 1;
for ( size_t i = 0; i < dims; i++ )
count *= m_array->rgsabound[i].cElements;
const BSTR* data = static_cast<const BSTR*>(m_array->pvData);
wxString element;
strings.clear();
strings.reserve(count);
for ( size_t i1 = 0; i1 < count; i1++ )
{
if ( !Convertor::FromArray(data[i1], element) )
{
strings.clear();
return false;
}
strings.push_back(element);
}
return true;
}
static bool ConvertToVariant(SAFEARRAY* psa, wxVariant& variant)
{
wxSafeArray<varType> sa;
bool result = false;
if ( sa.Attach(psa) )
result = sa.ConvertToVariant(variant);
if ( sa.HasArray() )
sa.Detach();
return result;
}
static bool ConvertToArrayString(SAFEARRAY* psa, wxArrayString& strings)
{
wxSafeArray<varType> sa;
bool result = false;
if ( sa.Attach(psa) )
result = sa.ConvertToArrayString(strings);
if ( sa.HasArray() )
sa.Detach();
return result;
}
wxDECLARE_NO_COPY_TEMPLATE_CLASS(wxSafeArray, varType);
};
#endif // wxUSE_OLE && wxUSE_VARIANT
#endif // _MSW_OLE_SAFEARRAY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/rt/utils.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/rt/utils.h
// Purpose: Windows Runtime Objects helper functions and objects
// Author: Tobias Taschner
// Created: 2015-09-05
// Copyright: (c) 2015 wxWidgets development team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_RTUTILS_H
#define _WX_MSW_RTUTILS_H
#include "wx/defs.h"
#if wxUSE_WINRT
#include "wx/string.h"
#include "wx/msw/wrapwin.h"
#include <winstring.h>
namespace wxWinRT
{
bool WXDLLIMPEXP_CORE IsAvailable();
bool WXDLLIMPEXP_CORE Initialize();
void WXDLLIMPEXP_CORE Uninitialize();
bool WXDLLIMPEXP_CORE GetActivationFactory(const wxString& activatableClassId, REFIID iid, void ** factory);
// RAII class initializing WinRT in its ctor and undoing it in its dtor.
class WXDLLIMPEXP_CORE Initializer
{
public:
Initializer()
: m_ok(Initialize())
{
}
bool IsOk() const
{
return m_ok;
}
~Initializer()
{
if (m_ok)
Uninitialize();
}
private:
const bool m_ok;
wxDECLARE_NO_COPY_CLASS(Initializer);
};
// Simple class to convert wxString to HSTRING
// This just wraps a reference to the wxString object,
// which needs a life time greater than the TempStringRef object
class WXDLLIMPEXP_CORE TempStringRef
{
public:
HSTRING Get() const { return m_hstring; }
operator HSTRING() const { return m_hstring; };
static const TempStringRef Make(const wxString &str);
private:
TempStringRef(const wxString &str);
HSTRING m_hstring;
HSTRING_HEADER m_header;
wxDECLARE_NO_COPY_CLASS(TempStringRef);
};
} // namespace wxWinRT
#endif // wxUSE_WINRT
#endif // _WX_MSW_RTUTILS_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/rt/private/notifmsg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/rt/private/notifmsg.h
// Purpose: WinRT implementation of wxNotificationMessageImpl
// Author: Tobias Taschner
// Created: 2015-09-13
// Copyright: (c) 2015 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_RT_PRIVATE_NOTIFMSG_H_
#define _WX_MSW_RT_PRIVATE_NOTIFMSG_H_
#include "wx/notifmsg.h"
#include "wx/private/notifmsg.h"
class wxToastNotificationHelper
{
public:
static bool UseToasts(const wxString& shortcutPath,
const wxString& appId);
static bool IsEnabled();
static wxNotificationMessageImpl* CreateInstance(wxNotificationMessageBase* notification);
};
#endif // _WX_MSW_RT_PRIVATE_NOTIFMSG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/winstyle.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/winstyle.h
// Purpose: Small helper class for updating MSW windows style
// Author: Vadim Zeitlin
// Created: 2017-12-09
// Copyright: (c) 2017 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_WINSTYLE_H_
#define _WX_MSW_PRIVATE_WINSTYLE_H_
// ----------------------------------------------------------------------------
// wxMSWWinLongUpdater
// ----------------------------------------------------------------------------
/*
This class is not used directly, but either as wxMSWWinStyleUpdater or
wxMSWWinExStyleUpdater, both of which inherit from it and can be used like
this:
void SomeFunction()
{
wxMSWWinStyleUpdater updateStyle(GetHwndOf(m_win));
if ( some-condition )
updateStyle.TurnOn(XX_YYY);
// Style update happens here implicitly -- or call Apply().
}
*/
class wxMSWWinLongUpdater
{
public:
// Get the current style.
LONG_PTR Get() const
{
return m_styleCurrent;
}
// Check if the given style bit(s) is (are all) currently turned on.
bool IsOn(LONG_PTR style) const
{
return (m_styleCurrent & style) == style;
}
// Turn on some bit(s) in the style.
wxMSWWinLongUpdater& TurnOn(LONG_PTR on)
{
m_style |= on;
return *this;
}
// Turn off some bit(s) in the style.
wxMSWWinLongUpdater& TurnOff(LONG_PTR off)
{
m_style &= ~off;
return *this;
}
// Turn some bit(s) on or off depending on the condition.
wxMSWWinLongUpdater& TurnOnOrOff(bool cond, LONG_PTR style)
{
return cond ? TurnOn(style) : TurnOff(style);
}
// Perform the style update (only if necessary, i.e. if the style really
// changed).
//
// Notice that if this method is not called, it's still done from the dtor,
// so it's just a convenient way to do it sooner and avoid having to create
// a new scope for ensuring that the dtor runs at the right place, but
// otherwise is equivalent to do this.
bool Apply()
{
if ( m_style == m_styleCurrent )
return false;
::SetWindowLongPtr(m_hwnd, m_gwlSlot, m_style);
m_styleCurrent = m_style;
return true;
}
~wxMSWWinLongUpdater()
{
Apply();
}
protected:
// Create the object for updating the style or extended style of the given
// window.
//
// Ctor is protected, this class can only be used as wxMSWWinStyleUpdater
// or wxMSWWinExStyleUpdater.
wxMSWWinLongUpdater(HWND hwnd, int gwlSlot)
: m_hwnd(hwnd),
m_gwlSlot(gwlSlot),
m_styleCurrent(::GetWindowLongPtr(hwnd, gwlSlot)),
m_style(m_styleCurrent)
{
}
private:
const HWND m_hwnd;
const int m_gwlSlot;
LONG_PTR m_styleCurrent;
LONG_PTR m_style;
wxDECLARE_NO_COPY_CLASS(wxMSWWinLongUpdater);
};
// A variant of wxMSWWinLongUpdater which updates the extended style.
class wxMSWWinStyleUpdater : public wxMSWWinLongUpdater
{
public:
explicit wxMSWWinStyleUpdater(HWND hwnd)
: wxMSWWinLongUpdater(hwnd, GWL_STYLE)
{
}
};
// A variant of wxMSWWinLongUpdater which updates the extended style.
class wxMSWWinExStyleUpdater : public wxMSWWinLongUpdater
{
public:
explicit wxMSWWinExStyleUpdater(HWND hwnd)
: wxMSWWinLongUpdater(hwnd, GWL_EXSTYLE)
{
}
};
#endif // _WX_MSW_PRIVATE_WINSTYLE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/comptr.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/comptr.h
// Purpose: Smart pointer for COM interfaces.
// Author: PB
// Created: 2012-04-16
// Copyright: (c) 2012 wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_COMPTR_H_
#define _WX_MSW_PRIVATE_COMPTR_H_
// ----------------------------------------------------------------------------
// wxCOMPtr: A minimalistic smart pointer for use with COM interfaces.
// ----------------------------------------------------------------------------
template <class T>
class wxCOMPtr
{
public:
typedef T element_type;
wxCOMPtr()
: m_ptr(NULL)
{
}
explicit wxCOMPtr(T* ptr)
: m_ptr(ptr)
{
if ( m_ptr )
m_ptr->AddRef();
}
wxCOMPtr(const wxCOMPtr& ptr)
: m_ptr(ptr.get())
{
if ( m_ptr )
m_ptr->AddRef();
}
~wxCOMPtr()
{
if ( m_ptr )
m_ptr->Release();
}
void reset(T* ptr = NULL)
{
if ( m_ptr != ptr)
{
if ( ptr )
ptr->AddRef();
if ( m_ptr )
m_ptr->Release();
m_ptr = ptr;
}
}
wxCOMPtr& operator=(const wxCOMPtr& ptr)
{
reset(ptr.get());
return *this;
}
wxCOMPtr& operator=(T* ptr)
{
reset(ptr);
return *this;
}
operator T*() const
{
return m_ptr;
}
T& operator*() const
{
return *m_ptr;
}
T* operator->() const
{
return m_ptr;
}
// It would be better to forbid direct access completely but we do need
// for QueryInterface() and similar functions, so provide it but it can
// only be used to initialize the pointer, not to modify an existing one.
T** operator&()
{
wxASSERT_MSG(!m_ptr,
wxS("Can't get direct access to initialized pointer"));
return &m_ptr;
}
T* get() const
{
return m_ptr;
}
bool operator<(T* ptr) const
{
return get() < ptr;
}
private:
T* m_ptr;
};
// Define a helper for the macro below: we just need a function taking a
// pointer and not returning anything to avoid warnings about unused return
// value of the cast in the macro itself.
namespace wxPrivate { inline void PPV_ARGS_CHECK(void*) { } }
// Takes the interface name and a pointer to a pointer of the interface type
// and expands into the IID of this interface and the same pointer but after a
// type-safety check.
//
// This is similar to the standard IID_PPV_ARGS macro but takes the pointer
// type instead of relying on the non-standard Microsoft __uuidof().
#define wxIID_PPV_ARGS(IType, pType) \
IID_##IType, \
(wxPrivate::PPV_ARGS_CHECK(static_cast<IType*>(*pType)), \
reinterpret_cast<void**>(pType))
#endif // _WX_MSW_PRIVATE_COMPTR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/event.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/event.h
// Purpose: Simple Windows 'event object' wrapper.
// Author: Troelsk, Vadim Zeitlin
// Created: 2014-05-07
// Copyright: (c) 2014 wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_EVENT_H_
#define _WX_MSW_PRIVATE_EVENT_H_
#include "wx/msw/private.h"
namespace wxWinAPI
{
class Event : public AutoHANDLE<0>
{
public:
enum Kind
{
ManualReset,
AutomaticReset
};
enum InitialState
{
Signaled,
Nonsignaled
};
Event()
{
}
// Wrappers around {Create,Set,Reset}Event() Windows API functions, with
// the same semantics.
bool Create(Kind kind = AutomaticReset,
InitialState initialState = Nonsignaled,
const wxChar* name = NULL);
bool Set();
bool Reset();
private:
wxDECLARE_NO_COPY_CLASS(Event);
};
} // namespace wxWinAPI
// ----------------------------------------------------------------------------
// Implementations requiring windows.h; these are to moved out-of-line if
// this class is moved to a public header, or if [parts of] msw/private.h is
// changed to not depend on windows.h being included.
// ----------------------------------------------------------------------------
inline bool
wxWinAPI::Event::Create(wxWinAPI::Event::Kind kind,
wxWinAPI::Event::InitialState initialState,
const wxChar* name)
{
wxCHECK_MSG( !IsOk(), false, wxS("Event can't be created twice") );
WXHANDLE handle = ::CreateEvent(NULL,
kind == ManualReset,
initialState == Signaled,
name);
if ( !handle )
{
wxLogLastError(wxS("CreateEvent"));
return false;
}
m_handle = handle;
return true;
}
inline bool wxWinAPI::Event::Set()
{
wxCHECK_MSG( m_handle, false, wxS("Event must be valid") );
if ( !::SetEvent(m_handle) )
{
wxLogLastError(wxS("SetEvent"));
return false;
}
return true;
}
inline bool wxWinAPI::Event::Reset()
{
wxCHECK_MSG( m_handle, false, wxS("Event must be valid") );
if ( !::ResetEvent(m_handle) )
{
wxLogLastError(wxS("ResetEvent"));
return false;
}
return true;
}
#endif // _WX_MSW_PRIVATE_EVENT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/hiddenwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/hiddenwin.h
// Purpose: Helper for creating a hidden window used by wxMSW internally.
// Author: Vadim Zeitlin
// Created: 2011-09-16
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_HIDDENWIN_H_
#define _WX_MSW_PRIVATE_HIDDENWIN_H_
#include "wx/msw/private.h"
/*
Creates a hidden window with supplied window proc registering the class for
it if necessary (i.e. the first time only). Caller is responsible for
destroying the window and unregistering the class (note that this must be
done because wxWidgets may be used as a DLL and so may be loaded/unloaded
multiple times into/from the same process so we can't rely on automatic
Windows class unregistration).
pclassname is a pointer to a caller stored classname, which must initially be
NULL. classname is the desired wndclass classname. If function successfully
registers the class, pclassname will be set to classname.
*/
extern "C" WXDLLIMPEXP_BASE HWND
wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc);
#endif // _WX_MSW_PRIVATE_HIDDENWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/tlwgeom.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/tlwgeom.h
// Purpose: wxMSW-specific wxTLWGeometry class.
// Author: Vadim Zeitlin
// Created: 2018-04-29
// Copyright: (c) 2018 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_TLWGEOM_H_
#define _WX_MSW_PRIVATE_TLWGEOM_H_
#include "wx/log.h"
#include "wx/msw/private.h"
// names for MSW-specific options
#define wxPERSIST_TLW_MAX_X "xmax"
#define wxPERSIST_TLW_MAX_Y "ymax"
class wxTLWGeometry : public wxTLWGeometryBase
{
public:
wxTLWGeometry()
{
wxZeroMemory(m_placement);
m_placement.length = sizeof(m_placement);
}
virtual bool Save(const Serializer& ser) const wxOVERRIDE
{
// For compatibility with the existing saved positions/sizes, use the
// same keys as the generic version (which was previously used under
// MSW too).
// Normal position and size.
const RECT& rc = m_placement.rcNormalPosition;
if ( !ser.SaveField(wxPERSIST_TLW_X, rc.left) ||
!ser.SaveField(wxPERSIST_TLW_Y, rc.top) )
return false;
if ( !ser.SaveField(wxPERSIST_TLW_W, rc.right - rc.left) ||
!ser.SaveField(wxPERSIST_TLW_H, rc.bottom - rc.top) )
return false;
// Maximized/minimized state.
UINT show = m_placement.showCmd;
if ( !ser.SaveField(wxPERSIST_TLW_MAXIMIZED, show == SW_SHOWMAXIMIZED) )
return false;
if ( !ser.SaveField(wxPERSIST_TLW_ICONIZED, show == SW_SHOWMINIMIZED) )
return false;
// Maximized window position.
const POINT pt = m_placement.ptMaxPosition;
if ( !ser.SaveField(wxPERSIST_TLW_MAX_X, pt.x) ||
!ser.SaveField(wxPERSIST_TLW_MAX_Y, pt.y) )
return false;
// We don't currently save the minimized window position, it doesn't
// seem useful for anything and is probably just a left over from
// Windows 3.1 days, when icons were positioned on the desktop instead
// of being located in the taskbar.
return true;
}
virtual bool Restore(Serializer& ser) wxOVERRIDE
{
// Normal position and size.
wxRect r;
if ( !ser.RestoreField(wxPERSIST_TLW_X, &r.x) ||
!ser.RestoreField(wxPERSIST_TLW_Y, &r.y) ||
!ser.RestoreField(wxPERSIST_TLW_W, &r.width) ||
!ser.RestoreField(wxPERSIST_TLW_H, &r.height) )
return false;
wxCopyRectToRECT(r, m_placement.rcNormalPosition);
// Maximized/minimized state.
//
// Note the special case of SW_MINIMIZE: while GetWindowPlacement()
// returns SW_SHOWMINIMIZED when the window is iconized, we restore it
// as SW_MINIMIZE as this is what the code in wxTLW checks to determine
// whether the window is supposed to be iconized or not.
//
// Just to confuse matters further, note that SW_MAXIMIZE is exactly
// the same thing as SW_SHOWMAXIMIZED.
int tmp;
UINT& show = m_placement.showCmd;
if ( ser.RestoreField(wxPERSIST_TLW_MAXIMIZED, &tmp) && tmp )
show = SW_MAXIMIZE;
else if ( ser.RestoreField(wxPERSIST_TLW_ICONIZED, &tmp) && tmp )
show = SW_MINIMIZE;
else
show = SW_SHOWNORMAL;
// Maximized window position.
if ( ser.RestoreField(wxPERSIST_TLW_MAX_X, &r.x) &&
ser.RestoreField(wxPERSIST_TLW_MAX_Y, &r.y) )
{
m_placement.ptMaxPosition.x = r.x;
m_placement.ptMaxPosition.y = r.y;
}
return true;
}
virtual bool GetFrom(const wxTopLevelWindow* tlw) wxOVERRIDE
{
if ( !::GetWindowPlacement(GetHwndOf(tlw), &m_placement) )
{
wxLogLastError(wxS("GetWindowPlacement"));
return false;
}
return true;
}
virtual bool ApplyTo(wxTopLevelWindow* tlw) wxOVERRIDE
{
// There is a subtlety here: if the window is currently hidden,
// restoring its geometry shouldn't show it, so we must use SW_HIDE as
// show command, but showing it later should restore it to the correct
// state, so we need to remember it in wxTLW itself. And even if it's
// currently shown, we still need to update its show command, so that
// it matches the real window state after SetWindowPlacement() call.
tlw->MSWSetShowCommand(m_placement.showCmd);
if ( !tlw->IsShown() )
{
m_placement.showCmd = SW_HIDE;
}
if ( !::SetWindowPlacement(GetHwndOf(tlw), &m_placement) )
{
wxLogLastError(wxS("SetWindowPlacement"));
return false;
}
return true;
}
private:
WINDOWPLACEMENT m_placement;
};
#endif // _WX_MSW_PRIVATE_TLWGEOM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/datecontrols.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/datecontrols.h
// Purpose: implementation helpers for wxDatePickerCtrl and wxCalendarCtrl
// Author: Vadim Zeitlin
// Created: 2008-04-04
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSW_PRIVATE_DATECONTROLS_H_
#define _MSW_PRIVATE_DATECONTROLS_H_
#include "wx/datetime.h"
#include "wx/msw/wrapwin.h"
// namespace for the helper functions related to the date controls
namespace wxMSWDateControls
{
// do the one time only initialization of date classes of comctl32.dll, return
// true if ok or log an error and return false if we failed (this can only
// happen with a very old version of common controls DLL, i.e. before 4.70)
extern bool CheckInitialization();
} // namespace wxMSWDateControls
#endif // _MSW_PRIVATE_DATECONTROLS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/customdraw.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/customdraw.h
// Purpose: Helper for implementing custom drawing support in wxMSW
// Author: Vadim Zeitlin
// Created: 2016-04-16
// Copyright: (c) 2016 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CUSTOMDRAW_H_
#define _WX_MSW_CUSTOMDRAW_H_
#include "wx/itemattr.h"
#include "wx/msw/wrapcctl.h"
namespace wxMSWImpl
{
// ----------------------------------------------------------------------------
// CustomDraw: inherit from this class and forward NM_CUSTOMDRAW to it
// ----------------------------------------------------------------------------
class CustomDraw
{
public:
// Trivial default ctor needed for non-copyable class.
CustomDraw()
{
}
// Virtual dtor for the base class.
virtual ~CustomDraw()
{
}
// Implementation of NM_CUSTOMDRAW handler, returns one of CDRF_XXX
// constants, possibly CDRF_DODEFAULT if custom drawing is not necessary.
LPARAM HandleCustomDraw(LPARAM lParam);
private:
// Return true if we need custom drawing at all.
virtual bool HasCustomDrawnItems() const = 0;
// Return the attribute to use for the given item, can return NULL if this
// item doesn't need to be custom-drawn.
virtual const wxItemAttr* GetItemAttr(DWORD_PTR dwItemSpec) const = 0;
// Set the colours and font for the specified HDC, return CDRF_NEWFONT if
// the font was changed.
LPARAM HandleItemPrepaint(const wxItemAttr& attr, HDC hdc);
wxDECLARE_NO_COPY_CLASS(CustomDraw);
};
} // namespace wxMSWImpl
#endif // _WX_MSW_CUSTOMDRAW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/sockmsw.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/gsockmsw.h
// Purpose: MSW-specific socket implementation
// Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia, Vadim Zeitlin
// Created: April 1997
// Copyright: (C) 1999-1997, Guilhem Lavaux
// (C) 1999-2000, Guillermo Rodriguez Garcia
// (C) 2008 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_GSOCKMSW_H_
#define _WX_MSW_GSOCKMSW_H_
#include "wx/msw/wrapwin.h"
#if defined(__CYGWIN__)
//CYGWIN gives annoying warning about runtime stuff if we don't do this
# define USE_SYS_TYPES_FD_SET
# include <sys/types.h>
#endif
#if defined(__CYGWIN__)
#include <winsock.h>
#ifdef __LP64__
// We can't use long in this case because it is 64 bits with Cygwin, so
// use their special type used for working around this instead.
#define wxIoctlSocketArg_t __ms_u_long
#endif
#endif
#ifndef wxIoctlSocketArg_t
#define wxIoctlSocketArg_t u_long
#endif
// ----------------------------------------------------------------------------
// MSW-specific socket implementation
// ----------------------------------------------------------------------------
class wxSocketImplMSW : public wxSocketImpl
{
public:
wxSocketImplMSW(wxSocketBase& wxsocket);
virtual ~wxSocketImplMSW();
virtual wxSocketError GetLastError() const wxOVERRIDE;
virtual void ReenableEvents(wxSocketEventFlags WXUNUSED(flags)) wxOVERRIDE
{
// notifications are never disabled in this implementation, there is no
// need for this as WSAAsyncSelect() only sends notification once when
// the new data becomes available anyhow, so there is no need to do
// anything here
}
private:
virtual void DoClose() wxOVERRIDE;
virtual void UnblockAndRegisterWithEventLoop() wxOVERRIDE
{
if ( GetSocketFlags() & wxSOCKET_BLOCK )
{
// Counter-intuitively, we make the socket non-blocking even in
// this case as it is necessary e.g. for Read() to return
// immediately if there is no data available. However we must not
// install a callback for it as blocking sockets don't use any
// events and generating them would actually be harmful (and not
// just useless) as they would be dispatched by the main thread
// while this blocking socket can be used from a worker one, so it
// would result in data races and other unpleasantness.
wxIoctlSocketArg_t trueArg = 1;
ioctlsocket(m_fd, FIONBIO, &trueArg);
}
else
{
// No need to make the socket non-blocking, Install_Callback() will
// do it as a side effect of calling WSAAsyncSelect().
wxSocketManager::Get()->Install_Callback(this);
}
}
int m_msgnumber;
friend class wxSocketMSWManager;
wxDECLARE_NO_COPY_CLASS(wxSocketImplMSW);
};
#endif /* _WX_MSW_GSOCKMSW_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/textmeasure.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/textmeasure.h
// Purpose: wxMSW-specific declaration of wxTextMeasure class
// Author: Manuel Martin
// Created: 2012-10-05
// Copyright: (c) 1997-2012 wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_TEXTMEASURE_H_
#define _WX_MSW_PRIVATE_TEXTMEASURE_H_
#include "wx/msw/wrapwin.h"
// ----------------------------------------------------------------------------
// wxTextMeasure for MSW.
// ----------------------------------------------------------------------------
class wxTextMeasure : public wxTextMeasureBase
{
public:
explicit wxTextMeasure(const wxDC *dc, const wxFont *font = NULL)
: wxTextMeasureBase(dc, font)
{
Init();
}
explicit wxTextMeasure(const wxWindow *win, const wxFont *font = NULL)
: wxTextMeasureBase(win, font)
{
Init();
}
protected:
void Init();
virtual void BeginMeasuring() wxOVERRIDE;
virtual void EndMeasuring() wxOVERRIDE;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *width,
wxCoord *height,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL) wxOVERRIDE;
virtual bool DoGetPartialTextExtents(const wxString& text,
wxArrayInt& widths,
double scaleX) wxOVERRIDE;
// We use either the HDC of the provided wxDC or an HDC created for our
// window.
HDC m_hdc;
// If we change the font in BeginMeasuring(), we restore it to the old one
// in EndMeasuring().
HFONT m_hfontOld;
wxDECLARE_NO_COPY_CLASS(wxTextMeasure);
};
#endif // _WX_MSW_PRIVATE_TEXTMEASURE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/timer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/timer.h
// Purpose: wxTimer class
// Author: Julian Smart
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_TIMER_H_
#define _WX_MSW_PRIVATE_TIMER_H_
#if wxUSE_TIMER
#include "wx/private/timer.h"
#include "wx/msw/wrapwin.h" // for WPARAM
class WXDLLIMPEXP_BASE wxMSWTimerImpl : public wxTimerImpl
{
public:
wxMSWTimerImpl(wxTimer *timer) : wxTimerImpl(timer) { m_id = 0; }
virtual bool Start(int milliseconds = -1, bool oneShot = false) wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual bool IsRunning() const wxOVERRIDE { return m_id != 0; }
protected:
// this must be 64 bit under Win64 as WPARAM (storing timer ids) is 64 bit
// there and so the ids may possibly not fit in 32 bits
WPARAM m_id;
};
#endif // wxUSE_TIMER
#endif // _WX_TIMERH_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/graphicsd2d.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/graphicsd2d.h
// Purpose: Allow functions from graphicsd2d.cpp to be used in othe files
// Author: New Pagodi
// Created: 2017-10-31
// Copyright: (c) 2017 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef WX_MSW_PRIVATE_GRAPHICSD2D_H_
#define WX_MSW_PRIVATE_GRAPHICSD2D_H_
#if wxUSE_GRAPHICS_DIRECT2D
// Ensure no previous defines interfere with the Direct2D API headers
#undef GetHwnd
// include before wincodec.h to prevent winsock/winsock2 redefinition warnings
#include "wx/msw/wrapwin.h"
#include <d2d1.h>
#include <dwrite.h>
#include <wincodec.h>
WXDLLIMPEXP_CORE IWICImagingFactory* wxWICImagingFactory();
WXDLLIMPEXP_CORE ID2D1Factory* wxD2D1Factory();
WXDLLIMPEXP_CORE IDWriteFactory* wxDWriteFactory();
#endif // wxUSE_GRAPHICS_DIRECT2D
#endif // WX_MSW_PRIVATE_GRAPHICSD2D_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/keyboard.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/keyboard.h
// Purpose: Helper keyboard-related functions.
// Author: Vadim Zeitlin
// Created: 2010-09-09
// Copyright: (c) 2010 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_KEYBOARD_H_
#define _WX_MSW_PRIVATE_KEYBOARD_H_
#include "wx/defs.h"
namespace wxMSWKeyboard
{
// ----------------------------------------------------------------------------
// Functions for translating between MSW virtual keys codes and wx key codes
//
// These functions are currently implemented in src/msw/window.cpp.
// ----------------------------------------------------------------------------
// Translate MSW virtual key code to wx key code. lParam is used to distinguish
// between numpad and extended version of the keys, extended is assumed by
// default if lParam == 0.
//
// Returns WXK_NONE if translation couldn't be done at all (this happens e.g.
// for dead keys and in this case uc will be WXK_NONE too) or if the key
// corresponds to a non-Latin-1 character in which case uc is filled with its
// Unicode value.
WXDLLIMPEXP_CORE int VKToWX(WXWORD vk, WXLPARAM lParam = 0, wchar_t *uc = NULL);
// Translate wxKeyCode enum element (passed as int for compatibility reasons)
// to MSW virtual key code. isExtended is set to true if the key corresponds to
// a non-numpad version of a key that exists both on numpad and outside it.
WXDLLIMPEXP_CORE WXWORD WXToVK(int id, bool *isExtended = NULL);
} // namespace wxMSWKeyboard
#endif // _WX_MSW_PRIVATE_KEYBOARD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/metrics.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/metrics.h
// Purpose: various helper functions to retrieve system metrics
// Author: Vadim Zeitlin
// Created: 2008-09-05
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_METRICS_H_
#define _WX_MSW_PRIVATE_METRICS_H_
namespace wxMSWImpl
{
// return NONCLIENTMETRICS as retrieved by SystemParametersInfo()
//
// currently this is not cached as the values may change when system settings
// do and we don't react to this to invalidate the cache but it could be done
// in the future
//
// MT-safety: this function is only meant to be called from the main thread
inline const NONCLIENTMETRICS& GetNonClientMetrics()
{
static WinStruct<NONCLIENTMETRICS> nm;
if ( !::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &nm, 0) )
{
#if WINVER >= 0x0600
// a new field has been added to NONCLIENTMETRICS under Vista, so
// the call to SystemParametersInfo() fails if we use the struct
// size incorporating this new value on an older system -- retry
// without it
nm.cbSize -= sizeof(int);
if ( !::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &nm, 0) )
#endif // WINVER >= 0x0600
{
// maybe we should initialize the struct with some defaults?
wxLogLastError(wxT("SystemParametersInfo(SPI_GETNONCLIENTMETRICS)"));
}
}
return nm;
}
} // namespace wxMSWImpl
#endif // _WX_MSW_PRIVATE_METRICS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/pipestream.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/pipestream.h
// Purpose: MSW wxPipeInputStream and wxPipeOutputStream declarations
// Author: Vadim Zeitlin
// Created: 2013-06-08 (extracted from src/msw/utilsexc.cpp)
// Copyright: (c) 2013 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_PIPESTREAM_H_
#define _WX_MSW_PRIVATE_PIPESTREAM_H_
class wxPipeInputStream : public wxInputStream
{
public:
explicit wxPipeInputStream(HANDLE hInput);
virtual ~wxPipeInputStream();
// returns true if the pipe is still opened
bool IsOpened() const { return m_hInput != INVALID_HANDLE_VALUE; }
// returns true if there is any data to be read from the pipe
virtual bool CanRead() const wxOVERRIDE;
protected:
virtual size_t OnSysRead(void *buffer, size_t len) wxOVERRIDE;
protected:
HANDLE m_hInput;
wxDECLARE_NO_COPY_CLASS(wxPipeInputStream);
};
class wxPipeOutputStream: public wxOutputStream
{
public:
explicit wxPipeOutputStream(HANDLE hOutput);
virtual ~wxPipeOutputStream() { Close(); }
bool Close() wxOVERRIDE;
protected:
size_t OnSysWrite(const void *buffer, size_t len) wxOVERRIDE;
protected:
HANDLE m_hOutput;
wxDECLARE_NO_COPY_CLASS(wxPipeOutputStream);
};
#endif // _WX_MSW_PRIVATE_PIPESTREAM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/dc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/dc.h
// Purpose: private wxMSW helpers for working with HDCs
// Author: Vadim Zeitlin
// Created: 2009-06-16 (extracted from src/msw/dc.cpp)
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _MSW_PRIVATE_DC_H_
#define _MSW_PRIVATE_DC_H_
#include "wx/msw/dc.h"
#include "wx/msw/wrapwin.h"
namespace wxMSWImpl
{
// various classes to change some DC property temporarily
// text background and foreground colours
class wxTextColoursChanger
{
public:
wxTextColoursChanger(HDC hdc, const wxMSWDCImpl& dc)
: m_hdc(hdc)
{
Change(dc.GetTextForeground(), dc.GetTextBackground());
}
wxTextColoursChanger(HDC hdc, const wxColour& colFg, const wxColour& colBg)
: m_hdc(hdc)
{
Change(colFg, colBg);
}
wxTextColoursChanger(HDC hdc, COLORREF colFg, COLORREF colBg)
: m_hdc(hdc)
{
Change(colFg, colBg);
}
~wxTextColoursChanger()
{
if ( m_oldColFg != CLR_INVALID )
::SetTextColor(m_hdc, m_oldColFg);
if ( m_oldColBg != CLR_INVALID )
::SetBkColor(m_hdc, m_oldColBg);
}
protected:
// this ctor doesn't change mode immediately, call Change() later to do it
// only if needed
wxTextColoursChanger(HDC hdc)
: m_hdc(hdc)
{
m_oldColFg =
m_oldColBg = CLR_INVALID;
}
void Change(const wxColour& colFg, const wxColour& colBg)
{
Change(colFg.IsOk() ? colFg.GetPixel() : CLR_INVALID,
colBg.IsOk() ? colBg.GetPixel() : CLR_INVALID);
}
void Change(COLORREF colFg, COLORREF colBg)
{
if ( colFg != CLR_INVALID )
{
m_oldColFg = ::SetTextColor(m_hdc, colFg);
if ( m_oldColFg == CLR_INVALID )
{
wxLogLastError(wxT("SetTextColor"));
}
}
else
{
m_oldColFg = CLR_INVALID;
}
if ( colBg != CLR_INVALID )
{
m_oldColBg = ::SetBkColor(m_hdc, colBg);
if ( m_oldColBg == CLR_INVALID )
{
wxLogLastError(wxT("SetBkColor"));
}
}
else
{
m_oldColBg = CLR_INVALID;
}
}
private:
const HDC m_hdc;
COLORREF m_oldColFg,
m_oldColBg;
wxDECLARE_NO_COPY_CLASS(wxTextColoursChanger);
};
// background mode
class wxBkModeChanger
{
public:
// set background mode to opaque if mode != wxBRUSHSTYLE_TRANSPARENT
wxBkModeChanger(HDC hdc, int mode)
: m_hdc(hdc)
{
Change(mode);
}
~wxBkModeChanger()
{
if ( m_oldMode )
::SetBkMode(m_hdc, m_oldMode);
}
protected:
// this ctor doesn't change mode immediately, call Change() later to do it
// only if needed
wxBkModeChanger(HDC hdc) : m_hdc(hdc) { m_oldMode = 0; }
void Change(int mode)
{
m_oldMode = ::SetBkMode(m_hdc, mode == wxBRUSHSTYLE_TRANSPARENT
? TRANSPARENT
: OPAQUE);
if ( !m_oldMode )
{
wxLogLastError(wxT("SetBkMode"));
}
}
private:
const HDC m_hdc;
int m_oldMode;
wxDECLARE_NO_COPY_CLASS(wxBkModeChanger);
};
} // namespace wxMSWImpl
#endif // _MSW_PRIVATE_DC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/msgdlg.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/msgdlg.h
// Purpose: helper functions used with native message dialog
// Author: Rickard Westerlund
// Created: 2010-07-12
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_MSGDLG_H_
#define _WX_MSW_PRIVATE_MSGDLG_H_
#include "wx/msw/wrapcctl.h"
#include "wx/scopedarray.h"
// Macro to help identify if task dialogs are available: we rely on
// TD_WARNING_ICON being defined in the headers for this as this symbol is used
// by the task dialogs only. Also notice that task dialogs are available for
// Unicode applications only.
#if defined(TD_WARNING_ICON) && wxUSE_UNICODE
#define wxHAS_MSW_TASKDIALOG
#endif
// Provides methods for creating a task dialog.
namespace wxMSWMessageDialog
{
#ifdef wxHAS_MSW_TASKDIALOG
class wxMSWTaskDialogConfig
{
public:
enum { MAX_BUTTONS = 4 };
wxMSWTaskDialogConfig()
: buttons(new TASKDIALOG_BUTTON[MAX_BUTTONS]),
parent(NULL),
iconId(0),
style(0),
useCustomLabels(false)
{ }
// initializes the object from a message dialog.
wxMSWTaskDialogConfig(const wxMessageDialogBase& dlg);
wxScopedArray<TASKDIALOG_BUTTON> buttons;
wxWindow *parent;
wxString caption;
wxString message;
wxString extendedMessage;
long iconId;
long style;
bool useCustomLabels;
wxString btnYesLabel;
wxString btnNoLabel;
wxString btnOKLabel;
wxString btnCancelLabel;
wxString btnHelpLabel;
// Will create a task dialog with it's parameters for it's creation
// stored in the provided TASKDIALOGCONFIG parameter.
// NOTE: The wxMSWTaskDialogConfig object needs to remain accessible
// during the subsequent call to TaskDialogIndirect().
void MSWCommonTaskDialogInit(TASKDIALOGCONFIG &tdc);
// Used by MSWCommonTaskDialogInit() to add a regular button or a
// button with a custom label if used.
void AddTaskDialogButton(TASKDIALOGCONFIG &tdc,
int btnCustomId,
int btnCommonId,
const wxString& customLabel);
}; // class wxMSWTaskDialogConfig
typedef HRESULT (WINAPI *TaskDialogIndirect_t)(const TASKDIALOGCONFIG *,
int *, int *, BOOL *);
// Return the pointer to TaskDialogIndirect(). This should only be called
// if HasNativeTaskDialog() returned true and is normally guaranteed to
// succeed in this case.
TaskDialogIndirect_t GetTaskDialogIndirectFunc();
#endif // wxHAS_MSW_TASKDIALOG
// Check if the task dialog is available: this simply checks the OS version
// as we know that it's only present in Vista and later.
bool HasNativeTaskDialog();
// Translates standard MSW button IDs like IDCANCEL into an equivalent
// wx constant such as wxCANCEL.
int MSWTranslateReturnCode(int msAns);
}; // namespace wxMSWMessageDialog
#endif // _WX_MSW_PRIVATE_MSGDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/dcdynwrap.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/dcdynwrap.h
// Purpose: Private dynamically loaded HDC-related functions
// Author: Vadim Zeitlin
// Created: 2016-05-26 (extracted from src/msw/dc.cpp)
// Copyright: (c) 2016 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_DCDYNWRAP_H_
#define _WX_MSW_PRIVATE_DCDYNWRAP_H_
#include "wx/msw/wrapwin.h"
// Namespace for the wrapper functions, hopefully one day we'll be able to get
// rid of all of them and then it will be easy to find all occurrences of their
// use by just searching for this namespace name.
//
// All of the functions in this namespace must work *exactly* like the standard
// functions with the same name and just return an error if dynamically loading
// them failed.
//
// And they're all implemented in src/msw/dc.cpp.
namespace wxDynLoadWrappers
{
DWORD GetLayout(HDC hdc);
DWORD SetLayout(HDC hdc, DWORD dwLayout);
BOOL AlphaBlend(HDC hdcDest, int xDest, int yDest, int wDest, int hDest,
HDC hdcSrc, int xSrc, int ySrc, int wSrc, int hSrc,
BLENDFUNCTION bf);
BOOL GradientFill(HDC hdc, PTRIVERTEX pVert, ULONG numVert,
PVOID pMesh, ULONG numMesh, ULONG mode);
} // namespace wxDynLoadWrappers
#endif // _WX_MSW_PRIVATE_DCDYNWRAP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/button.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/button.h
// Purpose: helper functions used with native BUTTON control
// Author: Vadim Zeitlin
// Created: 2008-06-07
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PRIVATE_BUTTON_H_
#define _WX_MSW_PRIVATE_BUTTON_H_
// define some standard button constants which may be missing in the headers
#ifndef BS_PUSHLIKE
#define BS_PUSHLIKE 0x00001000L
#endif
#ifndef BST_UNCHECKED
#define BST_UNCHECKED 0x0000
#endif
#ifndef BST_CHECKED
#define BST_CHECKED 0x0001
#endif
#ifndef BST_INDETERMINATE
#define BST_INDETERMINATE 0x0002
#endif
namespace wxMSWButton
{
// returns BS_MULTILINE if the label contains new lines or 0 otherwise
inline int GetMultilineStyle(const wxString& label)
{
return label.find(wxT('\n')) == wxString::npos ? 0 : BS_MULTILINE;
}
// update the style of the specified HWND to include or exclude BS_MULTILINE
// depending on whether the label contains the new lines
void UpdateMultilineStyle(HWND hwnd, const wxString& label);
// flags for ComputeBestSize() and GetFittingSize()
enum
{
Size_AuthNeeded = 1,
Size_ExactFit = 2
};
// NB: All the functions below are implemented in src/msw/button.cpp
// Compute the button size (as if wxBU_EXACTFIT were specified, i.e. without
// adjusting it to be of default size if it's smaller) for the given label size
WXDLLIMPEXP_CORE wxSize
GetFittingSize(wxWindow *win, const wxSize& sizeLabel, int flags = 0);
// Compute the button size (as if wxBU_EXACTFIT were specified) by computing
// its label size and then calling GetFittingSize().
wxSize ComputeBestFittingSize(wxControl *btn, int flags = 0);
// Increase the size passed as parameter to be at least the standard button
// size if the control doesn't have wxBU_EXACTFIT style and also cache it as
// the best size and return its value -- this is used in DoGetBestSize()
// implementation.
wxSize IncreaseToStdSizeAndCache(wxControl *btn, const wxSize& size);
// helper of wxToggleButton::DoGetBestSize()
inline wxSize ComputeBestSize(wxControl *btn, int flags = 0)
{
return IncreaseToStdSizeAndCache(btn, ComputeBestFittingSize(btn, flags));
}
} // namespace wxMSWButton
#endif // _WX_MSW_PRIVATE_BUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private/fswatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private/fswatcher.h
// Purpose: File system watcher impl classes
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef WX_MSW_PRIVATE_FSWATCHER_H_
#define WX_MSW_PRIVATE_FSWATCHER_H_
#include "wx/filename.h"
#include "wx/vector.h"
#include "wx/msw/private.h"
// ============================================================================
// wxFSWatcherEntry implementation & helper declarations
// ============================================================================
class wxFSWatcherImplMSW;
class wxFSWatchEntryMSW : public wxFSWatchInfo
{
public:
enum
{
BUFFER_SIZE = 4096 // TODO parametrize
};
wxFSWatchEntryMSW(const wxFSWatchInfo& winfo) :
wxFSWatchInfo(winfo)
{
// get handle for this path
m_handle = OpenDir(m_path);
m_overlapped = (OVERLAPPED*)calloc(1, sizeof(OVERLAPPED));
wxZeroMemory(m_buffer);
}
virtual ~wxFSWatchEntryMSW()
{
wxLogTrace(wxTRACE_FSWATCHER, "Deleting entry '%s'", m_path);
if (m_handle != INVALID_HANDLE_VALUE)
{
if (!CloseHandle(m_handle))
{
wxLogSysError(_("Unable to close the handle for '%s'"),
m_path);
}
}
free(m_overlapped);
}
bool IsOk() const
{
return m_handle != INVALID_HANDLE_VALUE;
}
HANDLE GetHandle() const
{
return m_handle;
}
void* GetBuffer()
{
return m_buffer;
}
OVERLAPPED* GetOverlapped() const
{
return m_overlapped;
}
private:
// opens dir with all flags, attributes etc. necessary to be later
// asynchronous watched with ReadDirectoryChangesW
static HANDLE OpenDir(const wxString& path)
{
HANDLE handle = CreateFile(path.t_str(),
FILE_LIST_DIRECTORY,
FILE_SHARE_READ |
FILE_SHARE_WRITE |
FILE_SHARE_DELETE,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS |
FILE_FLAG_OVERLAPPED,
NULL);
if (handle == INVALID_HANDLE_VALUE)
{
wxLogSysError(_("Failed to open directory \"%s\" for monitoring."),
path);
}
return handle;
}
HANDLE m_handle; // handle to opened directory
char m_buffer[BUFFER_SIZE]; // buffer for fs events
OVERLAPPED* m_overlapped;
wxDECLARE_NO_COPY_CLASS(wxFSWatchEntryMSW);
};
// ============================================================================
// wxFSWatcherImplMSW helper classes implementations
// ============================================================================
class wxIOCPService
{
public:
wxIOCPService() :
m_iocp(INVALID_HANDLE_VALUE)
{
Init();
}
~wxIOCPService()
{
if (m_iocp != INVALID_HANDLE_VALUE)
{
if (!CloseHandle(m_iocp))
{
wxLogSysError(_("Unable to close I/O completion port handle"));
}
}
m_watches.clear();
}
// associates a wxFSWatchEntryMSW with completion port
bool Add(wxSharedPtr<wxFSWatchEntryMSW> watch)
{
wxCHECK_MSG( m_iocp != INVALID_HANDLE_VALUE, false, "IOCP not init" );
wxCHECK_MSG( watch->IsOk(), false, "Invalid watch" );
// associate with IOCP
HANDLE ret = CreateIoCompletionPort(watch->GetHandle(), m_iocp,
(ULONG_PTR)watch.get(), 0);
if (ret == NULL)
{
wxLogSysError(_("Unable to associate handle with "
"I/O completion port"));
return false;
}
else if (ret != m_iocp)
{
wxFAIL_MSG(_("Unexpectedly new I/O completion port was created"));
return false;
}
// add to watch map
wxFSWatchEntries::value_type val(watch->GetPath(), watch);
return m_watches.insert(val).second;
}
// Removes a watch we're currently using. Notice that this doesn't happen
// immediately, CompleteRemoval() must be called later when it's really
// safe to delete the watch, i.e. after completion of the IO operation
// using it.
bool ScheduleForRemoval(const wxSharedPtr<wxFSWatchEntryMSW>& watch)
{
wxCHECK_MSG( m_iocp != INVALID_HANDLE_VALUE, false, "IOCP not init" );
wxCHECK_MSG( watch->IsOk(), false, "Invalid watch" );
const wxString path = watch->GetPath();
wxFSWatchEntries::iterator it = m_watches.find(path);
wxCHECK_MSG( it != m_watches.end(), false,
"Can't remove a watch we don't use" );
// We can't just delete the watch here as we can have pending events
// for it and if we destroyed it now, we could get a dangling (or,
// worse, reused to point to another object) pointer in ReadEvents() so
// just remember that this one should be removed when CompleteRemoval()
// is called later.
m_removedWatches.push_back(watch);
m_watches.erase(it);
return true;
}
// Really remove the watch previously passed to ScheduleForRemoval().
//
// It's ok to call this for a watch that hadn't been removed before, in
// this case we'll just return false and do nothing.
bool CompleteRemoval(wxFSWatchEntryMSW* watch)
{
for ( Watches::iterator it = m_removedWatches.begin();
it != m_removedWatches.end();
++it )
{
if ( (*it).get() == watch )
{
// Removing the object from here will result in deleting the
// watch itself as it's not referenced from anywhere else now.
m_removedWatches.erase(it);
return true;
}
}
return false;
}
// post completion packet
bool PostEmptyStatus()
{
wxCHECK_MSG( m_iocp != INVALID_HANDLE_VALUE, false, "IOCP not init" );
// The special values of 0 will make GetStatus() return Status_Exit.
const int ret = PostQueuedCompletionStatus(m_iocp, 0, 0, NULL);
if (!ret)
{
wxLogSysError(_("Unable to post completion status"));
}
return ret != 0;
}
// Possible return values of GetStatus()
enum Status
{
// Status successfully retrieved into the provided arguments.
Status_OK,
// Special status indicating that we should exit retrieved.
Status_Exit,
// An error occurred because the watched directory was deleted.
Status_Deleted,
// Some other error occurred.
Status_Error
};
// Wait for completion status to arrive.
// This function can block forever in it's wait for completion status.
// Use PostEmptyStatus() to wake it up (and end the worker thread)
Status
GetStatus(DWORD* count, wxFSWatchEntryMSW** watch,
OVERLAPPED** overlapped)
{
wxCHECK_MSG( m_iocp != INVALID_HANDLE_VALUE, Status_Error,
"Invalid IOCP object" );
wxCHECK_MSG( count && watch && overlapped, Status_Error,
"Output parameters can't be NULL" );
const int ret = GetQueuedCompletionStatus(m_iocp, count, (ULONG_PTR *)watch,
overlapped, INFINITE);
if ( ret != 0 )
{
return *count || *watch || *overlapped ? Status_OK : Status_Exit;
}
// An error is returned if the underlying directory has been deleted,
// but this is not really an unexpected failure, so handle it
// specially.
if ( wxSysErrorCode() == ERROR_ACCESS_DENIED &&
*watch && !wxFileName::DirExists((*watch)->GetPath()) )
return Status_Deleted;
// Some other error, at least log it.
wxLogSysError(_("Unable to dequeue completion packet"));
return Status_Error;
}
protected:
bool Init()
{
m_iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
if (m_iocp == NULL)
{
wxLogSysError(_("Unable to create I/O completion port"));
}
return m_iocp != NULL;
}
HANDLE m_iocp;
// The hash containing all the wxFSWatchEntryMSW objects currently being
// watched keyed by their paths.
wxFSWatchEntries m_watches;
// Contains the watches which had been removed but are still pending.
typedef wxVector< wxSharedPtr<wxFSWatchEntryMSW> > Watches;
Watches m_removedWatches;
};
class wxIOCPThread : public wxThread
{
public:
wxIOCPThread(wxFSWatcherImplMSW* service, wxIOCPService* iocp);
// finishes this thread
bool Finish();
protected:
// structure to hold information needed to process one native event
// this is just a dummy holder, so it doesn't take ownership of it's data
struct wxEventProcessingData
{
wxEventProcessingData(const FILE_NOTIFY_INFORMATION* ne,
const wxFSWatchEntryMSW* watch_) :
nativeEvent(ne), watch(watch_)
{}
const FILE_NOTIFY_INFORMATION* nativeEvent;
const wxFSWatchEntryMSW* watch;
};
virtual ExitCode Entry() wxOVERRIDE;
// wait for events to occur, read them and send to interested parties
// returns false it empty status was read, which means we would exit
// true otherwise
bool ReadEvents();
void ProcessNativeEvents(wxVector<wxEventProcessingData>& events);
void SendEvent(wxFileSystemWatcherEvent& evt);
static int Native2WatcherFlags(int flags);
static wxString FileNotifyInformationToString(
const FILE_NOTIFY_INFORMATION& e);
static wxFileName GetEventPath(const wxFSWatchEntryMSW& watch,
const FILE_NOTIFY_INFORMATION& e);
wxFSWatcherImplMSW* m_service;
wxIOCPService* m_iocp;
};
#endif /* WX_MSW_PRIVATE_FSWATCHER_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/protocol/ftp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/protocol/ftp.h
// Purpose: FTP protocol
// Author: Vadim Zeitlin
// Modified by: Mark Johnson, [email protected]
// 20000917 : RmDir, GetLastResult, GetList
// Created: 07/07/1997
// Copyright: (c) 1997, 1998 Guilhem Lavaux
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __WX_FTP_H__
#define __WX_FTP_H__
#include "wx/defs.h"
#if wxUSE_PROTOCOL_FTP
#include "wx/sckaddr.h"
#include "wx/protocol/protocol.h"
#include "wx/url.h"
class WXDLLIMPEXP_NET wxFTP : public wxProtocol
{
public:
enum TransferMode
{
NONE, // not set by user explicitly
ASCII,
BINARY
};
wxFTP();
virtual ~wxFTP();
// Connecting and disconnecting
virtual bool Connect(const wxSockAddress& addr, bool wait = true) wxOVERRIDE;
virtual bool Connect(const wxString& host) wxOVERRIDE { return Connect(host, 0); }
virtual bool Connect(const wxString& host, unsigned short port);
// disconnect
virtual bool Close() wxOVERRIDE;
// Parameters set up
// set transfer mode now
void SetPassive(bool pasv) { m_bPassive = pasv; }
bool SetBinary() { return SetTransferMode(BINARY); }
bool SetAscii() { return SetTransferMode(ASCII); }
bool SetTransferMode(TransferMode mode);
// Generic FTP interface
// FTP doesn't know the MIME type of the last downloaded/uploaded file
virtual wxString GetContentType() const wxOVERRIDE { return wxEmptyString; }
// the last FTP server reply
const wxString& GetLastResult() const { return m_lastResult; }
// send any FTP command (should be full FTP command line but without
// trailing "\r\n") and return its return code
char SendCommand(const wxString& command);
// check that the command returned the given code
bool CheckCommand(const wxString& command, char expectedReturn)
{
// SendCommand() does updates m_lastError
return SendCommand(command) == expectedReturn;
}
// Filesystem commands
bool ChDir(const wxString& dir);
bool MkDir(const wxString& dir);
bool RmDir(const wxString& dir);
wxString Pwd();
bool Rename(const wxString& src, const wxString& dst);
bool RmFile(const wxString& path);
// Get the size of a file in the current dir.
// this function tries its best to deliver the size in bytes using BINARY
// (the SIZE command reports different sizes depending on whether
// type is set to ASCII or BINARY)
// returns -1 if file is non-existent or size could not be found
int GetFileSize(const wxString& fileName);
// Check to see if a file exists in the current dir
bool FileExists(const wxString& fileName);
// Download methods
bool Abort() wxOVERRIDE;
virtual wxInputStream *GetInputStream(const wxString& path) wxOVERRIDE;
virtual wxOutputStream *GetOutputStream(const wxString& path);
// Directory listing
// get the list of full filenames, the format is fixed: one file name per
// line
bool GetFilesList(wxArrayString& files,
const wxString& wildcard = wxEmptyString)
{
return GetList(files, wildcard, false);
}
// get a directory list in server dependent format - this can be shown
// directly to the user
bool GetDirList(wxArrayString& files,
const wxString& wildcard = wxEmptyString)
{
return GetList(files, wildcard, true);
}
// equivalent to either GetFilesList() (default) or GetDirList()
bool GetList(wxArrayString& files,
const wxString& wildcard = wxEmptyString,
bool details = false);
protected:
// this executes a simple ftp command with the given argument and returns
// true if it its return code starts with '2'
bool DoSimpleCommand(const wxChar *command,
const wxString& arg = wxEmptyString);
// get the server reply, return the first character of the reply code,
// '1'..'5' for normal FTP replies, 0 (*not* '0') if an error occurred
char GetResult();
// check that the result is equal to expected value
bool CheckResult(char ch) { return GetResult() == ch; }
// return the socket to be used, Passive/Active versions are used only by
// GetPort()
wxSocketBase *GetPort();
wxSocketBase *GetPassivePort();
wxSocketBase *GetActivePort();
// helper for GetPort()
wxString GetPortCmdArgument(const wxIPV4address& Local, const wxIPV4address& New);
// accept connection from server in active mode, returns the same socket as
// passed in passive mode
wxSocketBase *AcceptIfActive(wxSocketBase *sock);
// internal variables:
wxString m_lastResult;
// true if there is an FTP transfer going on
bool m_streaming;
// although this should be set to ASCII by default according to STD9,
// we will use BINARY transfer mode by default for backwards compatibility
TransferMode m_currentTransfermode;
bool m_bPassive;
// following is true when a read or write times out, we then assume
// the connection is dead and abort. we avoid additional delays this way
bool m_bEncounteredError;
friend class wxInputFTPStream;
friend class wxOutputFTPStream;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxFTP);
DECLARE_PROTOCOL(wxFTP)
};
// the trace mask used by assorted wxLogTrace() in ftp code, do
// wxLog::AddTraceMask(FTP_TRACE_MASK) to see them in output
#define FTP_TRACE_MASK wxT("ftp")
#endif // wxUSE_PROTOCOL_FTP
#endif // __WX_FTP_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/protocol/file.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/protocol/file.h
// Purpose: File protocol
// Author: Guilhem Lavaux
// Modified by:
// Created: 1997
// Copyright: (c) 1997, 1998 Guilhem Lavaux
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __WX_PROTO_FILE_H__
#define __WX_PROTO_FILE_H__
#include "wx/defs.h"
#if wxUSE_PROTOCOL_FILE
#include "wx/protocol/protocol.h"
class WXDLLIMPEXP_NET wxFileProto: public wxProtocol
{
public:
wxFileProto();
virtual ~wxFileProto();
bool Abort() wxOVERRIDE { return true; }
wxString GetContentType() const wxOVERRIDE { return wxEmptyString; }
wxInputStream *GetInputStream(const wxString& path) wxOVERRIDE;
protected:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxFileProto);
DECLARE_PROTOCOL(wxFileProto)
};
#endif // wxUSE_PROTOCOL_FILE
#endif // __WX_PROTO_FILE_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/protocol/protocol.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/protocol/protocol.h
// Purpose: Protocol base class
// Author: Guilhem Lavaux
// Modified by:
// Created: 10/07/1997
// Copyright: (c) 1997, 1998 Guilhem Lavaux
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PROTOCOL_PROTOCOL_H
#define _WX_PROTOCOL_PROTOCOL_H
#include "wx/defs.h"
#if wxUSE_PROTOCOL
#include "wx/object.h"
#include "wx/string.h"
#include "wx/stream.h"
#if wxUSE_SOCKETS
#include "wx/socket.h"
#endif
class WXDLLIMPEXP_FWD_NET wxProtocolLog;
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
enum wxProtocolError
{
wxPROTO_NOERR = 0,
wxPROTO_NETERR,
wxPROTO_PROTERR,
wxPROTO_CONNERR,
wxPROTO_INVVAL,
wxPROTO_NOHNDLR,
wxPROTO_NOFILE,
wxPROTO_ABRT,
wxPROTO_RCNCT,
wxPROTO_STREAMING
};
// ----------------------------------------------------------------------------
// wxProtocol: abstract base class for all protocols
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_NET wxProtocol
#if wxUSE_SOCKETS
: public wxSocketClient
#else
: public wxObject
#endif
{
public:
wxProtocol();
virtual ~wxProtocol();
#if wxUSE_SOCKETS
bool Reconnect();
virtual bool Connect( const wxString& WXUNUSED(host) ) { return false; }
virtual bool Connect( const wxSockAddress& addr, bool WXUNUSED(wait) = true) wxOVERRIDE
{ return wxSocketClient::Connect(addr); }
// read a '\r\n' terminated line from the given socket and put it in
// result (without the terminators)
static wxProtocolError ReadLine(wxSocketBase *socket, wxString& result);
// read a line from this socket - this one can be overridden in the
// derived classes if different line termination convention is to be used
virtual wxProtocolError ReadLine(wxString& result);
#endif // wxUSE_SOCKETS
virtual bool Abort() = 0;
virtual wxInputStream *GetInputStream(const wxString& path) = 0;
virtual wxString GetContentType() const = 0;
// the error code
virtual wxProtocolError GetError() const { return m_lastError; }
void SetUser(const wxString& user) { m_username = user; }
void SetPassword(const wxString& passwd) { m_password = passwd; }
virtual void SetDefaultTimeout(wxUint32 Value);
// override wxSocketBase::SetTimeout function to avoid that the internal
// m_uiDefaultTimeout goes out-of-sync:
virtual void SetTimeout(long seconds) wxOVERRIDE
{ SetDefaultTimeout(seconds); }
// logging support: each wxProtocol object may have the associated logger
// (by default there is none) which is used to log network requests and
// responses
// set the logger, deleting the old one and taking ownership of this one
void SetLog(wxProtocolLog *log);
// return the current logger, may be NULL
wxProtocolLog *GetLog() const { return m_log; }
// detach the existing logger without deleting it, the caller is
// responsible for deleting the returned pointer if it's non-NULL
wxProtocolLog *DetachLog()
{
wxProtocolLog * const log = m_log;
m_log = NULL;
return log;
}
// these functions forward to the same functions with the same names in
// wxProtocolLog if we have a valid logger and do nothing otherwise
void LogRequest(const wxString& str);
void LogResponse(const wxString& str);
protected:
// the timeout associated with the protocol:
wxUint32 m_uiDefaultTimeout;
wxString m_username;
wxString m_password;
// this must be always updated by the derived classes!
wxProtocolError m_lastError;
private:
wxProtocolLog *m_log;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxProtocol);
};
// ----------------------------------------------------------------------------
// macros for protocol classes
// ----------------------------------------------------------------------------
#define DECLARE_PROTOCOL(class) \
public: \
static wxProtoInfo g_proto_##class;
#define IMPLEMENT_PROTOCOL(class, name, serv, host) \
wxProtoInfo class::g_proto_##class(name, serv, host, wxCLASSINFO(class)); \
bool wxProtocolUse##class = true;
#define USE_PROTOCOL(class) \
extern bool wxProtocolUse##class ; \
static struct wxProtocolUserFor##class \
{ \
wxProtocolUserFor##class() { wxProtocolUse##class = true; } \
} wxProtocolDoUse##class;
class WXDLLIMPEXP_NET wxProtoInfo : public wxObject
{
public:
wxProtoInfo(const wxChar *name,
const wxChar *serv_name,
const bool need_host1,
wxClassInfo *info);
protected:
wxProtoInfo *next;
wxString m_protoname;
wxString prefix;
wxString m_servname;
wxClassInfo *m_cinfo;
bool m_needhost;
friend class wxURL;
wxDECLARE_DYNAMIC_CLASS(wxProtoInfo);
wxDECLARE_NO_COPY_CLASS(wxProtoInfo);
};
#endif // wxUSE_PROTOCOL
#endif // _WX_PROTOCOL_PROTOCOL_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/protocol/log.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/protocol/log.h
// Purpose: wxProtocolLog class for logging network exchanges
// Author: Troelsk, Vadim Zeitlin
// Created: 2009-03-06
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PROTOCOL_LOG_H_
#define _WX_PROTOCOL_LOG_H_
#include "wx/string.h"
// ----------------------------------------------------------------------------
// wxProtocolLog: simple class for logging network requests and responses
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_NET wxProtocolLog
{
public:
// Create object doing the logging using wxLogTrace() with the specified
// trace mask.
wxProtocolLog(const wxString& traceMask)
: m_traceMask(traceMask)
{
}
// Virtual dtor for the base class
virtual ~wxProtocolLog() { }
// Called by wxProtocol-derived classes to actually log something
virtual void LogRequest(const wxString& str)
{
DoLogString("==> " + str);
}
virtual void LogResponse(const wxString& str)
{
DoLogString("<== " + str);
}
protected:
// Can be overridden by the derived classes.
virtual void DoLogString(const wxString& str);
private:
const wxString m_traceMask;
wxDECLARE_NO_COPY_CLASS(wxProtocolLog);
};
#endif // _WX_PROTOCOL_LOG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/protocol/http.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/protocol/http.h
// Purpose: HTTP protocol
// Author: Guilhem Lavaux
// Modified by: Simo Virokannas (authentication, Dec 2005)
// Created: August 1997
// Copyright: (c) 1997, 1998 Guilhem Lavaux
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HTTP_H
#define _WX_HTTP_H
#include "wx/defs.h"
#if wxUSE_PROTOCOL_HTTP
#include "wx/hashmap.h"
#include "wx/protocol/protocol.h"
#include "wx/buffer.h"
class WXDLLIMPEXP_NET wxHTTP : public wxProtocol
{
public:
wxHTTP();
virtual ~wxHTTP();
virtual bool Connect(const wxString& host, unsigned short port);
virtual bool Connect(const wxString& host) wxOVERRIDE { return Connect(host, 0); }
virtual bool Connect(const wxSockAddress& addr, bool wait = true) wxOVERRIDE;
bool Abort() wxOVERRIDE;
wxInputStream *GetInputStream(const wxString& path) wxOVERRIDE;
wxString GetContentType() const wxOVERRIDE;
wxString GetHeader(const wxString& header) const;
int GetResponse() const { return m_http_response; }
void SetMethod(const wxString& method) { m_method = method; }
void SetHeader(const wxString& header, const wxString& h_data);
bool SetPostText(const wxString& contentType,
const wxString& data,
const wxMBConv& conv = wxConvUTF8);
bool SetPostBuffer(const wxString& contentType, const wxMemoryBuffer& data);
void SetProxyMode(bool on);
/* Cookies */
wxString GetCookie(const wxString& cookie) const;
bool HasCookies() const { return m_cookies.size() > 0; }
// Use the other SetPostBuffer() overload or SetPostText() instead.
wxDEPRECATED(void SetPostBuffer(const wxString& post_buf));
protected:
typedef wxStringToStringHashMap::iterator wxHeaderIterator;
typedef wxStringToStringHashMap::const_iterator wxHeaderConstIterator;
typedef wxStringToStringHashMap::iterator wxCookieIterator;
typedef wxStringToStringHashMap::const_iterator wxCookieConstIterator;
bool BuildRequest(const wxString& path, const wxString& method);
void SendHeaders();
bool ParseHeaders();
wxString GenerateAuthString(const wxString& user, const wxString& pass) const;
// find the header in m_headers
wxHeaderIterator FindHeader(const wxString& header);
wxHeaderConstIterator FindHeader(const wxString& header) const;
wxCookieIterator FindCookie(const wxString& cookie);
wxCookieConstIterator FindCookie(const wxString& cookie) const;
// deletes the header value strings
void ClearHeaders();
void ClearCookies();
// internal variables:
wxString m_method;
wxStringToStringHashMap m_cookies;
wxStringToStringHashMap m_headers;
bool m_read,
m_proxy_mode;
wxSockAddress *m_addr;
wxMemoryBuffer m_postBuffer;
wxString m_contentType;
int m_http_response;
wxDECLARE_DYNAMIC_CLASS(wxHTTP);
DECLARE_PROTOCOL(wxHTTP)
wxDECLARE_NO_COPY_CLASS(wxHTTP);
};
#endif // wxUSE_PROTOCOL_HTTP
#endif // _WX_HTTP_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/art_internal.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/art_internal.h
// Purpose: Helper functions & classes used by ribbon art providers
// Author: Peter Cawley
// Modified by:
// Created: 2009-08-04
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_ART_INTERNAL_H_
#define _WX_RIBBON_ART_INTERNAL_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
WXDLLIMPEXP_RIBBON wxColour wxRibbonInterpolateColour(
const wxColour& start_colour,
const wxColour& end_colour,
int position,
int start_position,
int end_position);
WXDLLIMPEXP_RIBBON bool wxRibbonCanLabelBreakAtPosition(
const wxString& label,
size_t pos);
WXDLLIMPEXP_RIBBON void wxRibbonDrawParallelGradientLines(
wxDC& dc,
int nlines,
const wxPoint* line_origins,
int stepx,
int stepy,
int numsteps,
int offset_x,
int offset_y,
const wxColour& start_colour,
const wxColour& end_colour);
WXDLLIMPEXP_RIBBON wxBitmap wxRibbonLoadPixmap(
const char* const* bits,
wxColour fore);
/*
HSL colour class, using interface as discussed in wx-dev. Provided mainly
for art providers to perform colour scheme calculations in the HSL colour
space. If such a class makes it into base / core, then this class should be
removed and users switched over to the one in base / core.
0.0 <= Hue < 360.0
0.0 <= Saturation <= 1.0
0.0 <= Luminance <= 1.0
*/
class WXDLLIMPEXP_RIBBON wxRibbonHSLColour
{
public:
wxRibbonHSLColour()
: hue(0.0), saturation(0.0), luminance(0.0) {}
wxRibbonHSLColour(float H, float S, float L)
: hue(H), saturation(S), luminance(L) { }
wxRibbonHSLColour(const wxColour& C);
wxColour ToRGB() const;
wxRibbonHSLColour& MakeDarker(float delta);
wxRibbonHSLColour Darker(float delta) const;
wxRibbonHSLColour Lighter(float delta) const;
wxRibbonHSLColour Saturated(float delta) const;
wxRibbonHSLColour Desaturated(float delta) const;
wxRibbonHSLColour ShiftHue(float delta) const;
float hue, saturation, luminance;
};
WXDLLIMPEXP_RIBBON wxRibbonHSLColour wxRibbonShiftLuminance(
wxRibbonHSLColour colour, float amount);
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_ART_INTERNAL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/panel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/panel.h
// Purpose: Ribbon-style container for a group of related tools / controls
// Author: Peter Cawley
// Modified by:
// Created: 2009-05-25
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_PANEL_H_
#define _WX_RIBBON_PANEL_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/bitmap.h"
#include "wx/ribbon/control.h"
enum wxRibbonPanelOption
{
wxRIBBON_PANEL_NO_AUTO_MINIMISE = 1 << 0,
wxRIBBON_PANEL_EXT_BUTTON = 1 << 3,
wxRIBBON_PANEL_MINIMISE_BUTTON = 1 << 4,
wxRIBBON_PANEL_STRETCH = 1 << 5,
wxRIBBON_PANEL_FLEXIBLE = 1 << 6,
wxRIBBON_PANEL_DEFAULT_STYLE = 0
};
class WXDLLIMPEXP_RIBBON wxRibbonPanel : public wxRibbonControl
{
public:
wxRibbonPanel();
wxRibbonPanel(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxString& label = wxEmptyString,
const wxBitmap& minimised_icon = wxNullBitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxRIBBON_PANEL_DEFAULT_STYLE);
virtual ~wxRibbonPanel();
bool Create(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxString& label = wxEmptyString,
const wxBitmap& icon = wxNullBitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxRIBBON_PANEL_DEFAULT_STYLE);
wxBitmap& GetMinimisedIcon() {return m_minimised_icon;}
const wxBitmap& GetMinimisedIcon() const {return m_minimised_icon;}
bool IsMinimised() const;
bool IsMinimised(wxSize at_size) const;
bool IsHovered() const;
bool IsExtButtonHovered() const;
bool CanAutoMinimise() const;
bool ShowExpanded();
bool HideExpanded();
void SetArtProvider(wxRibbonArtProvider* art) wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
virtual bool Layout() wxOVERRIDE;
virtual wxSize GetMinSize() const wxOVERRIDE;
virtual bool IsSizingContinuous() const wxOVERRIDE;
virtual void AddChild(wxWindowBase *child) wxOVERRIDE;
virtual void RemoveChild(wxWindowBase *child) wxOVERRIDE;
virtual bool HasExtButton() const;
wxRibbonPanel* GetExpandedDummy();
wxRibbonPanel* GetExpandedPanel();
// Finds the best width and height given the parent's width and height
virtual wxSize GetBestSizeForParentSize(const wxSize& parentSize) const wxOVERRIDE;
long GetFlags() { return m_flags; }
void HideIfExpanded();
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize GetPanelSizerBestSize() const;
wxSize GetPanelSizerMinSize() const;
wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
wxSize GetMinNotMinimisedSize() const;
virtual wxSize DoGetNextSmallerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
virtual wxSize DoGetNextLargerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
void DoSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
void OnSize(wxSizeEvent& evt);
void OnEraseBackground(wxEraseEvent& evt);
void OnPaint(wxPaintEvent& evt);
void OnMouseEnter(wxMouseEvent& evt);
void OnMouseEnterChild(wxMouseEvent& evt);
void OnMouseLeave(wxMouseEvent& evt);
void OnMouseLeaveChild(wxMouseEvent& evt);
void OnMouseClick(wxMouseEvent& evt);
void OnMotion(wxMouseEvent& evt);
void OnKillFocus(wxFocusEvent& evt);
void OnChildKillFocus(wxFocusEvent& evt);
void TestPositionForHover(const wxPoint& pos);
bool ShouldSendEventToDummy(wxEvent& evt);
virtual bool TryAfter(wxEvent& evt) wxOVERRIDE;
void CommonInit(const wxString& label, const wxBitmap& icon, long style);
static wxRect GetExpandedPosition(wxRect panel,
wxSize expanded_size,
wxDirection direction);
wxBitmap m_minimised_icon;
wxBitmap m_minimised_icon_resized;
wxSize m_smallest_unminimised_size;
wxSize m_minimised_size;
wxDirection m_preferred_expand_direction;
wxRibbonPanel* m_expanded_dummy;
wxRibbonPanel* m_expanded_panel;
wxWindow* m_child_with_focus;
long m_flags;
bool m_minimised;
bool m_hovered;
bool m_ext_button_hovered;
wxRect m_ext_button_rect;
#ifndef SWIG
wxDECLARE_CLASS(wxRibbonPanel);
wxDECLARE_EVENT_TABLE();
#endif
};
class WXDLLIMPEXP_RIBBON wxRibbonPanelEvent : public wxCommandEvent
{
public:
wxRibbonPanelEvent(wxEventType command_type = wxEVT_NULL,
int win_id = 0,
wxRibbonPanel* panel = NULL)
: wxCommandEvent(command_type, win_id)
, m_panel(panel)
{
}
#ifndef SWIG
wxRibbonPanelEvent(const wxRibbonPanelEvent& e) : wxCommandEvent(e)
{
m_panel = e.m_panel;
}
#endif
wxEvent *Clone() const wxOVERRIDE { return new wxRibbonPanelEvent(*this); }
wxRibbonPanel* GetPanel() {return m_panel;}
void SetPanel(wxRibbonPanel* panel) {m_panel = panel;}
protected:
wxRibbonPanel* m_panel;
#ifndef SWIG
private:
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRibbonPanelEvent);
#endif
};
#ifndef SWIG
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONPANEL_EXTBUTTON_ACTIVATED, wxRibbonPanelEvent);
typedef void (wxEvtHandler::*wxRibbonPanelEventFunction)(wxRibbonPanelEvent&);
#define wxRibbonPanelEventHandler(func) \
wxEVENT_HANDLER_CAST(wxRibbonPanelEventFunction, func)
#define EVT_RIBBONPANEL_EXTBUTTON_ACTIVATED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONPANEL_EXTBUTTON_ACTIVATED, winid, wxRibbonPanelEventHandler(fn))
#else
// wxpython/swig event work
%constant wxEventType wxEVT_RIBBONPANEL_EXTBUTTON_ACTIVATED;
%pythoncode {
EVT_RIBBONPANEL_EXTBUTTON_ACTIVATED = wx.PyEventBinder( wxEVT_RIBBONPANEL_EXTBUTTON_ACTIVATED, 1 )
}
#endif
// old wxEVT_COMMAND_* constants
#define wxEVT_COMMAND_RIBBONPANEL_EXTBUTTON_ACTIVATED wxEVT_RIBBONPANEL_EXTBUTTON_ACTIVATED
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_PANEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/toolbar.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/toolbar.h
// Purpose: Ribbon-style tool bar
// Author: Peter Cawley
// Modified by:
// Created: 2009-07-06
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_TOOLBAR_H_
#define _WX_RIBBON_TOOLBAR_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/ribbon/control.h"
#include "wx/ribbon/art.h"
class wxRibbonToolBarToolBase;
class wxRibbonToolBarToolGroup;
WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxRibbonToolBarToolGroup*, wxArrayRibbonToolBarToolGroup, class WXDLLIMPEXP_RIBBON);
enum wxRibbonToolBarToolState
{
wxRIBBON_TOOLBAR_TOOL_FIRST = 1 << 0,
wxRIBBON_TOOLBAR_TOOL_LAST = 1 << 1,
wxRIBBON_TOOLBAR_TOOL_POSITION_MASK = wxRIBBON_TOOLBAR_TOOL_FIRST | wxRIBBON_TOOLBAR_TOOL_LAST,
wxRIBBON_TOOLBAR_TOOL_NORMAL_HOVERED = 1 << 3,
wxRIBBON_TOOLBAR_TOOL_DROPDOWN_HOVERED = 1 << 4,
wxRIBBON_TOOLBAR_TOOL_HOVER_MASK = wxRIBBON_TOOLBAR_TOOL_NORMAL_HOVERED | wxRIBBON_TOOLBAR_TOOL_DROPDOWN_HOVERED,
wxRIBBON_TOOLBAR_TOOL_NORMAL_ACTIVE = 1 << 5,
wxRIBBON_TOOLBAR_TOOL_DROPDOWN_ACTIVE = 1 << 6,
wxRIBBON_TOOLBAR_TOOL_ACTIVE_MASK = wxRIBBON_TOOLBAR_TOOL_NORMAL_ACTIVE | wxRIBBON_TOOLBAR_TOOL_DROPDOWN_ACTIVE,
wxRIBBON_TOOLBAR_TOOL_DISABLED = 1 << 7,
wxRIBBON_TOOLBAR_TOOL_TOGGLED = 1 << 8,
wxRIBBON_TOOLBAR_TOOL_STATE_MASK = 0x1F8
};
class WXDLLIMPEXP_RIBBON wxRibbonToolBar : public wxRibbonControl
{
public:
wxRibbonToolBar();
wxRibbonToolBar(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
virtual ~wxRibbonToolBar();
bool Create(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
virtual wxRibbonToolBarToolBase* AddTool(
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL);
virtual wxRibbonToolBarToolBase* AddDropdownTool(
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonToolBarToolBase* AddHybridTool(
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonToolBarToolBase* AddToggleTool(
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonToolBarToolBase* AddTool(
int tool_id,
const wxBitmap& bitmap,
const wxBitmap& bitmap_disabled = wxNullBitmap,
const wxString& help_string = wxEmptyString,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL,
wxObject* client_data = NULL);
virtual wxRibbonToolBarToolBase* AddSeparator();
virtual wxRibbonToolBarToolBase* InsertTool(
size_t pos,
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL);
virtual wxRibbonToolBarToolBase* InsertDropdownTool(
size_t pos,
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonToolBarToolBase* InsertHybridTool(
size_t pos,
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonToolBarToolBase* InsertToggleTool(
size_t pos,
int tool_id,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonToolBarToolBase* InsertTool(
size_t pos,
int tool_id,
const wxBitmap& bitmap,
const wxBitmap& bitmap_disabled = wxNullBitmap,
const wxString& help_string = wxEmptyString,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL,
wxObject* client_data = NULL);
virtual wxRibbonToolBarToolBase* InsertSeparator(size_t pos);
virtual void ClearTools();
virtual bool DeleteTool(int tool_id);
virtual bool DeleteToolByPos(size_t pos);
virtual wxRibbonToolBarToolBase* FindById(int tool_id)const;
virtual wxRibbonToolBarToolBase* GetToolByPos(size_t pos)const;
virtual size_t GetToolCount() const;
virtual int GetToolId(const wxRibbonToolBarToolBase* tool)const;
virtual wxObject* GetToolClientData(int tool_id)const;
virtual bool GetToolEnabled(int tool_id)const;
virtual wxString GetToolHelpString(int tool_id)const;
virtual wxRibbonButtonKind GetToolKind(int tool_id)const;
virtual int GetToolPos(int tool_id)const;
virtual bool GetToolState(int tool_id)const;
virtual bool Realize() wxOVERRIDE;
virtual void SetRows(int nMin, int nMax = -1);
virtual void SetToolClientData(int tool_id, wxObject* clientData);
virtual void SetToolDisabledBitmap(int tool_id, const wxBitmap &bitmap);
virtual void SetToolHelpString(int tool_id, const wxString& helpString);
virtual void SetToolNormalBitmap(int tool_id, const wxBitmap &bitmap);
virtual bool IsSizingContinuous() const wxOVERRIDE;
virtual void EnableTool(int tool_id, bool enable = true);
virtual void ToggleTool(int tool_id, bool checked);
// Finds the best width and height given the parent's width and height
virtual wxSize GetBestSizeForParentSize(const wxSize& parentSize) const wxOVERRIDE;
protected:
friend class wxRibbonToolBarEvent;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
void OnEraseBackground(wxEraseEvent& evt);
void OnMouseDown(wxMouseEvent& evt);
void OnMouseEnter(wxMouseEvent& evt);
void OnMouseLeave(wxMouseEvent& evt);
void OnMouseMove(wxMouseEvent& evt);
void OnMouseUp(wxMouseEvent& evt);
void OnPaint(wxPaintEvent& evt);
void OnSize(wxSizeEvent& evt);
virtual wxSize DoGetNextSmallerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
virtual wxSize DoGetNextLargerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
void CommonInit(long style);
void AppendGroup();
wxRibbonToolBarToolGroup* InsertGroup(size_t pos);
virtual void UpdateWindowUI(long flags) wxOVERRIDE;
static wxBitmap MakeDisabledBitmap(const wxBitmap& original);
wxArrayRibbonToolBarToolGroup m_groups;
wxRibbonToolBarToolBase* m_hover_tool;
wxRibbonToolBarToolBase* m_active_tool;
wxSize* m_sizes;
int m_nrows_min;
int m_nrows_max;
#ifndef SWIG
wxDECLARE_CLASS(wxRibbonToolBar);
wxDECLARE_EVENT_TABLE();
#endif
};
class WXDLLIMPEXP_RIBBON wxRibbonToolBarEvent : public wxCommandEvent
{
public:
wxRibbonToolBarEvent(wxEventType command_type = wxEVT_NULL,
int win_id = 0,
wxRibbonToolBar* bar = NULL)
: wxCommandEvent(command_type, win_id)
, m_bar(bar)
{
}
#ifndef SWIG
wxRibbonToolBarEvent(const wxRibbonToolBarEvent& e) : wxCommandEvent(e)
{
m_bar = e.m_bar;
}
#endif
wxEvent *Clone() const wxOVERRIDE { return new wxRibbonToolBarEvent(*this); }
wxRibbonToolBar* GetBar() {return m_bar;}
void SetBar(wxRibbonToolBar* bar) {m_bar = bar;}
bool PopupMenu(wxMenu* menu);
protected:
wxRibbonToolBar* m_bar;
#ifndef SWIG
private:
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRibbonToolBarEvent);
#endif
};
#ifndef SWIG
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONTOOLBAR_CLICKED, wxRibbonToolBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONTOOLBAR_DROPDOWN_CLICKED, wxRibbonToolBarEvent);
typedef void (wxEvtHandler::*wxRibbonToolBarEventFunction)(wxRibbonToolBarEvent&);
#define wxRibbonToolBarEventHandler(func) \
wxEVENT_HANDLER_CAST(wxRibbonToolBarEventFunction, func)
#define EVT_RIBBONTOOLBAR_CLICKED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONTOOLBAR_CLICKED, winid, wxRibbonToolBarEventHandler(fn))
#define EVT_RIBBONTOOLBAR_DROPDOWN_CLICKED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONTOOLBAR_DROPDOWN_CLICKED, winid, wxRibbonToolBarEventHandler(fn))
#else
// wxpython/swig event work
%constant wxEventType wxEVT_RIBBONTOOLBAR_CLICKED;
%constant wxEventType wxEVT_RIBBONTOOLBAR_DROPDOWN_CLICKED;
%pythoncode {
EVT_RIBBONTOOLBAR_CLICKED = wx.PyEventBinder( wxEVT_RIBBONTOOLBAR_CLICKED, 1 )
EVT_RIBBONTOOLBAR_DROPDOWN_CLICKED = wx.PyEventBinder( wxEVT_RIBBONTOOLBAR_DROPDOWN_CLICKED, 1 )
}
#endif
// old wxEVT_COMMAND_* constants
#define wxEVT_COMMAND_RIBBONTOOL_CLICKED wxEVT_RIBBONTOOLBAR_CLICKED
#define wxEVT_COMMAND_RIBBONTOOL_DROPDOWN_CLICKED wxEVT_RIBBONTOOLBAR_DROPDOWN_CLICKED
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_TOOLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/buttonbar.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/buttonbar.h
// Purpose: Ribbon control similar to a tool bar
// Author: Peter Cawley
// Modified by:
// Created: 2009-07-01
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_BUTTON_BAR_H_
#define _WX_RIBBON_BUTTON_BAR_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/ribbon/art.h"
#include "wx/ribbon/control.h"
#include "wx/dynarray.h"
class wxRibbonButtonBarButtonBase;
class wxRibbonButtonBarLayout;
class wxRibbonButtonBarButtonInstance;
WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxRibbonButtonBarLayout*, wxArrayRibbonButtonBarLayout, class WXDLLIMPEXP_RIBBON);
WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxRibbonButtonBarButtonBase*, wxArrayRibbonButtonBarButtonBase, class WXDLLIMPEXP_RIBBON);
class WXDLLIMPEXP_RIBBON wxRibbonButtonBar : public wxRibbonControl
{
public:
wxRibbonButtonBar();
wxRibbonButtonBar(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
virtual ~wxRibbonButtonBar();
bool Create(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
virtual wxRibbonButtonBarButtonBase* AddButton(
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL);
// NB: help_string cannot be optional as that would cause the signature
// to be identical to the full version of AddButton when 3 arguments are
// given.
virtual wxRibbonButtonBarButtonBase* AddDropdownButton(
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonButtonBarButtonBase* AddHybridButton(
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonButtonBarButtonBase* AddToggleButton(
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonButtonBarButtonBase* AddButton(
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxBitmap& bitmap_small = wxNullBitmap,
const wxBitmap& bitmap_disabled = wxNullBitmap,
const wxBitmap& bitmap_small_disabled = wxNullBitmap,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL,
const wxString& help_string = wxEmptyString);
virtual wxRibbonButtonBarButtonBase* InsertButton(
size_t pos,
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL);
virtual wxRibbonButtonBarButtonBase* InsertDropdownButton(
size_t pos,
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonButtonBarButtonBase* InsertHybridButton(
size_t pos,
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonButtonBarButtonBase* InsertToggleButton(
size_t pos,
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxString& help_string = wxEmptyString);
virtual wxRibbonButtonBarButtonBase* InsertButton(
size_t pos,
int button_id,
const wxString& label,
const wxBitmap& bitmap,
const wxBitmap& bitmap_small = wxNullBitmap,
const wxBitmap& bitmap_disabled = wxNullBitmap,
const wxBitmap& bitmap_small_disabled = wxNullBitmap,
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL,
const wxString& help_string = wxEmptyString);
void SetItemClientObject(wxRibbonButtonBarButtonBase* item, wxClientData* data);
wxClientData* GetItemClientObject(const wxRibbonButtonBarButtonBase* item) const;
void SetItemClientData(wxRibbonButtonBarButtonBase* item, void* data);
void* GetItemClientData(const wxRibbonButtonBarButtonBase* item) const;
virtual size_t GetButtonCount() const;
virtual wxRibbonButtonBarButtonBase *GetItem(size_t n) const;
virtual wxRibbonButtonBarButtonBase *GetItemById(int id) const;
virtual int GetItemId(wxRibbonButtonBarButtonBase *button) const;
virtual bool Realize() wxOVERRIDE;
virtual void ClearButtons();
virtual bool DeleteButton(int button_id);
virtual void EnableButton(int button_id, bool enable = true);
virtual void ToggleButton(int button_id, bool checked);
virtual void SetButtonIcon(
int button_id,
const wxBitmap& bitmap,
const wxBitmap& bitmap_small = wxNullBitmap,
const wxBitmap& bitmap_disabled = wxNullBitmap,
const wxBitmap& bitmap_small_disabled = wxNullBitmap);
virtual void SetButtonText(int button_id, const wxString& label);
virtual void SetButtonTextMinWidth(int button_id,
int min_width_medium, int min_width_large);
virtual void SetButtonTextMinWidth(int button_id, const wxString& label);
virtual void SetButtonMinSizeClass(int button_id,
wxRibbonButtonBarButtonState min_size_class);
virtual void SetButtonMaxSizeClass(int button_id,
wxRibbonButtonBarButtonState max_size_class);
virtual wxRibbonButtonBarButtonBase *GetActiveItem() const;
virtual wxRibbonButtonBarButtonBase *GetHoveredItem() const;
virtual void SetArtProvider(wxRibbonArtProvider* art) wxOVERRIDE;
virtual bool IsSizingContinuous() const wxOVERRIDE;
virtual wxSize GetMinSize() const wxOVERRIDE;
void SetShowToolTipsForDisabled(bool show);
bool GetShowToolTipsForDisabled() const;
protected:
friend class wxRibbonButtonBarEvent;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
void OnEraseBackground(wxEraseEvent& evt);
void OnPaint(wxPaintEvent& evt);
void OnSize(wxSizeEvent& evt);
void OnMouseMove(wxMouseEvent& evt);
void OnMouseEnter(wxMouseEvent& evt);
void OnMouseLeave(wxMouseEvent& evt);
void OnMouseDown(wxMouseEvent& evt);
void OnMouseUp(wxMouseEvent& evt);
virtual wxSize DoGetNextSmallerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
virtual wxSize DoGetNextLargerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
void CommonInit(long style);
void MakeLayouts();
void TryCollapseLayout(wxRibbonButtonBarLayout* original,
size_t first_btn, size_t* last_button,
wxRibbonButtonBarButtonState target_size);
void MakeBitmaps(wxRibbonButtonBarButtonBase* base,
const wxBitmap& bitmap_large,
const wxBitmap& bitmap_large_disabled,
const wxBitmap& bitmap_small,
const wxBitmap& bitmap_small_disabled);
static wxBitmap MakeResizedBitmap(const wxBitmap& original, wxSize size);
static wxBitmap MakeDisabledBitmap(const wxBitmap& original);
void FetchButtonSizeInfo(wxRibbonButtonBarButtonBase* button,
wxRibbonButtonBarButtonState size, wxDC& dc);
virtual void UpdateWindowUI(long flags) wxOVERRIDE;
wxArrayRibbonButtonBarLayout m_layouts;
wxArrayRibbonButtonBarButtonBase m_buttons;
wxRibbonButtonBarButtonInstance* m_hovered_button;
wxRibbonButtonBarButtonInstance* m_active_button;
wxPoint m_layout_offset;
wxSize m_bitmap_size_large;
wxSize m_bitmap_size_small;
int m_current_layout;
bool m_layouts_valid;
bool m_lock_active_state;
bool m_show_tooltips_for_disabled;
#ifndef SWIG
wxDECLARE_CLASS(wxRibbonButtonBar);
wxDECLARE_EVENT_TABLE();
#endif
};
class WXDLLIMPEXP_RIBBON wxRibbonButtonBarEvent : public wxCommandEvent
{
public:
wxRibbonButtonBarEvent(wxEventType command_type = wxEVT_NULL,
int win_id = 0,
wxRibbonButtonBar* bar = NULL,
wxRibbonButtonBarButtonBase* button = NULL)
: wxCommandEvent(command_type, win_id)
, m_bar(bar), m_button(button)
{
}
#ifndef SWIG
wxRibbonButtonBarEvent(const wxRibbonButtonBarEvent& e) : wxCommandEvent(e)
{
m_bar = e.m_bar;
m_button = e.m_button;
}
#endif
wxEvent *Clone() const wxOVERRIDE { return new wxRibbonButtonBarEvent(*this); }
wxRibbonButtonBar* GetBar() {return m_bar;}
wxRibbonButtonBarButtonBase *GetButton() { return m_button; }
void SetBar(wxRibbonButtonBar* bar) {m_bar = bar;}
void SetButton(wxRibbonButtonBarButtonBase* button) { m_button = button; }
bool PopupMenu(wxMenu* menu);
protected:
wxRibbonButtonBar* m_bar;
wxRibbonButtonBarButtonBase *m_button;
#ifndef SWIG
private:
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRibbonButtonBarEvent);
#endif
};
#ifndef SWIG
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBUTTONBAR_CLICKED, wxRibbonButtonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED, wxRibbonButtonBarEvent);
typedef void (wxEvtHandler::*wxRibbonButtonBarEventFunction)(wxRibbonButtonBarEvent&);
#define wxRibbonButtonBarEventHandler(func) \
wxEVENT_HANDLER_CAST(wxRibbonButtonBarEventFunction, func)
#define EVT_RIBBONBUTTONBAR_CLICKED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBUTTONBAR_CLICKED, winid, wxRibbonButtonBarEventHandler(fn))
#define EVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED, winid, wxRibbonButtonBarEventHandler(fn))
#else
// wxpython/swig event work
%constant wxEventType wxEVT_RIBBONBUTTONBAR_CLICKED;
%constant wxEventType wxEVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED;
%pythoncode {
EVT_RIBBONBUTTONBAR_CLICKED = wx.PyEventBinder( wxEVT_RIBBONBUTTONBAR_CLICKED, 1 )
EVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED = wx.PyEventBinder( wxEVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED, 1 )
}
#endif
// old wxEVT_COMMAND_* constants
#define wxEVT_COMMAND_RIBBONBUTTON_CLICKED wxEVT_RIBBONBUTTONBAR_CLICKED
#define wxEVT_COMMAND_RIBBONBUTTON_DROPDOWN_CLICKED wxEVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_BUTTON_BAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/gallery.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/gallery.h
// Purpose: Ribbon control which displays a gallery of items to choose from
// Author: Peter Cawley
// Modified by:
// Created: 2009-07-22
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_GALLERY_H_
#define _WX_RIBBON_GALLERY_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/ribbon/art.h"
#include "wx/ribbon/control.h"
class wxRibbonGalleryItem;
WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxRibbonGalleryItem*, wxArrayRibbonGalleryItem, class WXDLLIMPEXP_RIBBON);
class WXDLLIMPEXP_RIBBON wxRibbonGallery : public wxRibbonControl
{
public:
wxRibbonGallery();
wxRibbonGallery(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
virtual ~wxRibbonGallery();
bool Create(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
void Clear();
bool IsEmpty() const;
unsigned int GetCount() const;
wxRibbonGalleryItem* GetItem(unsigned int n);
wxRibbonGalleryItem* Append(const wxBitmap& bitmap, int id);
wxRibbonGalleryItem* Append(const wxBitmap& bitmap, int id, void* clientData);
wxRibbonGalleryItem* Append(const wxBitmap& bitmap, int id, wxClientData* clientData);
void SetItemClientObject(wxRibbonGalleryItem* item, wxClientData* data);
wxClientData* GetItemClientObject(const wxRibbonGalleryItem* item) const;
void SetItemClientData(wxRibbonGalleryItem* item, void* data);
void* GetItemClientData(const wxRibbonGalleryItem* item) const;
void SetSelection(wxRibbonGalleryItem* item);
wxRibbonGalleryItem* GetSelection() const;
wxRibbonGalleryItem* GetHoveredItem() const;
wxRibbonGalleryItem* GetActiveItem() const;
wxRibbonGalleryButtonState GetUpButtonState() const;
wxRibbonGalleryButtonState GetDownButtonState() const;
wxRibbonGalleryButtonState GetExtensionButtonState() const;
bool IsHovered() const;
virtual bool IsSizingContinuous() const wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
virtual bool Layout() wxOVERRIDE;
virtual bool ScrollLines(int lines) wxOVERRIDE;
bool ScrollPixels(int pixels);
void EnsureVisible(const wxRibbonGalleryItem* item);
protected:
wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
void CommonInit(long style);
void CalculateMinSize();
bool TestButtonHover(const wxRect& rect, wxPoint pos,
wxRibbonGalleryButtonState* state);
void OnEraseBackground(wxEraseEvent& evt);
void OnMouseEnter(wxMouseEvent& evt);
void OnMouseMove(wxMouseEvent& evt);
void OnMouseLeave(wxMouseEvent& evt);
void OnMouseDown(wxMouseEvent& evt);
void OnMouseUp(wxMouseEvent& evt);
void OnMouseDClick(wxMouseEvent& evt);
void OnPaint(wxPaintEvent& evt);
void OnSize(wxSizeEvent& evt);
int GetScrollLineSize() const;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetNextSmallerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
virtual wxSize DoGetNextLargerSize(wxOrientation direction,
wxSize relative_to) const wxOVERRIDE;
wxArrayRibbonGalleryItem m_items;
wxRibbonGalleryItem* m_selected_item;
wxRibbonGalleryItem* m_hovered_item;
wxRibbonGalleryItem* m_active_item;
wxSize m_bitmap_size;
wxSize m_bitmap_padded_size;
wxSize m_best_size;
wxRect m_client_rect;
wxRect m_scroll_up_button_rect;
wxRect m_scroll_down_button_rect;
wxRect m_extension_button_rect;
const wxRect* m_mouse_active_rect;
int m_item_separation_x;
int m_item_separation_y;
int m_scroll_amount;
int m_scroll_limit;
wxRibbonGalleryButtonState m_up_button_state;
wxRibbonGalleryButtonState m_down_button_state;
wxRibbonGalleryButtonState m_extension_button_state;
bool m_hovered;
#ifndef SWIG
wxDECLARE_CLASS(wxRibbonGallery);
wxDECLARE_EVENT_TABLE();
#endif
};
class WXDLLIMPEXP_RIBBON wxRibbonGalleryEvent : public wxCommandEvent
{
public:
wxRibbonGalleryEvent(wxEventType command_type = wxEVT_NULL,
int win_id = 0,
wxRibbonGallery* gallery = NULL,
wxRibbonGalleryItem* item = NULL)
: wxCommandEvent(command_type, win_id)
, m_gallery(gallery), m_item(item)
{
}
#ifndef SWIG
wxRibbonGalleryEvent(const wxRibbonGalleryEvent& e) : wxCommandEvent(e)
{
m_gallery = e.m_gallery;
m_item = e.m_item;
}
#endif
wxEvent *Clone() const wxOVERRIDE { return new wxRibbonGalleryEvent(*this); }
wxRibbonGallery* GetGallery() {return m_gallery;}
wxRibbonGalleryItem* GetGalleryItem() {return m_item;}
void SetGallery(wxRibbonGallery* gallery) {m_gallery = gallery;}
void SetGalleryItem(wxRibbonGalleryItem* item) {m_item = item;}
protected:
wxRibbonGallery* m_gallery;
wxRibbonGalleryItem* m_item;
#ifndef SWIG
private:
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRibbonGalleryEvent);
#endif
};
#ifndef SWIG
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONGALLERY_HOVER_CHANGED, wxRibbonGalleryEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONGALLERY_SELECTED, wxRibbonGalleryEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONGALLERY_CLICKED, wxRibbonGalleryEvent);
typedef void (wxEvtHandler::*wxRibbonGalleryEventFunction)(wxRibbonGalleryEvent&);
#define wxRibbonGalleryEventHandler(func) \
wxEVENT_HANDLER_CAST(wxRibbonGalleryEventFunction, func)
#define EVT_RIBBONGALLERY_HOVER_CHANGED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONGALLERY_HOVER_CHANGED, winid, wxRibbonGalleryEventHandler(fn))
#define EVT_RIBBONGALLERY_SELECTED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONGALLERY_SELECTED, winid, wxRibbonGalleryEventHandler(fn))
#define EVT_RIBBONGALLERY_CLICKED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONGALLERY_CLICKED, winid, wxRibbonGalleryEventHandler(fn))
#else
// wxpython/swig event work
%constant wxEventType wxEVT_RIBBONGALLERY_HOVER_CHANGED;
%constant wxEventType wxEVT_RIBBONGALLERY_SELECTED;
%constant wxEventType wxEVT_RIBBONGALLERY_CLICKED;
%pythoncode {
EVT_RIBBONGALLERY_HOVER_CHANGED = wx.PyEventBinder( wxEVT_RIBBONGALLERY_HOVER_CHANGED, 1 )
EVT_RIBBONGALLERY_SELECTED = wx.PyEventBinder( wxEVT_RIBBONGALLERY_SELECTED, 1 )
EVT_RIBBONGALLERY_CLICKED = wx.PyEventBinder( wxEVT_RIBBONGALLERY_CLICKED, 1 )
}
#endif // SWIG
// old wxEVT_COMMAND_* constants
#define wxEVT_COMMAND_RIBBONGALLERY_HOVER_CHANGED wxEVT_RIBBONGALLERY_HOVER_CHANGED
#define wxEVT_COMMAND_RIBBONGALLERY_SELECTED wxEVT_RIBBONGALLERY_SELECTED
#define wxEVT_COMMAND_RIBBONGALLERY_CLICKED wxEVT_RIBBONGALLERY_CLICKED
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_GALLERY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/bar.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/bar.h
// Purpose: Top-level component of the ribbon-bar-style interface
// Author: Peter Cawley
// Modified by:
// Created: 2009-05-23
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_BAR_H_
#define _WX_RIBBON_BAR_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/ribbon/control.h"
#include "wx/ribbon/page.h"
enum wxRibbonBarOption
{
wxRIBBON_BAR_SHOW_PAGE_LABELS = 1 << 0,
wxRIBBON_BAR_SHOW_PAGE_ICONS = 1 << 1,
wxRIBBON_BAR_FLOW_HORIZONTAL = 0,
wxRIBBON_BAR_FLOW_VERTICAL = 1 << 2,
wxRIBBON_BAR_SHOW_PANEL_EXT_BUTTONS = 1 << 3,
wxRIBBON_BAR_SHOW_PANEL_MINIMISE_BUTTONS = 1 << 4,
wxRIBBON_BAR_ALWAYS_SHOW_TABS = 1 << 5,
wxRIBBON_BAR_SHOW_TOGGLE_BUTTON = 1 << 6,
wxRIBBON_BAR_SHOW_HELP_BUTTON = 1 << 7,
wxRIBBON_BAR_DEFAULT_STYLE = wxRIBBON_BAR_FLOW_HORIZONTAL
| wxRIBBON_BAR_SHOW_PAGE_LABELS
| wxRIBBON_BAR_SHOW_PANEL_EXT_BUTTONS
| wxRIBBON_BAR_SHOW_TOGGLE_BUTTON
| wxRIBBON_BAR_SHOW_HELP_BUTTON,
wxRIBBON_BAR_FOLDBAR_STYLE = wxRIBBON_BAR_FLOW_VERTICAL
| wxRIBBON_BAR_SHOW_PAGE_ICONS
| wxRIBBON_BAR_SHOW_PANEL_EXT_BUTTONS
| wxRIBBON_BAR_SHOW_PANEL_MINIMISE_BUTTONS
};
enum wxRibbonDisplayMode
{
wxRIBBON_BAR_PINNED,
wxRIBBON_BAR_MINIMIZED,
wxRIBBON_BAR_EXPANDED
};
class WXDLLIMPEXP_RIBBON wxRibbonBarEvent : public wxNotifyEvent
{
public:
wxRibbonBarEvent(wxEventType command_type = wxEVT_NULL,
int win_id = 0,
wxRibbonPage* page = NULL)
: wxNotifyEvent(command_type, win_id)
, m_page(page)
{
}
#ifndef SWIG
wxRibbonBarEvent(const wxRibbonBarEvent& c) : wxNotifyEvent(c)
{
m_page = c.m_page;
}
#endif
wxEvent *Clone() const wxOVERRIDE { return new wxRibbonBarEvent(*this); }
wxRibbonPage* GetPage() {return m_page;}
void SetPage(wxRibbonPage* page) {m_page = page;}
protected:
wxRibbonPage* m_page;
#ifndef SWIG
private:
wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(wxRibbonBarEvent);
#endif
};
class WXDLLIMPEXP_RIBBON wxRibbonPageTabInfo
{
public:
wxRect rect;
wxRibbonPage *page;
int ideal_width;
int small_begin_need_separator_width;
int small_must_have_separator_width;
int minimum_width;
bool active;
bool hovered;
bool highlight;
bool shown;
};
#ifndef SWIG
WX_DECLARE_USER_EXPORTED_OBJARRAY(wxRibbonPageTabInfo, wxRibbonPageTabInfoArray, WXDLLIMPEXP_RIBBON);
#endif
class WXDLLIMPEXP_RIBBON wxRibbonBar : public wxRibbonControl
{
public:
wxRibbonBar();
wxRibbonBar(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxRIBBON_BAR_DEFAULT_STYLE);
virtual ~wxRibbonBar();
bool Create(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxRIBBON_BAR_DEFAULT_STYLE);
void SetTabCtrlMargins(int left, int right);
void SetArtProvider(wxRibbonArtProvider* art) wxOVERRIDE;
bool SetActivePage(size_t page);
bool SetActivePage(wxRibbonPage* page);
int GetActivePage() const;
wxRibbonPage* GetPage(int n);
size_t GetPageCount() const;
bool DismissExpandedPanel();
int GetPageNumber(wxRibbonPage* page) const;
void DeletePage(size_t n);
void ClearPages();
bool IsPageShown(size_t page) const;
void ShowPage(size_t page, bool show = true);
void HidePage(size_t page) { ShowPage(page, false); }
bool IsPageHighlighted(size_t page) const;
void AddPageHighlight(size_t page, bool highlight = true);
void RemovePageHighlight(size_t page) { AddPageHighlight(page, false); }
void ShowPanels(wxRibbonDisplayMode mode);
void ShowPanels(bool show = true);
void HidePanels() { ShowPanels(wxRIBBON_BAR_MINIMIZED); }
bool ArePanelsShown() const { return m_arePanelsShown; }
wxRibbonDisplayMode GetDisplayMode() const { return m_ribbon_state; }
virtual bool HasMultiplePages() const wxOVERRIDE { return true; }
void SetWindowStyleFlag(long style) wxOVERRIDE;
long GetWindowStyleFlag() const wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
// Implementation only.
bool IsToggleButtonHovered() const { return m_toggle_button_hovered; }
bool IsHelpButtonHovered() const { return m_help_button_hovered; }
void HideIfExpanded();
protected:
friend class wxRibbonPage;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
wxRibbonPageTabInfo* HitTestTabs(wxPoint position, int* index = NULL);
void HitTestRibbonButton(const wxRect& rect, const wxPoint& position, bool &hover_flag);
void CommonInit(long style);
void AddPage(wxRibbonPage *page);
void RecalculateTabSizes();
void RecalculateMinSize();
void ScrollTabBar(int npixels);
void RefreshTabBar();
void RepositionPage(wxRibbonPage *page);
void OnPaint(wxPaintEvent& evt);
void OnEraseBackground(wxEraseEvent& evt);
void DoEraseBackground(wxDC& dc);
void OnSize(wxSizeEvent& evt);
void OnMouseLeftDown(wxMouseEvent& evt);
void OnMouseLeftUp(wxMouseEvent& evt);
void OnMouseMiddleDown(wxMouseEvent& evt);
void OnMouseMiddleUp(wxMouseEvent& evt);
void OnMouseRightDown(wxMouseEvent& evt);
void OnMouseRightUp(wxMouseEvent& evt);
void OnMouseMove(wxMouseEvent& evt);
void OnMouseLeave(wxMouseEvent& evt);
void OnMouseDoubleClick(wxMouseEvent& evt);
void DoMouseButtonCommon(wxMouseEvent& evt, wxEventType tab_event_type);
void OnKillFocus(wxFocusEvent& evt);
wxRibbonPageTabInfoArray m_pages;
wxRect m_tab_scroll_left_button_rect;
wxRect m_tab_scroll_right_button_rect;
wxRect m_toggle_button_rect;
wxRect m_help_button_rect;
long m_flags;
int m_tabs_total_width_ideal;
int m_tabs_total_width_minimum;
int m_tab_margin_left;
int m_tab_margin_right;
int m_tab_height;
int m_tab_scroll_amount;
int m_current_page;
int m_current_hovered_page;
int m_tab_scroll_left_button_state;
int m_tab_scroll_right_button_state;
bool m_tab_scroll_buttons_shown;
bool m_arePanelsShown;
bool m_bar_hovered;
bool m_toggle_button_hovered;
bool m_help_button_hovered;
wxRibbonDisplayMode m_ribbon_state;
#ifndef SWIG
wxDECLARE_CLASS(wxRibbonBar);
wxDECLARE_EVENT_TABLE();
#endif
};
#ifndef SWIG
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_PAGE_CHANGED, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_PAGE_CHANGING, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_TAB_MIDDLE_UP, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_TAB_RIGHT_DOWN, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_TAB_RIGHT_UP, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_TAB_LEFT_DCLICK, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_TOGGLED, wxRibbonBarEvent);
wxDECLARE_EXPORTED_EVENT(WXDLLIMPEXP_RIBBON, wxEVT_RIBBONBAR_HELP_CLICK, wxRibbonBarEvent);
typedef void (wxEvtHandler::*wxRibbonBarEventFunction)(wxRibbonBarEvent&);
#define wxRibbonBarEventHandler(func) \
wxEVENT_HANDLER_CAST(wxRibbonBarEventFunction, func)
#define EVT_RIBBONBAR_PAGE_CHANGED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_PAGE_CHANGED, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_PAGE_CHANGING(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_PAGE_CHANGING, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_TAB_MIDDLE_DOWN(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_TAB_MIDDLE_UP(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_TAB_MIDDLE_UP, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_TAB_RIGHT_DOWN(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_TAB_RIGHT_DOWN, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_TAB_RIGHT_UP(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_TAB_RIGHT_UP, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_TAB_LEFT_DCLICK(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_TAB_LEFT_DCLICK, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_TOGGLED(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_TOGGLED, winid, wxRibbonBarEventHandler(fn))
#define EVT_RIBBONBAR_HELP_CLICK(winid, fn) \
wx__DECLARE_EVT1(wxEVT_RIBBONBAR_HELP_CLICK, winid, wxRibbonBarEventHandler(fn))
#else
// wxpython/swig event work
%constant wxEventType wxEVT_RIBBONBAR_PAGE_CHANGED;
%constant wxEventType wxEVT_RIBBONBAR_PAGE_CHANGING;
%constant wxEventType wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN;
%constant wxEventType wxEVT_RIBBONBAR_TAB_MIDDLE_UP;
%constant wxEventType wxEVT_RIBBONBAR_TAB_RIGHT_DOWN;
%constant wxEventType wxEVT_RIBBONBAR_TAB_RIGHT_UP;
%constant wxEventType wxEVT_RIBBONBAR_TAB_LEFT_DCLICK;
%constant wxEventType wxEVT_RIBBONBAR_TOGGLED;
%constant wxEventType wxEVT_RIBBONBAR_HELP_CLICK;
%pythoncode {
EVT_RIBBONBAR_PAGE_CHANGED = wx.PyEventBinder( wxEVT_RIBBONBAR_PAGE_CHANGED, 1 )
EVT_RIBBONBAR_PAGE_CHANGING = wx.PyEventBinder( wxEVT_RIBBONBAR_PAGE_CHANGING, 1 )
EVT_RIBBONBAR_TAB_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN, 1 )
EVT_RIBBONBAR_TAB_MIDDLE_UP = wx.PyEventBinder( wxEVT_RIBBONBAR_TAB_MIDDLE_UP, 1 )
EVT_RIBBONBAR_TAB_RIGHT_DOWN = wx.PyEventBinder( wxEVT_RIBBONBAR_TAB_RIGHT_DOWN, 1 )
EVT_RIBBONBAR_TAB_RIGHT_UP = wx.PyEventBinder( wxEVT_RIBBONBAR_TAB_RIGHT_UP, 1 )
EVT_RIBBONBAR_TAB_LEFT_DCLICK = wx.PyEventBinder( wxEVT_RIBBONBAR_TAB_LEFT_DCLICK, 1 )
EVT_RIBBONBAR_TOGGLED = wx.PyEventBinder( wxEVT_RIBBONBAR_TOGGLED, 1 )
EVT_RIBBONBAR_HELP_CLICK = wx.PyEventBinder( wxEVT_RIBBONBAR_HELP_CLICK, 1 )
}
#endif
// old wxEVT_COMMAND_* constants
#define wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGED wxEVT_RIBBONBAR_PAGE_CHANGED
#define wxEVT_COMMAND_RIBBONBAR_PAGE_CHANGING wxEVT_RIBBONBAR_PAGE_CHANGING
#define wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_DOWN wxEVT_RIBBONBAR_TAB_MIDDLE_DOWN
#define wxEVT_COMMAND_RIBBONBAR_TAB_MIDDLE_UP wxEVT_RIBBONBAR_TAB_MIDDLE_UP
#define wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_DOWN wxEVT_RIBBONBAR_TAB_RIGHT_DOWN
#define wxEVT_COMMAND_RIBBONBAR_TAB_RIGHT_UP wxEVT_RIBBONBAR_TAB_RIGHT_UP
#define wxEVT_COMMAND_RIBBONBAR_TAB_LEFT_DCLICK wxEVT_RIBBONBAR_TAB_LEFT_DCLICK
#define wxEVT_COMMAND_RIBBONBAR_TOGGLED wxEVT_RIBBONBAR_TOGGLED
#define wxEVT_COMMAND_RIBBONBAR_HELP_CLICKED wxEVT_RIBBONBAR_HELP_CLICK
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_BAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/art.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/art.h
// Purpose: Art providers for ribbon-bar-style interface
// Author: Peter Cawley
// Modified by:
// Created: 2009-05-25
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_ART_H_
#define _WX_RIBBON_ART_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/brush.h"
#include "wx/colour.h"
#include "wx/font.h"
#include "wx/pen.h"
#include "wx/bitmap.h"
#include "wx/ribbon/bar.h"
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxWindow;
enum wxRibbonArtSetting
{
wxRIBBON_ART_TAB_SEPARATION_SIZE,
wxRIBBON_ART_PAGE_BORDER_LEFT_SIZE,
wxRIBBON_ART_PAGE_BORDER_TOP_SIZE,
wxRIBBON_ART_PAGE_BORDER_RIGHT_SIZE,
wxRIBBON_ART_PAGE_BORDER_BOTTOM_SIZE,
wxRIBBON_ART_PANEL_X_SEPARATION_SIZE,
wxRIBBON_ART_PANEL_Y_SEPARATION_SIZE,
wxRIBBON_ART_TOOL_GROUP_SEPARATION_SIZE,
wxRIBBON_ART_GALLERY_BITMAP_PADDING_LEFT_SIZE,
wxRIBBON_ART_GALLERY_BITMAP_PADDING_RIGHT_SIZE,
wxRIBBON_ART_GALLERY_BITMAP_PADDING_TOP_SIZE,
wxRIBBON_ART_GALLERY_BITMAP_PADDING_BOTTOM_SIZE,
wxRIBBON_ART_PANEL_LABEL_FONT,
wxRIBBON_ART_BUTTON_BAR_LABEL_FONT,
wxRIBBON_ART_TAB_LABEL_FONT,
wxRIBBON_ART_BUTTON_BAR_LABEL_COLOUR,
wxRIBBON_ART_BUTTON_BAR_HOVER_BORDER_COLOUR,
wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_COLOUR,
wxRIBBON_ART_BUTTON_BAR_HOVER_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_BUTTON_BAR_ACTIVE_BORDER_COLOUR,
wxRIBBON_ART_BUTTON_BAR_ACTIVE_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_BUTTON_BAR_ACTIVE_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_BUTTON_BAR_ACTIVE_BACKGROUND_COLOUR,
wxRIBBON_ART_BUTTON_BAR_ACTIVE_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_GALLERY_BORDER_COLOUR,
wxRIBBON_ART_GALLERY_HOVER_BACKGROUND_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_BACKGROUND_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_FACE_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_HOVER_BACKGROUND_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_HOVER_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_HOVER_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_HOVER_FACE_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_BACKGROUND_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_ACTIVE_FACE_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_DISABLED_BACKGROUND_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_DISABLED_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_DISABLED_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_GALLERY_BUTTON_DISABLED_FACE_COLOUR,
wxRIBBON_ART_GALLERY_ITEM_BORDER_COLOUR,
wxRIBBON_ART_TAB_LABEL_COLOUR,
wxRIBBON_ART_TAB_SEPARATOR_COLOUR,
wxRIBBON_ART_TAB_SEPARATOR_GRADIENT_COLOUR,
wxRIBBON_ART_TAB_CTRL_BACKGROUND_COLOUR,
wxRIBBON_ART_TAB_CTRL_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_TAB_HOVER_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_TAB_HOVER_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_TAB_HOVER_BACKGROUND_COLOUR,
wxRIBBON_ART_TAB_HOVER_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_COLOUR,
wxRIBBON_ART_TAB_ACTIVE_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_TAB_BORDER_COLOUR,
wxRIBBON_ART_PANEL_BORDER_COLOUR,
wxRIBBON_ART_PANEL_BORDER_GRADIENT_COLOUR,
wxRIBBON_ART_PANEL_MINIMISED_BORDER_COLOUR,
wxRIBBON_ART_PANEL_MINIMISED_BORDER_GRADIENT_COLOUR,
wxRIBBON_ART_PANEL_LABEL_BACKGROUND_COLOUR,
wxRIBBON_ART_PANEL_LABEL_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_PANEL_LABEL_COLOUR,
wxRIBBON_ART_PANEL_HOVER_LABEL_BACKGROUND_COLOUR,
wxRIBBON_ART_PANEL_HOVER_LABEL_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_PANEL_HOVER_LABEL_COLOUR,
wxRIBBON_ART_PANEL_MINIMISED_LABEL_COLOUR,
wxRIBBON_ART_PANEL_ACTIVE_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_PANEL_ACTIVE_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_PANEL_ACTIVE_BACKGROUND_COLOUR,
wxRIBBON_ART_PANEL_ACTIVE_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_PANEL_BUTTON_FACE_COLOUR,
wxRIBBON_ART_PANEL_BUTTON_HOVER_FACE_COLOUR,
wxRIBBON_ART_PAGE_TOGGLE_FACE_COLOUR,
wxRIBBON_ART_PAGE_TOGGLE_HOVER_FACE_COLOUR,
wxRIBBON_ART_PAGE_BORDER_COLOUR,
wxRIBBON_ART_PAGE_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_PAGE_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_PAGE_BACKGROUND_COLOUR,
wxRIBBON_ART_PAGE_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_PAGE_HOVER_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_PAGE_HOVER_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_PAGE_HOVER_BACKGROUND_COLOUR,
wxRIBBON_ART_PAGE_HOVER_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_TOOLBAR_BORDER_COLOUR,
wxRIBBON_ART_TOOLBAR_HOVER_BORDER_COLOUR,
wxRIBBON_ART_TOOLBAR_FACE_COLOUR,
wxRIBBON_ART_TOOL_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_TOOL_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_TOOL_BACKGROUND_COLOUR,
wxRIBBON_ART_TOOL_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_TOOL_HOVER_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_TOOL_HOVER_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_TOOL_HOVER_BACKGROUND_COLOUR,
wxRIBBON_ART_TOOL_HOVER_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_TOOL_ACTIVE_BACKGROUND_TOP_COLOUR,
wxRIBBON_ART_TOOL_ACTIVE_BACKGROUND_TOP_GRADIENT_COLOUR,
wxRIBBON_ART_TOOL_ACTIVE_BACKGROUND_COLOUR,
wxRIBBON_ART_TOOL_ACTIVE_BACKGROUND_GRADIENT_COLOUR,
wxRIBBON_ART_BUTTON_BAR_LABEL_DISABLED_COLOUR,
wxRIBBON_ART_BUTTON_BAR_LABEL_HIGHLIGHT_COLOUR,
wxRIBBON_ART_BUTTON_BAR_LABEL_HIGHLIGHT_GRADIENT_COLOUR,
wxRIBBON_ART_BUTTON_BAR_LABEL_HIGHLIGHT_TOP_COLOUR,
wxRIBBON_ART_BUTTON_BAR_LABEL_HIGHLIGHT_GRADIENT_TOP_COLOUR
};
enum wxRibbonScrollButtonStyle
{
wxRIBBON_SCROLL_BTN_LEFT = 0,
wxRIBBON_SCROLL_BTN_RIGHT = 1,
wxRIBBON_SCROLL_BTN_UP = 2,
wxRIBBON_SCROLL_BTN_DOWN = 3,
wxRIBBON_SCROLL_BTN_DIRECTION_MASK = 3,
wxRIBBON_SCROLL_BTN_NORMAL = 0,
wxRIBBON_SCROLL_BTN_HOVERED = 4,
wxRIBBON_SCROLL_BTN_ACTIVE = 8,
wxRIBBON_SCROLL_BTN_STATE_MASK = 12,
wxRIBBON_SCROLL_BTN_FOR_OTHER = 0,
wxRIBBON_SCROLL_BTN_FOR_TABS = 16,
wxRIBBON_SCROLL_BTN_FOR_PAGE = 32,
wxRIBBON_SCROLL_BTN_FOR_MASK = 48
};
enum wxRibbonButtonKind
{
wxRIBBON_BUTTON_NORMAL = 1 << 0,
wxRIBBON_BUTTON_DROPDOWN = 1 << 1,
wxRIBBON_BUTTON_HYBRID = wxRIBBON_BUTTON_NORMAL | wxRIBBON_BUTTON_DROPDOWN,
wxRIBBON_BUTTON_TOGGLE = 1 << 2
};
enum wxRibbonButtonBarButtonState
{
wxRIBBON_BUTTONBAR_BUTTON_SMALL = 0 << 0,
wxRIBBON_BUTTONBAR_BUTTON_MEDIUM = 1 << 0,
wxRIBBON_BUTTONBAR_BUTTON_LARGE = 2 << 0,
wxRIBBON_BUTTONBAR_BUTTON_SIZE_MASK = 3 << 0,
wxRIBBON_BUTTONBAR_BUTTON_NORMAL_HOVERED = 1 << 3,
wxRIBBON_BUTTONBAR_BUTTON_DROPDOWN_HOVERED = 1 << 4,
wxRIBBON_BUTTONBAR_BUTTON_HOVER_MASK = wxRIBBON_BUTTONBAR_BUTTON_NORMAL_HOVERED | wxRIBBON_BUTTONBAR_BUTTON_DROPDOWN_HOVERED,
wxRIBBON_BUTTONBAR_BUTTON_NORMAL_ACTIVE = 1 << 5,
wxRIBBON_BUTTONBAR_BUTTON_DROPDOWN_ACTIVE = 1 << 6,
wxRIBBON_BUTTONBAR_BUTTON_ACTIVE_MASK = wxRIBBON_BUTTONBAR_BUTTON_NORMAL_ACTIVE | wxRIBBON_BUTTONBAR_BUTTON_DROPDOWN_ACTIVE,
wxRIBBON_BUTTONBAR_BUTTON_DISABLED = 1 << 7,
wxRIBBON_BUTTONBAR_BUTTON_TOGGLED = 1 << 8,
wxRIBBON_BUTTONBAR_BUTTON_STATE_MASK = 0x1F8
};
enum wxRibbonGalleryButtonState
{
wxRIBBON_GALLERY_BUTTON_NORMAL,
wxRIBBON_GALLERY_BUTTON_HOVERED,
wxRIBBON_GALLERY_BUTTON_ACTIVE,
wxRIBBON_GALLERY_BUTTON_DISABLED
};
class wxRibbonBar;
class wxRibbonPage;
class wxRibbonPanel;
class wxRibbonGallery;
class wxRibbonGalleryItem;
class wxRibbonPageTabInfo;
class wxRibbonPageTabInfoArray;
class WXDLLIMPEXP_RIBBON wxRibbonArtProvider
{
public:
wxRibbonArtProvider();
virtual ~wxRibbonArtProvider();
virtual wxRibbonArtProvider* Clone() const = 0;
virtual void SetFlags(long flags) = 0;
virtual long GetFlags() const = 0;
virtual int GetMetric(int id) const = 0;
virtual void SetMetric(int id, int new_val) = 0;
virtual void SetFont(int id, const wxFont& font) = 0;
virtual wxFont GetFont(int id) const = 0;
virtual wxColour GetColour(int id) const = 0;
virtual void SetColour(int id, const wxColor& colour) = 0;
wxColour GetColor(int id) const { return GetColour(id); }
void SetColor(int id, const wxColour& color) { SetColour(id, color); }
virtual void GetColourScheme(wxColour* primary,
wxColour* secondary,
wxColour* tertiary) const = 0;
virtual void SetColourScheme(const wxColour& primary,
const wxColour& secondary,
const wxColour& tertiary) = 0;
virtual void DrawTabCtrlBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) = 0;
virtual void DrawTab(wxDC& dc,
wxWindow* wnd,
const wxRibbonPageTabInfo& tab) = 0;
virtual void DrawTabSeparator(wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
double visibility) = 0;
virtual void DrawPageBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) = 0;
virtual void DrawScrollButton(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
long style) = 0;
virtual void DrawPanelBackground(
wxDC& dc,
wxRibbonPanel* wnd,
const wxRect& rect) = 0;
virtual void DrawGalleryBackground(
wxDC& dc,
wxRibbonGallery* wnd,
const wxRect& rect) = 0;
virtual void DrawGalleryItemBackground(
wxDC& dc,
wxRibbonGallery* wnd,
const wxRect& rect,
wxRibbonGalleryItem* item) = 0;
virtual void DrawMinimisedPanel(
wxDC& dc,
wxRibbonPanel* wnd,
const wxRect& rect,
wxBitmap& bitmap) = 0;
virtual void DrawButtonBarBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) = 0;
virtual void DrawButtonBarButton(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
wxRibbonButtonKind kind,
long state,
const wxString& label,
const wxBitmap& bitmap_large,
const wxBitmap& bitmap_small) = 0;
virtual void DrawToolBarBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) = 0;
virtual void DrawToolGroupBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) = 0;
virtual void DrawTool(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
const wxBitmap& bitmap,
wxRibbonButtonKind kind,
long state) = 0;
virtual void DrawToggleButton(
wxDC& dc,
wxRibbonBar* wnd,
const wxRect& rect,
wxRibbonDisplayMode mode) = 0;
virtual void DrawHelpButton(
wxDC& dc,
wxRibbonBar* wnd,
const wxRect& rect) = 0;
virtual void GetBarTabWidth(
wxDC& dc,
wxWindow* wnd,
const wxString& label,
const wxBitmap& bitmap,
int* ideal,
int* small_begin_need_separator,
int* small_must_have_separator,
int* minimum) = 0;
virtual int GetTabCtrlHeight(
wxDC& dc,
wxWindow* wnd,
const wxRibbonPageTabInfoArray& pages) = 0;
virtual wxSize GetScrollButtonMinimumSize(
wxDC& dc,
wxWindow* wnd,
long style) = 0;
virtual wxSize GetPanelSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize client_size,
wxPoint* client_offset) = 0;
virtual wxSize GetPanelClientSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize size,
wxPoint* client_offset) = 0;
virtual wxRect GetPanelExtButtonArea(
wxDC& dc,
const wxRibbonPanel* wnd,
wxRect rect) = 0;
virtual wxSize GetGallerySize(
wxDC& dc,
const wxRibbonGallery* wnd,
wxSize client_size) = 0;
virtual wxSize GetGalleryClientSize(
wxDC& dc,
const wxRibbonGallery* wnd,
wxSize size,
wxPoint* client_offset,
wxRect* scroll_up_button,
wxRect* scroll_down_button,
wxRect* extension_button) = 0;
virtual wxRect GetPageBackgroundRedrawArea(
wxDC& dc,
const wxRibbonPage* wnd,
wxSize page_old_size,
wxSize page_new_size) = 0;
virtual bool GetButtonBarButtonSize(
wxDC& dc,
wxWindow* wnd,
wxRibbonButtonKind kind,
wxRibbonButtonBarButtonState size,
const wxString& label,
wxCoord text_min_width,
wxSize bitmap_size_large,
wxSize bitmap_size_small,
wxSize* button_size,
wxRect* normal_region,
wxRect* dropdown_region) = 0;
virtual wxCoord GetButtonBarButtonTextWidth(
wxDC& dc, const wxString& label,
wxRibbonButtonKind kind,
wxRibbonButtonBarButtonState size) = 0;
virtual wxSize GetMinimisedPanelMinimumSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize* desired_bitmap_size,
wxDirection* expanded_panel_direction) = 0;
virtual wxSize GetToolSize(
wxDC& dc,
wxWindow* wnd,
wxSize bitmap_size,
wxRibbonButtonKind kind,
bool is_first,
bool is_last,
wxRect* dropdown_region) = 0;
virtual wxRect GetBarToggleButtonArea(const wxRect& rect)= 0;
virtual wxRect GetRibbonHelpButtonArea(const wxRect& rect) = 0;
};
class WXDLLIMPEXP_RIBBON wxRibbonMSWArtProvider : public wxRibbonArtProvider
{
public:
wxRibbonMSWArtProvider(bool set_colour_scheme = true);
virtual ~wxRibbonMSWArtProvider();
wxRibbonArtProvider* Clone() const wxOVERRIDE;
void SetFlags(long flags) wxOVERRIDE;
long GetFlags() const wxOVERRIDE;
int GetMetric(int id) const wxOVERRIDE;
void SetMetric(int id, int new_val) wxOVERRIDE;
void SetFont(int id, const wxFont& font) wxOVERRIDE;
wxFont GetFont(int id) const wxOVERRIDE;
wxColour GetColour(int id) const wxOVERRIDE;
void SetColour(int id, const wxColor& colour) wxOVERRIDE;
void GetColourScheme(wxColour* primary,
wxColour* secondary,
wxColour* tertiary) const wxOVERRIDE;
void SetColourScheme(const wxColour& primary,
const wxColour& secondary,
const wxColour& tertiary) wxOVERRIDE;
int GetTabCtrlHeight(
wxDC& dc,
wxWindow* wnd,
const wxRibbonPageTabInfoArray& pages) wxOVERRIDE;
void DrawTabCtrlBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawTab(wxDC& dc,
wxWindow* wnd,
const wxRibbonPageTabInfo& tab) wxOVERRIDE;
void DrawTabSeparator(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
double visibility) wxOVERRIDE;
void DrawPageBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawScrollButton(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
long style) wxOVERRIDE;
void DrawPanelBackground(
wxDC& dc,
wxRibbonPanel* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawGalleryBackground(
wxDC& dc,
wxRibbonGallery* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawGalleryItemBackground(
wxDC& dc,
wxRibbonGallery* wnd,
const wxRect& rect,
wxRibbonGalleryItem* item) wxOVERRIDE;
void DrawMinimisedPanel(
wxDC& dc,
wxRibbonPanel* wnd,
const wxRect& rect,
wxBitmap& bitmap) wxOVERRIDE;
void DrawButtonBarBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawButtonBarButton(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
wxRibbonButtonKind kind,
long state,
const wxString& label,
const wxBitmap& bitmap_large,
const wxBitmap& bitmap_small) wxOVERRIDE;
void DrawToolBarBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawToolGroupBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawTool(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
const wxBitmap& bitmap,
wxRibbonButtonKind kind,
long state) wxOVERRIDE;
void DrawToggleButton(
wxDC& dc,
wxRibbonBar* wnd,
const wxRect& rect,
wxRibbonDisplayMode mode) wxOVERRIDE;
void DrawHelpButton(wxDC& dc,
wxRibbonBar* wnd,
const wxRect& rect) wxOVERRIDE;
void GetBarTabWidth(
wxDC& dc,
wxWindow* wnd,
const wxString& label,
const wxBitmap& bitmap,
int* ideal,
int* small_begin_need_separator,
int* small_must_have_separator,
int* minimum) wxOVERRIDE;
wxSize GetScrollButtonMinimumSize(
wxDC& dc,
wxWindow* wnd,
long style) wxOVERRIDE;
wxSize GetPanelSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize client_size,
wxPoint* client_offset) wxOVERRIDE;
wxSize GetPanelClientSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize size,
wxPoint* client_offset) wxOVERRIDE;
wxRect GetPanelExtButtonArea(
wxDC& dc,
const wxRibbonPanel* wnd,
wxRect rect) wxOVERRIDE;
wxSize GetGallerySize(
wxDC& dc,
const wxRibbonGallery* wnd,
wxSize client_size) wxOVERRIDE;
wxSize GetGalleryClientSize(
wxDC& dc,
const wxRibbonGallery* wnd,
wxSize size,
wxPoint* client_offset,
wxRect* scroll_up_button,
wxRect* scroll_down_button,
wxRect* extension_button) wxOVERRIDE;
wxRect GetPageBackgroundRedrawArea(
wxDC& dc,
const wxRibbonPage* wnd,
wxSize page_old_size,
wxSize page_new_size) wxOVERRIDE;
bool GetButtonBarButtonSize(
wxDC& dc,
wxWindow* wnd,
wxRibbonButtonKind kind,
wxRibbonButtonBarButtonState size,
const wxString& label,
wxCoord text_min_width,
wxSize bitmap_size_large,
wxSize bitmap_size_small,
wxSize* button_size,
wxRect* normal_region,
wxRect* dropdown_region) wxOVERRIDE;
wxCoord GetButtonBarButtonTextWidth(
wxDC& dc, const wxString& label,
wxRibbonButtonKind kind,
wxRibbonButtonBarButtonState size) wxOVERRIDE;
wxSize GetMinimisedPanelMinimumSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize* desired_bitmap_size,
wxDirection* expanded_panel_direction) wxOVERRIDE;
wxSize GetToolSize(
wxDC& dc,
wxWindow* wnd,
wxSize bitmap_size,
wxRibbonButtonKind kind,
bool is_first,
bool is_last,
wxRect* dropdown_region) wxOVERRIDE;
wxRect GetBarToggleButtonArea(const wxRect& rect) wxOVERRIDE;
wxRect GetRibbonHelpButtonArea(const wxRect& rect) wxOVERRIDE;
protected:
void ReallyDrawTabSeparator(wxWindow* wnd, const wxRect& rect, double visibility);
void DrawPartialPageBackground(wxDC& dc, wxWindow* wnd, const wxRect& rect,
bool allow_hovered = true);
void DrawPartialPageBackground(wxDC& dc, wxWindow* wnd, const wxRect& rect,
wxRibbonPage* page, wxPoint offset, bool hovered = false);
void DrawPanelBorder(wxDC& dc, const wxRect& rect, wxPen& primary_colour,
wxPen& secondary_colour);
void RemovePanelPadding(wxRect* rect);
void DrawDropdownArrow(wxDC& dc, int x, int y, const wxColour& colour);
void DrawGalleryBackgroundCommon(wxDC& dc, wxRibbonGallery* wnd,
const wxRect& rect);
virtual void DrawGalleryButton(wxDC& dc, wxRect rect,
wxRibbonGalleryButtonState state, wxBitmap* bitmaps);
void DrawButtonBarButtonForeground(
wxDC& dc,
const wxRect& rect,
wxRibbonButtonKind kind,
long state,
const wxString& label,
const wxBitmap& bitmap_large,
const wxBitmap& bitmap_small);
void DrawMinimisedPanelCommon(
wxDC& dc,
wxRibbonPanel* wnd,
const wxRect& rect,
wxRect* preview_rect);
void CloneTo(wxRibbonMSWArtProvider* copy) const;
wxBitmap m_cached_tab_separator;
wxBitmap m_gallery_up_bitmap[4];
wxBitmap m_gallery_down_bitmap[4];
wxBitmap m_gallery_extension_bitmap[4];
wxBitmap m_toolbar_drop_bitmap;
wxBitmap m_panel_extension_bitmap[2];
wxBitmap m_ribbon_toggle_up_bitmap[2];
wxBitmap m_ribbon_toggle_down_bitmap[2];
wxBitmap m_ribbon_toggle_pin_bitmap[2];
wxBitmap m_ribbon_bar_help_button_bitmap[2];
wxColour m_primary_scheme_colour;
wxColour m_secondary_scheme_colour;
wxColour m_tertiary_scheme_colour;
wxColour m_button_bar_label_colour;
wxColour m_button_bar_label_disabled_colour;
wxColour m_tab_label_colour;
wxColour m_tab_separator_colour;
wxColour m_tab_separator_gradient_colour;
wxColour m_tab_active_background_colour;
wxColour m_tab_active_background_gradient_colour;
wxColour m_tab_hover_background_colour;
wxColour m_tab_hover_background_gradient_colour;
wxColour m_tab_hover_background_top_colour;
wxColour m_tab_hover_background_top_gradient_colour;
wxColour m_tab_highlight_top_colour;
wxColour m_tab_highlight_top_gradient_colour;
wxColour m_tab_highlight_colour;
wxColour m_tab_highlight_gradient_colour;
wxColour m_panel_label_colour;
wxColour m_panel_minimised_label_colour;
wxColour m_panel_hover_label_colour;
wxColour m_panel_active_background_colour;
wxColour m_panel_active_background_gradient_colour;
wxColour m_panel_active_background_top_colour;
wxColour m_panel_active_background_top_gradient_colour;
wxColour m_panel_button_face_colour;
wxColour m_panel_button_hover_face_colour;
wxColour m_page_toggle_face_colour;
wxColour m_page_toggle_hover_face_colour;
wxColour m_page_background_colour;
wxColour m_page_background_gradient_colour;
wxColour m_page_background_top_colour;
wxColour m_page_background_top_gradient_colour;
wxColour m_page_hover_background_colour;
wxColour m_page_hover_background_gradient_colour;
wxColour m_page_hover_background_top_colour;
wxColour m_page_hover_background_top_gradient_colour;
wxColour m_button_bar_hover_background_colour;
wxColour m_button_bar_hover_background_gradient_colour;
wxColour m_button_bar_hover_background_top_colour;
wxColour m_button_bar_hover_background_top_gradient_colour;
wxColour m_button_bar_active_background_colour;
wxColour m_button_bar_active_background_gradient_colour;
wxColour m_button_bar_active_background_top_colour;
wxColour m_button_bar_active_background_top_gradient_colour;
wxColour m_gallery_button_background_colour;
wxColour m_gallery_button_background_gradient_colour;
wxColour m_gallery_button_hover_background_colour;
wxColour m_gallery_button_hover_background_gradient_colour;
wxColour m_gallery_button_active_background_colour;
wxColour m_gallery_button_active_background_gradient_colour;
wxColour m_gallery_button_disabled_background_colour;
wxColour m_gallery_button_disabled_background_gradient_colour;
wxColour m_gallery_button_face_colour;
wxColour m_gallery_button_hover_face_colour;
wxColour m_gallery_button_active_face_colour;
wxColour m_gallery_button_disabled_face_colour;
wxColour m_tool_face_colour;
wxColour m_tool_background_top_colour;
wxColour m_tool_background_top_gradient_colour;
wxColour m_tool_background_colour;
wxColour m_tool_background_gradient_colour;
wxColour m_tool_hover_background_top_colour;
wxColour m_tool_hover_background_top_gradient_colour;
wxColour m_tool_hover_background_colour;
wxColour m_tool_hover_background_gradient_colour;
wxColour m_tool_active_background_top_colour;
wxColour m_tool_active_background_top_gradient_colour;
wxColour m_tool_active_background_colour;
wxColour m_tool_active_background_gradient_colour;
wxBrush m_tab_ctrl_background_brush;
wxBrush m_panel_label_background_brush;
wxBrush m_panel_hover_label_background_brush;
wxBrush m_panel_hover_button_background_brush;
wxBrush m_gallery_hover_background_brush;
wxBrush m_gallery_button_background_top_brush;
wxBrush m_gallery_button_hover_background_top_brush;
wxBrush m_gallery_button_active_background_top_brush;
wxBrush m_gallery_button_disabled_background_top_brush;
wxBrush m_ribbon_toggle_brush;
wxFont m_tab_label_font;
wxFont m_panel_label_font;
wxFont m_button_bar_label_font;
wxPen m_page_border_pen;
wxPen m_panel_border_pen;
wxPen m_panel_border_gradient_pen;
wxPen m_panel_minimised_border_pen;
wxPen m_panel_minimised_border_gradient_pen;
wxPen m_panel_hover_button_border_pen;
wxPen m_tab_border_pen;
wxPen m_button_bar_hover_border_pen;
wxPen m_button_bar_active_border_pen;
wxPen m_gallery_border_pen;
wxPen m_gallery_item_border_pen;
wxPen m_toolbar_border_pen;
wxPen m_ribbon_toggle_pen;
double m_cached_tab_separator_visibility;
long m_flags;
int m_tab_separation_size;
int m_page_border_left;
int m_page_border_top;
int m_page_border_right;
int m_page_border_bottom;
int m_panel_x_separation_size;
int m_panel_y_separation_size;
int m_tool_group_separation_size;
int m_gallery_bitmap_padding_left_size;
int m_gallery_bitmap_padding_right_size;
int m_gallery_bitmap_padding_top_size;
int m_gallery_bitmap_padding_bottom_size;
int m_toggle_button_offset;
int m_help_button_offset;
};
class WXDLLIMPEXP_RIBBON wxRibbonAUIArtProvider : public wxRibbonMSWArtProvider
{
public:
wxRibbonAUIArtProvider();
virtual ~wxRibbonAUIArtProvider();
wxRibbonArtProvider* Clone() const wxOVERRIDE;
wxColour GetColour(int id) const wxOVERRIDE;
void SetColour(int id, const wxColor& colour) wxOVERRIDE;
void SetColourScheme(const wxColour& primary,
const wxColour& secondary,
const wxColour& tertiary) wxOVERRIDE;
void SetFont(int id, const wxFont& font) wxOVERRIDE;
wxSize GetScrollButtonMinimumSize(
wxDC& dc,
wxWindow* wnd,
long style) wxOVERRIDE;
void DrawScrollButton(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
long style) wxOVERRIDE;
wxSize GetPanelSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize client_size,
wxPoint* client_offset) wxOVERRIDE;
wxSize GetPanelClientSize(
wxDC& dc,
const wxRibbonPanel* wnd,
wxSize size,
wxPoint* client_offset) wxOVERRIDE;
wxRect GetPanelExtButtonArea(
wxDC& dc,
const wxRibbonPanel* wnd,
wxRect rect) wxOVERRIDE;
void DrawTabCtrlBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
int GetTabCtrlHeight(
wxDC& dc,
wxWindow* wnd,
const wxRibbonPageTabInfoArray& pages) wxOVERRIDE;
void GetBarTabWidth(
wxDC& dc,
wxWindow* wnd,
const wxString& label,
const wxBitmap& bitmap,
int* ideal,
int* small_begin_need_separator,
int* small_must_have_separator,
int* minimum) wxOVERRIDE;
void DrawTab(wxDC& dc,
wxWindow* wnd,
const wxRibbonPageTabInfo& tab) wxOVERRIDE;
void DrawTabSeparator(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
double visibility) wxOVERRIDE;
void DrawPageBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawPanelBackground(
wxDC& dc,
wxRibbonPanel* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawMinimisedPanel(
wxDC& dc,
wxRibbonPanel* wnd,
const wxRect& rect,
wxBitmap& bitmap) wxOVERRIDE;
void DrawGalleryBackground(
wxDC& dc,
wxRibbonGallery* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawGalleryItemBackground(
wxDC& dc,
wxRibbonGallery* wnd,
const wxRect& rect,
wxRibbonGalleryItem* item) wxOVERRIDE;
void DrawButtonBarBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawButtonBarButton(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
wxRibbonButtonKind kind,
long state,
const wxString& label,
const wxBitmap& bitmap_large,
const wxBitmap& bitmap_small) wxOVERRIDE;
void DrawToolBarBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawToolGroupBackground(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect) wxOVERRIDE;
void DrawTool(
wxDC& dc,
wxWindow* wnd,
const wxRect& rect,
const wxBitmap& bitmap,
wxRibbonButtonKind kind,
long state) wxOVERRIDE;
protected:
void DrawPartialPanelBackground(wxDC& dc, wxWindow* wnd,
const wxRect& rect);
void DrawGalleryButton(wxDC& dc, wxRect rect,
wxRibbonGalleryButtonState state, wxBitmap* bitmaps) wxOVERRIDE;
wxColour m_tab_ctrl_background_colour;
wxColour m_tab_ctrl_background_gradient_colour;
wxColour m_panel_label_background_colour;
wxColour m_panel_label_background_gradient_colour;
wxColour m_panel_hover_label_background_colour;
wxColour m_panel_hover_label_background_gradient_colour;
wxBrush m_background_brush;
wxBrush m_tab_active_top_background_brush;
wxBrush m_tab_hover_background_brush;
wxBrush m_button_bar_hover_background_brush;
wxBrush m_button_bar_active_background_brush;
wxBrush m_gallery_button_active_background_brush;
wxBrush m_gallery_button_hover_background_brush;
wxBrush m_gallery_button_disabled_background_brush;
wxBrush m_tool_hover_background_brush;
wxBrush m_tool_active_background_brush;
wxPen m_toolbar_hover_borden_pen;
wxFont m_tab_active_label_font;
};
#if defined(__WXMSW__)
typedef wxRibbonMSWArtProvider wxRibbonDefaultArtProvider;
#elif defined(__WXOSX_COCOA__) || \
defined(__WXOSX_IPHONE__)
// TODO: Once implemented, change typedef to OSX
// typedef wxRibbonOSXArtProvider wxRibbonDefaultArtProvider;
typedef wxRibbonAUIArtProvider wxRibbonDefaultArtProvider;
#else
// TODO: Once implemented, change typedef to AUI
typedef wxRibbonAUIArtProvider wxRibbonDefaultArtProvider;
#endif
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_ART_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/control.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/control.h
// Purpose: Extension of wxControl with common ribbon methods
// Author: Peter Cawley
// Modified by:
// Created: 2009-06-05
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_CONTROL_H_
#define _WX_RIBBON_CONTROL_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/control.h"
#include "wx/dynarray.h"
class wxRibbonBar;
class wxRibbonArtProvider;
class WXDLLIMPEXP_RIBBON wxRibbonControl : public wxControl
{
public:
wxRibbonControl() { Init(); }
wxRibbonControl(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr)
{
Init();
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr);
virtual void SetArtProvider(wxRibbonArtProvider* art);
wxRibbonArtProvider* GetArtProvider() const {return m_art;}
virtual bool IsSizingContinuous() const {return true;}
wxSize GetNextSmallerSize(wxOrientation direction, wxSize relative_to) const;
wxSize GetNextLargerSize(wxOrientation direction, wxSize relative_to) const;
wxSize GetNextSmallerSize(wxOrientation direction) const;
wxSize GetNextLargerSize(wxOrientation direction) const;
virtual bool Realize();
bool Realise() {return Realize();}
virtual wxRibbonBar* GetAncestorRibbonBar()const;
// Finds the best width and height given the parent's width and height
virtual wxSize GetBestSizeForParentSize(const wxSize& WXUNUSED(parentSize)) const { return GetBestSize(); }
protected:
wxRibbonArtProvider* m_art;
virtual wxSize DoGetNextSmallerSize(wxOrientation direction,
wxSize relative_to) const;
virtual wxSize DoGetNextLargerSize(wxOrientation direction,
wxSize relative_to) const;
private:
void Init() { m_art = NULL; }
#ifndef SWIG
wxDECLARE_CLASS(wxRibbonControl);
#endif
};
WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxRibbonControl*, wxArrayRibbonControl, class WXDLLIMPEXP_RIBBON);
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_CONTROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/ribbon/page.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/ribbon/page.h
// Purpose: Container for ribbon-bar-style interface panels
// Author: Peter Cawley
// Modified by:
// Created: 2009-05-25
// Copyright: (C) Peter Cawley
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RIBBON_PAGE_H_
#define _WX_RIBBON_PAGE_H_
#include "wx/defs.h"
#if wxUSE_RIBBON
#include "wx/ribbon/control.h"
#include "wx/ribbon/panel.h"
#include "wx/bitmap.h"
class wxRibbonBar;
class wxRibbonPageScrollButton;
class WXDLLIMPEXP_RIBBON wxRibbonPage : public wxRibbonControl
{
public:
wxRibbonPage();
wxRibbonPage(wxRibbonBar* parent,
wxWindowID id = wxID_ANY,
const wxString& label = wxEmptyString,
const wxBitmap& icon = wxNullBitmap,
long style = 0);
virtual ~wxRibbonPage();
bool Create(wxRibbonBar* parent,
wxWindowID id = wxID_ANY,
const wxString& label = wxEmptyString,
const wxBitmap& icon = wxNullBitmap,
long style = 0);
void SetArtProvider(wxRibbonArtProvider* art) wxOVERRIDE;
wxBitmap& GetIcon() {return m_icon;}
virtual wxSize GetMinSize() const wxOVERRIDE;
void SetSizeWithScrollButtonAdjustment(int x, int y, int width, int height);
void AdjustRectToIncludeScrollButtons(wxRect* rect) const;
bool DismissExpandedPanel();
virtual bool Realize() wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Layout() wxOVERRIDE;
virtual bool ScrollLines(int lines) wxOVERRIDE;
bool ScrollPixels(int pixels);
bool ScrollSections(int sections);
wxOrientation GetMajorAxis() const;
virtual void RemoveChild(wxWindowBase *child) wxOVERRIDE;
void HideIfExpanded();
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
void DoSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
bool DoActualLayout();
void OnEraseBackground(wxEraseEvent& evt);
void OnPaint(wxPaintEvent& evt);
void OnSize(wxSizeEvent& evt);
bool ExpandPanels(wxOrientation direction, int maximum_amount);
bool CollapsePanels(wxOrientation direction, int minimum_amount);
bool ShowScrollButtons();
void HideScrollButtons();
void CommonInit(const wxString& label, const wxBitmap& icon);
void PopulateSizeCalcArray(wxSize (wxWindow::*get_size)(void) const);
wxArrayRibbonControl m_collapse_stack;
wxBitmap m_icon;
wxSize m_old_size;
// NB: Scroll button windows are siblings rather than children (to get correct clipping of children)
wxRibbonPageScrollButton* m_scroll_left_btn;
wxRibbonPageScrollButton* m_scroll_right_btn;
wxSize* m_size_calc_array;
size_t m_size_calc_array_size;
int m_scroll_amount;
int m_scroll_amount_limit;
int m_size_in_major_axis_for_children;
bool m_scroll_buttons_visible;
#ifndef SWIG
wxDECLARE_CLASS(wxRibbonPage);
wxDECLARE_EVENT_TABLE();
#endif
};
#endif // wxUSE_RIBBON
#endif // _WX_RIBBON_PAGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/xml/xml.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/xml/xml.h
// Purpose: wxXmlDocument - XML parser & data holder class
// Author: Vaclav Slavik
// Created: 2000/03/05
// Copyright: (c) 2000 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_XML_H_
#define _WX_XML_H_
#include "wx/defs.h"
#if wxUSE_XML
#include "wx/string.h"
#include "wx/object.h"
#include "wx/list.h"
#include "wx/textbuf.h"
#include "wx/versioninfo.h"
#ifdef WXMAKINGDLL_XML
#define WXDLLIMPEXP_XML WXEXPORT
#elif defined(WXUSINGDLL)
#define WXDLLIMPEXP_XML WXIMPORT
#else // not making nor using DLL
#define WXDLLIMPEXP_XML
#endif
class WXDLLIMPEXP_FWD_XML wxXmlNode;
class WXDLLIMPEXP_FWD_XML wxXmlAttribute;
class WXDLLIMPEXP_FWD_XML wxXmlDocument;
class WXDLLIMPEXP_FWD_XML wxXmlIOHandler;
class WXDLLIMPEXP_FWD_BASE wxInputStream;
class WXDLLIMPEXP_FWD_BASE wxOutputStream;
// Represents XML node type.
enum wxXmlNodeType
{
// note: values are synchronized with xmlElementType from libxml
wxXML_ELEMENT_NODE = 1,
wxXML_ATTRIBUTE_NODE = 2,
wxXML_TEXT_NODE = 3,
wxXML_CDATA_SECTION_NODE = 4,
wxXML_ENTITY_REF_NODE = 5,
wxXML_ENTITY_NODE = 6,
wxXML_PI_NODE = 7,
wxXML_COMMENT_NODE = 8,
wxXML_DOCUMENT_NODE = 9,
wxXML_DOCUMENT_TYPE_NODE = 10,
wxXML_DOCUMENT_FRAG_NODE = 11,
wxXML_NOTATION_NODE = 12,
wxXML_HTML_DOCUMENT_NODE = 13
};
// Represents node property(ies).
// Example: in <img src="hello.gif" id="3"/> "src" is property with value
// "hello.gif" and "id" is prop. with value "3".
class WXDLLIMPEXP_XML wxXmlAttribute
{
public:
wxXmlAttribute() : m_next(NULL) {}
wxXmlAttribute(const wxString& name, const wxString& value,
wxXmlAttribute *next = NULL)
: m_name(name), m_value(value), m_next(next) {}
virtual ~wxXmlAttribute() {}
const wxString& GetName() const { return m_name; }
const wxString& GetValue() const { return m_value; }
wxXmlAttribute *GetNext() const { return m_next; }
void SetName(const wxString& name) { m_name = name; }
void SetValue(const wxString& value) { m_value = value; }
void SetNext(wxXmlAttribute *next) { m_next = next; }
private:
wxString m_name;
wxString m_value;
wxXmlAttribute *m_next;
};
#if WXWIN_COMPATIBILITY_2_8
// NB: #define is used instead of typedef so that forward declarations
// continue to work
#define wxXmlProperty wxXmlAttribute
#endif
// Represents node in XML document. Node has name and may have content and
// attributes. Most common node types are wxXML_TEXT_NODE (name and attributes
// are irrelevant) and wxXML_ELEMENT_NODE (e.g. in <title>hi</title> there is
// element with name="title", irrelevant content and one child (wxXML_TEXT_NODE
// with content="hi").
//
// If wxUSE_UNICODE is 0, all strings are encoded in the encoding given to Load
// (default is UTF-8).
class WXDLLIMPEXP_XML wxXmlNode
{
public:
wxXmlNode()
: m_attrs(NULL), m_parent(NULL), m_children(NULL), m_next(NULL),
m_lineNo(-1), m_noConversion(false)
{
}
wxXmlNode(wxXmlNode *parent, wxXmlNodeType type,
const wxString& name, const wxString& content = wxEmptyString,
wxXmlAttribute *attrs = NULL, wxXmlNode *next = NULL,
int lineNo = -1);
virtual ~wxXmlNode();
// copy ctor & operator=. Note that this does NOT copy siblings
// and parent pointer, i.e. m_parent and m_next will be NULL
// after using copy ctor and are never unmodified by operator=.
// On the other hand, it DOES copy children and attributes.
wxXmlNode(const wxXmlNode& node);
wxXmlNode& operator=(const wxXmlNode& node);
// user-friendly creation:
wxXmlNode(wxXmlNodeType type, const wxString& name,
const wxString& content = wxEmptyString,
int lineNo = -1);
virtual void AddChild(wxXmlNode *child);
virtual bool InsertChild(wxXmlNode *child, wxXmlNode *followingNode);
virtual bool InsertChildAfter(wxXmlNode *child, wxXmlNode *precedingNode);
virtual bool RemoveChild(wxXmlNode *child);
virtual void AddAttribute(const wxString& name, const wxString& value);
virtual bool DeleteAttribute(const wxString& name);
// access methods:
wxXmlNodeType GetType() const { return m_type; }
const wxString& GetName() const { return m_name; }
const wxString& GetContent() const { return m_content; }
bool IsWhitespaceOnly() const;
int GetDepth(wxXmlNode *grandparent = NULL) const;
// Gets node content from wxXML_ENTITY_NODE
// The problem is, <tag>content<tag> is represented as
// wxXML_ENTITY_NODE name="tag", content=""
// |-- wxXML_TEXT_NODE or
// wxXML_CDATA_SECTION_NODE name="" content="content"
wxString GetNodeContent() const;
wxXmlNode *GetParent() const { return m_parent; }
wxXmlNode *GetNext() const { return m_next; }
wxXmlNode *GetChildren() const { return m_children; }
wxXmlAttribute *GetAttributes() const { return m_attrs; }
bool GetAttribute(const wxString& attrName, wxString *value) const;
wxString GetAttribute(const wxString& attrName,
const wxString& defaultVal = wxEmptyString) const;
bool HasAttribute(const wxString& attrName) const;
int GetLineNumber() const { return m_lineNo; }
void SetType(wxXmlNodeType type) { m_type = type; }
void SetName(const wxString& name) { m_name = name; }
void SetContent(const wxString& con) { m_content = con; }
void SetParent(wxXmlNode *parent) { m_parent = parent; }
void SetNext(wxXmlNode *next) { m_next = next; }
void SetChildren(wxXmlNode *child) { m_children = child; }
void SetAttributes(wxXmlAttribute *attr) { m_attrs = attr; }
virtual void AddAttribute(wxXmlAttribute *attr);
// If true, don't do encoding conversion to improve efficiency - node content is ACII text
bool GetNoConversion() const { return m_noConversion; }
void SetNoConversion(bool noconversion) { m_noConversion = noconversion; }
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED( inline wxXmlAttribute *GetProperties() const );
wxDEPRECATED( inline bool GetPropVal(const wxString& propName,
wxString *value) const );
wxDEPRECATED( inline wxString GetPropVal(const wxString& propName,
const wxString& defaultVal) const );
wxDEPRECATED( inline bool HasProp(const wxString& propName) const );
wxDEPRECATED( inline void SetProperties(wxXmlAttribute *prop) );
#endif // WXWIN_COMPATIBILITY_2_8
// The following three functions are backward compatibility, but because
// they were virtual, we must make it possible to override them. This
// is done by calling e.g. AddProperty() from AddAttribute(), so we have
// to keep AddProperty() even if 2.8 compatibility is off. To prevent
// old code from compiling in that case, we make them private and
// non-virtual. (This can be removed when WXWIN_COMPATIBILITY_2_8 is
// removed, we'll have just *Attribute versions then.)
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_BUT_USED_INTERNALLY(
virtual void AddProperty(const wxString& name, const wxString& value) );
wxDEPRECATED_BUT_USED_INTERNALLY(
virtual bool DeleteProperty(const wxString& name) );
wxDEPRECATED_BUT_USED_INTERNALLY(
virtual void AddProperty(wxXmlAttribute *attr) );
#else
private:
void AddProperty(const wxString& name, const wxString& value);
bool DeleteProperty(const wxString& name);
void AddProperty(wxXmlAttribute *attr);
#endif // WXWIN_COMPATIBILITY_2_8/!WXWIN_COMPATIBILITY_2_8
private:
wxXmlNodeType m_type;
wxString m_name;
wxString m_content;
wxXmlAttribute *m_attrs;
wxXmlNode *m_parent, *m_children, *m_next;
int m_lineNo; // line number in original file, or -1
bool m_noConversion; // don't do encoding conversion - node is plain text
void DoFree();
void DoCopy(const wxXmlNode& node);
};
#if WXWIN_COMPATIBILITY_2_8
inline wxXmlAttribute *wxXmlNode::GetProperties() const
{ return GetAttributes(); }
inline bool wxXmlNode::GetPropVal(const wxString& propName,
wxString *value) const
{ return GetAttribute(propName, value); }
inline wxString wxXmlNode::GetPropVal(const wxString& propName,
const wxString& defaultVal) const
{ return GetAttribute(propName, defaultVal); }
inline bool wxXmlNode::HasProp(const wxString& propName) const
{ return HasAttribute(propName); }
inline void wxXmlNode::SetProperties(wxXmlAttribute *prop)
{ SetAttributes(prop); }
#endif // WXWIN_COMPATIBILITY_2_8
class WXDLLIMPEXP_XML wxXmlDoctype
{
public:
explicit
wxXmlDoctype(const wxString& name = wxString(),
const wxString& sysid = wxString(),
const wxString& pubid = wxString())
: m_rootName(name), m_systemId(sysid), m_publicId(pubid)
{}
// Default copy ctor and assignment operators are ok.
bool IsValid() const;
void Clear();
const wxString& GetRootName() const { return m_rootName; }
const wxString& GetSystemId() const { return m_systemId; }
const wxString& GetPublicId() const { return m_publicId; }
wxString GetFullString() const;
private:
wxString m_rootName;
wxString m_systemId;
wxString m_publicId;
};
// special indentation value for wxXmlDocument::Save
#define wxXML_NO_INDENTATION (-1)
// flags for wxXmlDocument::Load
enum wxXmlDocumentLoadFlag
{
wxXMLDOC_NONE = 0,
wxXMLDOC_KEEP_WHITESPACE_NODES = 1
};
// This class holds XML data/document as parsed by XML parser.
class WXDLLIMPEXP_XML wxXmlDocument : public wxObject
{
public:
wxXmlDocument();
wxXmlDocument(const wxString& filename,
const wxString& encoding = wxT("UTF-8"));
wxXmlDocument(wxInputStream& stream,
const wxString& encoding = wxT("UTF-8"));
virtual ~wxXmlDocument() { wxDELETE(m_docNode); }
wxXmlDocument(const wxXmlDocument& doc);
wxXmlDocument& operator=(const wxXmlDocument& doc);
// Parses .xml file and loads data. Returns TRUE on success, FALSE
// otherwise.
virtual bool Load(const wxString& filename,
const wxString& encoding = wxT("UTF-8"), int flags = wxXMLDOC_NONE);
virtual bool Load(wxInputStream& stream,
const wxString& encoding = wxT("UTF-8"), int flags = wxXMLDOC_NONE);
// Saves document as .xml file.
virtual bool Save(const wxString& filename, int indentstep = 2) const;
virtual bool Save(wxOutputStream& stream, int indentstep = 2) const;
bool IsOk() const { return GetRoot() != NULL; }
// Returns root node of the document.
wxXmlNode *GetRoot() const;
// Returns the document node.
wxXmlNode *GetDocumentNode() const { return m_docNode; }
// Returns version of document (may be empty).
const wxString& GetVersion() const { return m_version; }
// Returns encoding of document (may be empty).
// Note: this is the encoding original file was saved in, *not* the
// encoding of in-memory representation!
const wxString& GetFileEncoding() const { return m_fileEncoding; }
const wxXmlDoctype& GetDoctype() const { return m_doctype; }
// Returns file type of document
wxTextFileType GetFileType() const { return m_fileType; }
wxString GetEOL() const { return m_eol; }
// Write-access methods:
wxXmlNode *DetachDocumentNode() { wxXmlNode *old=m_docNode; m_docNode=NULL; return old; }
void SetDocumentNode(wxXmlNode *node) { wxDELETE(m_docNode); m_docNode = node; }
wxXmlNode *DetachRoot();
void SetRoot(wxXmlNode *node);
void SetVersion(const wxString& version) { m_version = version; }
void SetFileEncoding(const wxString& encoding) { m_fileEncoding = encoding; }
void SetDoctype(const wxXmlDoctype& doctype) { m_doctype = doctype; }
void SetFileType(wxTextFileType fileType);
void AppendToProlog(wxXmlNode *node);
#if !wxUSE_UNICODE
// Returns encoding of in-memory representation of the document
// (same as passed to Load or ctor, defaults to UTF-8).
// NB: this is meaningless in Unicode build where data are stored as wchar_t*
wxString GetEncoding() const { return m_encoding; }
void SetEncoding(const wxString& enc) { m_encoding = enc; }
#endif
static wxVersionInfo GetLibraryVersionInfo();
private:
wxString m_version;
wxString m_fileEncoding;
#if !wxUSE_UNICODE
wxString m_encoding;
#endif
wxXmlDoctype m_doctype;
wxXmlNode *m_docNode;
wxTextFileType m_fileType;
wxString m_eol;
void DoCopy(const wxXmlDocument& doc);
wxDECLARE_CLASS(wxXmlDocument);
};
#endif // wxUSE_XML
#endif // _WX_XML_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/webview_webkit.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/gtk/wx/webview.h
// Purpose: GTK webkit backend for web view component
// Author: Robert Roebling, Marianne Gagnon
// Copyright: (c) 2010 Marianne Gagnon, 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_WEBKITCTRL_H_
#define _WX_GTK_WEBKITCTRL_H_
#include "wx/defs.h"
// NOTE: this header is used for both the WebKit1 and WebKit2 implementations
#if wxUSE_WEBVIEW && (wxUSE_WEBVIEW_WEBKIT || wxUSE_WEBVIEW_WEBKIT2) && defined(__WXGTK__)
#include "wx/sharedptr.h"
#include "wx/webview.h"
#if wxUSE_WEBVIEW_WEBKIT2
#include <glib.h>
#include <gio/gio.h>
#endif
typedef struct _WebKitWebView WebKitWebView;
//-----------------------------------------------------------------------------
// wxWebViewWebKit
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_WEBVIEW wxWebViewWebKit : public wxWebView
{
public:
wxWebViewWebKit();
wxWebViewWebKit(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& url = wxWebViewDefaultURLStr,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxWebViewNameStr)
{
Create(parent, id, url, pos, size, style, name);
}
virtual bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& url = wxWebViewDefaultURLStr,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxWebViewNameStr) wxOVERRIDE;
virtual ~wxWebViewWebKit();
virtual bool Enable( bool enable = true ) wxOVERRIDE;
// implementation
// --------------
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
virtual void Stop() wxOVERRIDE;
virtual void LoadURL(const wxString& url) wxOVERRIDE;
virtual void GoBack() wxOVERRIDE;
virtual void GoForward() wxOVERRIDE;
virtual void Reload(wxWebViewReloadFlags flags = wxWEBVIEW_RELOAD_DEFAULT) wxOVERRIDE;
virtual bool CanGoBack() const wxOVERRIDE;
virtual bool CanGoForward() const wxOVERRIDE;
virtual void ClearHistory() wxOVERRIDE;
virtual void EnableContextMenu(bool enable = true) wxOVERRIDE;
virtual void EnableHistory(bool enable = true) wxOVERRIDE;
virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetBackwardHistory() wxOVERRIDE;
virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetForwardHistory() wxOVERRIDE;
virtual void LoadHistoryItem(wxSharedPtr<wxWebViewHistoryItem> item) wxOVERRIDE;
virtual wxString GetCurrentURL() const wxOVERRIDE;
virtual wxString GetCurrentTitle() const wxOVERRIDE;
virtual wxString GetPageSource() const wxOVERRIDE;
virtual wxString GetPageText() const wxOVERRIDE;
virtual void Print() wxOVERRIDE;
virtual bool IsBusy() const wxOVERRIDE;
void SetZoomType(wxWebViewZoomType) wxOVERRIDE;
wxWebViewZoomType GetZoomType() const wxOVERRIDE;
bool CanSetZoomType(wxWebViewZoomType) const wxOVERRIDE;
virtual wxWebViewZoom GetZoom() const wxOVERRIDE;
virtual void SetZoom(wxWebViewZoom) wxOVERRIDE;
//Clipboard functions
virtual bool CanCut() const wxOVERRIDE;
virtual bool CanCopy() const wxOVERRIDE;
virtual bool CanPaste() const wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Copy() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
//Undo / redo functionality
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
//Find function
virtual long Find(const wxString& text, int flags = wxWEBVIEW_FIND_DEFAULT) wxOVERRIDE;
//Editing functions
virtual void SetEditable(bool enable = true) wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
//Selection
virtual void DeleteSelection() wxOVERRIDE;
virtual bool HasSelection() const wxOVERRIDE;
virtual void SelectAll() wxOVERRIDE;
virtual wxString GetSelectedText() const wxOVERRIDE;
virtual wxString GetSelectedSource() const wxOVERRIDE;
virtual void ClearSelection() wxOVERRIDE;
virtual bool RunScript(const wxString& javascript, wxString* output = NULL) wxOVERRIDE;
//Virtual Filesystem Support
virtual void RegisterHandler(wxSharedPtr<wxWebViewHandler> handler) wxOVERRIDE;
virtual wxVector<wxSharedPtr<wxWebViewHandler> > GetHandlers() { return m_handlerList; }
virtual void* GetNativeBackend() const wxOVERRIDE { return m_web_view; }
/** TODO: check if this can be made private
* The native control has a getter to check for busy state, but except in
* very recent versions of webkit this getter doesn't say everything we need
* (namely it seems to stay indefinitely busy when loading is cancelled by
* user)
*/
bool m_busy;
wxString m_vfsurl;
//We use this flag to stop recursion when we load a page from the navigation
//callback, mainly when loading a VFS page
bool m_guard;
//This flag is use to indicate when a navigation event is the result of a
//create-web-view signal and so we need to send a new window event
bool m_creating;
protected:
virtual void DoSetPage(const wxString& html, const wxString& baseUrl) wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
private:
void ZoomIn();
void ZoomOut();
void SetWebkitZoom(float level);
float GetWebkitZoom() const;
//Find helper function
void FindClear();
// focus event handler: calls GTKUpdateBitmap()
void GTKOnFocus(wxFocusEvent& event);
#if wxUSE_WEBVIEW_WEBKIT2
bool CanExecuteEditingCommand(const gchar* command) const;
void SetupWebExtensionServer();
bool RunScriptSync(const wxString& javascript, wxString* output = NULL);
#endif
WebKitWebView *m_web_view;
int m_historyLimit;
wxVector<wxSharedPtr<wxWebViewHandler> > m_handlerList;
//variables used for Find()
int m_findFlags;
wxString m_findText;
int m_findPosition;
int m_findCount;
#if wxUSE_WEBVIEW_WEBKIT2
//Used for webkit2 extension
GDBusServer *m_dbusServer;
GDBusProxy *m_extension;
#endif
wxDECLARE_DYNAMIC_CLASS(wxWebViewWebKit);
};
class WXDLLIMPEXP_WEBVIEW wxWebViewFactoryWebKit : public wxWebViewFactory
{
public:
virtual wxWebView* Create() wxOVERRIDE { return new wxWebViewWebKit; }
virtual wxWebView* Create(wxWindow* parent,
wxWindowID id,
const wxString& url = wxWebViewDefaultURLStr,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxWebViewNameStr) wxOVERRIDE
{ return new wxWebViewWebKit(parent, id, url, pos, size, style, name); }
};
#endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT && defined(__WXGTK__)
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/dcclient.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/dcclient.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKDCCLIENT_H_
#define _WX_GTKDCCLIENT_H_
#include "wx/gtk/dc.h"
//-----------------------------------------------------------------------------
// wxWindowDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDCImpl : public wxGTKDCImpl
{
public:
wxWindowDCImpl( wxDC *owner );
wxWindowDCImpl( wxDC *owner, wxWindow *win );
virtual ~wxWindowDCImpl();
virtual bool CanDrawBitmap() const wxOVERRIDE { return true; }
virtual bool CanGetTextExtent() const wxOVERRIDE { return true; }
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual bool DoFloodFill( wxCoord x, wxCoord y, const wxColour& col,
wxFloodFillStyle style=wxFLOOD_SURFACE ) wxOVERRIDE;
virtual bool DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const wxOVERRIDE;
virtual void DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 ) wxOVERRIDE;
virtual void DoCrossHair( wxCoord x, wxCoord y ) wxOVERRIDE;
virtual void DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc ) wxOVERRIDE;
virtual void DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height,
double sa, double ea ) wxOVERRIDE;
virtual void DoDrawPoint( wxCoord x, wxCoord y ) wxOVERRIDE;
virtual void DoDrawLines(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset) wxOVERRIDE;
virtual void DoDrawPolygon(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
wxPolygonFillMode fillStyle = wxODDEVEN_RULE) wxOVERRIDE;
virtual void DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height ) wxOVERRIDE;
virtual void DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius = 20.0 ) wxOVERRIDE;
virtual void DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height ) wxOVERRIDE;
virtual void DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y ) wxOVERRIDE;
virtual void DoDrawBitmap( const wxBitmap &bitmap, wxCoord x, wxCoord y,
bool useMask = false ) wxOVERRIDE;
virtual bool DoBlit( wxCoord xdest, wxCoord ydest,
wxCoord width, wxCoord height,
wxDC *source, wxCoord xsrc, wxCoord ysrc,
wxRasterOperationMode logical_func = wxCOPY,
bool useMask = false,
wxCoord xsrcMask = -1, wxCoord ysrcMask = -1 ) wxOVERRIDE;
virtual void DoDrawText( const wxString &text, wxCoord x, wxCoord y ) wxOVERRIDE;
virtual void DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y,
double angle) wxOVERRIDE;
virtual void DoGetTextExtent( const wxString &string,
wxCoord *width, wxCoord *height,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
const wxFont *theFont = NULL) const wxOVERRIDE;
virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const wxOVERRIDE;
virtual void DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height ) wxOVERRIDE;
virtual void DoSetDeviceClippingRegion( const wxRegion ®ion ) wxOVERRIDE;
virtual bool DoGetClippingRect(wxRect& rect) const wxOVERRIDE;
virtual wxCoord GetCharWidth() const wxOVERRIDE;
virtual wxCoord GetCharHeight() const wxOVERRIDE;
virtual void Clear() wxOVERRIDE;
virtual void SetFont( const wxFont &font ) wxOVERRIDE;
virtual void SetPen( const wxPen &pen ) wxOVERRIDE;
virtual void SetBrush( const wxBrush &brush ) wxOVERRIDE;
virtual void SetBackground( const wxBrush &brush ) wxOVERRIDE;
virtual void SetLogicalFunction( wxRasterOperationMode function ) wxOVERRIDE;
virtual void SetTextForeground( const wxColour &col ) wxOVERRIDE;
virtual void SetTextBackground( const wxColour &col ) wxOVERRIDE;
virtual void SetBackgroundMode( int mode ) wxOVERRIDE;
#if wxUSE_PALETTE
virtual void SetPalette( const wxPalette& palette ) wxOVERRIDE;
#endif
virtual void DestroyClippingRegion() wxOVERRIDE;
// Resolution in pixels per logical inch
virtual wxSize GetPPI() const wxOVERRIDE;
virtual int GetDepth() const wxOVERRIDE;
// overrriden here for RTL
virtual void SetDeviceOrigin( wxCoord x, wxCoord y ) wxOVERRIDE;
virtual void SetAxisOrientation( bool xLeftRight, bool yBottomUp ) wxOVERRIDE;
// protected:
// implementation
// --------------
GdkWindow *m_gdkwindow;
GdkGC *m_penGC;
GdkGC *m_brushGC;
GdkGC *m_textGC;
GdkGC *m_bgGC;
GdkColormap *m_cmap;
bool m_isScreenDC;
wxRegion m_currentClippingRegion;
wxRegion m_paintClippingRegion;
bool m_isClipBoxValid;
// PangoContext stuff for GTK 2.0
PangoContext *m_context;
PangoLayout *m_layout;
PangoFontDescription *m_fontdesc;
void SetUpDC( bool ismem = false );
void Destroy();
virtual void ComputeScaleAndOrigin() wxOVERRIDE;
virtual GdkWindow *GetGDKWindow() const wxOVERRIDE { return m_gdkwindow; }
// Update the internal clip box variables
void UpdateClipBox();
private:
void DrawingSetup(GdkGC*& gc, bool& originChanged);
GdkPixmap* MonoToColor(GdkPixmap* monoPixmap, int x, int y, int w, int h) const;
wxDECLARE_ABSTRACT_CLASS(wxWindowDCImpl);
};
//-----------------------------------------------------------------------------
// wxClientDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
{
public:
wxClientDCImpl( wxDC *owner );
wxClientDCImpl( wxDC *owner, wxWindow *win );
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
wxDECLARE_ABSTRACT_CLASS(wxClientDCImpl);
};
//-----------------------------------------------------------------------------
// wxPaintDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
{
public:
wxPaintDCImpl( wxDC *owner );
wxPaintDCImpl( wxDC *owner, wxWindow *win );
wxDECLARE_ABSTRACT_CLASS(wxPaintDCImpl);
};
#endif // _WX_GTKDCCLIENT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/setup.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/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 --- */
// GTK-specific options used when not using configure. As we can't test for the
// exact GTK version (without including GTK+ headers that we don't want to
// include from our own public headers), just assume a recent GTK 2.x.
#define __WXGTK20__
#define __WXGTK210__
#define __WXGTK218__
//#define __WXGTK3__
#endif // _WX_SETUP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/font.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/font.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_FONT_H_
#define _WX_GTK_FONT_H_
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFont : public wxFontBase
{
public:
wxFont() { }
wxFont(const wxFontInfo& info);
wxFont(const wxString& nativeFontInfoString)
{
Create(nativeFontInfoString);
}
wxFont(const wxNativeFontInfo& info);
wxFont(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(size, family, style, weight, underlined, face, encoding);
}
wxFont(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(10, family, style, weight, underlined, face, encoding);
SetPixelSize(pixelSize);
}
bool Create(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
// wxGTK-specific
bool Create(const wxString& fontname);
virtual ~wxFont();
// implement base class pure virtuals
virtual float GetFractionalPointSize() const wxOVERRIDE;
virtual wxFontStyle GetStyle() const wxOVERRIDE;
virtual int GetNumericWeight() const wxOVERRIDE;
virtual wxString GetFaceName() const wxOVERRIDE;
virtual bool GetUnderlined() const wxOVERRIDE;
virtual bool GetStrikethrough() const wxOVERRIDE;
virtual wxFontEncoding GetEncoding() const wxOVERRIDE;
virtual const wxNativeFontInfo *GetNativeFontInfo() const wxOVERRIDE;
virtual bool IsFixedWidth() const wxOVERRIDE;
virtual void SetFractionalPointSize(float pointSize) wxOVERRIDE;
virtual void SetFamily(wxFontFamily family) wxOVERRIDE;
virtual void SetStyle(wxFontStyle style) wxOVERRIDE;
virtual void SetNumericWeight(int weight) wxOVERRIDE;
virtual bool SetFaceName( const wxString& faceName ) wxOVERRIDE;
virtual void SetUnderlined( bool underlined ) wxOVERRIDE;
virtual void SetStrikethrough(bool strikethrough) wxOVERRIDE;
virtual void SetEncoding(wxFontEncoding encoding) wxOVERRIDE;
wxDECLARE_COMMON_FONT_METHODS();
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants")
wxFont(int size,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(size, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight, underlined, face, encoding);
}
// Set Pango attributes in the specified layout. Currently only
// underlined and strike-through attributes are handled by this function.
//
// If neither of them is specified, returns false, otherwise sets up the
// attributes and returns true.
bool GTKSetPangoAttrs(PangoLayout* layout) const;
protected:
virtual void DoSetNativeFontInfo( const wxNativeFontInfo& info ) wxOVERRIDE;
virtual wxGDIRefData* CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData* CloneGDIRefData(const wxGDIRefData* data) const wxOVERRIDE;
virtual wxFontFamily DoGetFamily() const wxOVERRIDE;
private:
void Init();
wxDECLARE_DYNAMIC_CLASS(wxFont);
};
#endif // _WX_GTK_FONT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/filectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/filectrl.h
// Purpose: wxGtkFileCtrl Header
// Author: Diaa M. Sami
// Modified by:
// Created: Aug-10-2007
// Copyright: (c) Diaa M. Sami
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_FILECTRL_H_
#define _WX_GTK_FILECTRL_H_
#include "wx/control.h"
#include "wx/filectrl.h"
extern WXDLLIMPEXP_DATA_CORE(const char) wxFileSelectorDefaultWildcardStr[];
typedef struct _GtkFileChooser GtkFileChooser;
// [GTK] current problems:
// All methods(e.g. SetFilename(), SetPath(), etc) which change the state of
// the control result in events fired, such events should be suppressed.
// ------
// Sometimes a selection event(with 0 files) is fired before
// wxEVT_FILECTRL_FOLDERCHANGED, unfortunately this can hardly be detected!
// A wx wrapper for any Gtk object implementing the interface GtkFileChooser
class WXDLLIMPEXP_CORE wxGtkFileChooser
{
public:
wxGtkFileChooser() { m_ignoreNextFilterEvent = false; }
void SetWidget(GtkFileChooser *w);
wxString GetPath() const;
void GetPaths( wxArrayString& paths ) const;
wxString GetDirectory() const;
wxString GetFilename() const;
void GetFilenames( wxArrayString& files ) const;
int GetFilterIndex() const;
bool SetPath( const wxString& path );
bool SetDirectory( const wxString& dir );
void SetWildcard( const wxString& wildCard );
void SetFilterIndex( int filterIndex );
bool HasFilterChoice() const;
bool ShouldIgnoreNextFilterEvent() const { return m_ignoreNextFilterEvent; }
wxString GetCurrentWildCard() const
{ return m_wildcards[GetFilterIndex()]; }
private:
GtkFileChooser *m_widget;
// First wildcard in filter, to be used when the user
// saves a file without giving an extension.
wxArrayString m_wildcards;
// If true, ignore the next event because it was generated by us and not
// the user.
bool m_ignoreNextFilterEvent;
};
#if wxUSE_FILECTRL
class WXDLLIMPEXP_CORE wxGtkFileCtrl: public wxControl,
public wxFileCtrlBase
{
public:
wxGtkFileCtrl () { Init(); }
wxGtkFileCtrl ( wxWindow *parent,
wxWindowID id,
const wxString& defaultDirectory = wxEmptyString,
const wxString& defaultFilename = wxEmptyString,
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = wxFC_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxFileCtrlNameStr )
{
Init();
Create( parent, id, defaultDirectory, defaultFilename, wildCard, style, pos, size, name );
}
virtual ~wxGtkFileCtrl();
bool Create( wxWindow *parent,
wxWindowID id,
const wxString& defaultDirectory = wxEmptyString,
const wxString& defaultFileName = wxEmptyString,
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = wxFC_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxFileCtrlNameStr );
virtual void SetWildcard( const wxString& wildCard ) wxOVERRIDE;
virtual void SetFilterIndex( int filterIndex ) wxOVERRIDE;
virtual bool SetDirectory( const wxString& dir ) wxOVERRIDE;
virtual bool SetFilename( const wxString& name ) wxOVERRIDE;
virtual bool SetPath( const wxString& path ) wxOVERRIDE;
virtual wxString GetFilename() const wxOVERRIDE;
virtual wxString GetDirectory() const wxOVERRIDE;
virtual wxString GetWildcard() const wxOVERRIDE { return this->m_wildCard; }
virtual wxString GetPath() const wxOVERRIDE;
virtual void GetPaths( wxArrayString& paths ) const wxOVERRIDE;
virtual void GetFilenames( wxArrayString& files ) const wxOVERRIDE;
virtual int GetFilterIndex() const wxOVERRIDE { return m_fc.GetFilterIndex(); }
virtual bool HasMultipleFileSelection() const wxOVERRIDE { return HasFlag( wxFC_MULTIPLE ); }
virtual void ShowHidden(bool show) wxOVERRIDE;
virtual bool HasFilterChoice() const
{ return m_fc.HasFilterChoice(); }
// Implementation only from now on.
bool GTKShouldIgnoreNextFilterEvent() const
{ return m_fc.ShouldIgnoreNextFilterEvent(); }
bool m_checkNextSelEvent;
bool m_ignoreNextFolderChangeEvent;
protected:
GtkFileChooser *m_fcWidget;
wxGtkFileChooser m_fc;
wxString m_wildCard;
private:
void Init();
wxDECLARE_DYNAMIC_CLASS(wxGtkFileCtrl);
};
#endif // wxUSE_FILECTRL
#endif // _WX_GTK_FILECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/nonownedwnd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/nonownedwnd.h
// Purpose: wxGTK-specific wxNonOwnedWindow declaration.
// Author: Vadim Zeitlin
// Created: 2011-10-12
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_NONOWNEDWND_H_
#define _WX_GTK_NONOWNEDWND_H_
class wxNonOwnedWindowShapeImpl;
// ----------------------------------------------------------------------------
// wxNonOwnedWindow contains code common to wx{Popup,TopLevel}Window in wxGTK.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNonOwnedWindow : public wxNonOwnedWindowBase
{
public:
wxNonOwnedWindow() { m_shapeImpl = NULL; }
virtual ~wxNonOwnedWindow();
// Overridden to actually set the shape when the window becomes realized.
virtual void GTKHandleRealized() wxOVERRIDE;
protected:
virtual bool DoClearShape() wxOVERRIDE;
virtual bool DoSetRegionShape(const wxRegion& region) wxOVERRIDE;
#if wxUSE_GRAPHICS_CONTEXT
virtual bool DoSetPathShape(const wxGraphicsPath& path) wxOVERRIDE;
#endif // wxUSE_GRAPHICS_CONTEXT
private:
// If non-NULL, contains information about custom window shape.
wxNonOwnedWindowShapeImpl* m_shapeImpl;
wxDECLARE_NO_COPY_CLASS(wxNonOwnedWindow);
};
#endif // _WX_GTK_NONOWNEDWND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/activityindicator.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/activityindicator.h
// Purpose: Declaration of wxActivityIndicator for wxGTK.
// Author: Vadim Zeitlin
// Created: 2015-03-05
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_ACTIVITYINDICATOR_H_
#define _WX_GTK_ACTIVITYINDICATOR_H_
// With GTK+ 3 we can always be certain that this control is available, so use
// the normal base class. With GTK+ 2 however, we may determine during run-time
// that we need to fall back to the generic implementation because the GTK+
// version is earlier than 2.20, so we need to inherit from the generic class.
#ifdef __WXGTK3__
#define wxActivityIndicatorGtkBase wxActivityIndicatorBase
#else
#include "wx/generic/activityindicator.h"
#define wxActivityIndicatorGtkBase wxActivityIndicatorGeneric
#endif
// ----------------------------------------------------------------------------
// wxActivityIndicator: implementation using GtkSpinner.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxActivityIndicator : public wxActivityIndicatorGtkBase
{
public:
wxActivityIndicator()
{
}
explicit
wxActivityIndicator(wxWindow* parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxActivityIndicatorNameStr)
{
Create(parent, winid, pos, size, style, name);
}
bool Create(wxWindow* parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxActivityIndicatorNameStr);
virtual void Start() wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual bool IsRunning() const wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxActivityIndicator);
wxDECLARE_NO_COPY_CLASS(wxActivityIndicator);
};
#endif // _WX_GTK_ACTIVITYINDICATOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/app.h
// Purpose: wxApp definition for wxGTK
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_APP_H_
#define _WX_GTK_APP_H_
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// wxApp
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxApp: public wxAppBase
{
public:
wxApp();
virtual ~wxApp();
/* override for altering the way wxGTK initializes the GUI
* (palette/visual/colorcube). under wxMSW, OnInitGui() does nothing by
* default. when overriding this method, the code in it is likely to be
* platform dependent, otherwise use OnInit(). */
virtual bool SetNativeTheme(const wxString& theme) wxOVERRIDE;
virtual bool OnInitGui() wxOVERRIDE;
// override base class (pure) virtuals
virtual void WakeUpIdle() wxOVERRIDE;
virtual bool Initialize(int& argc, wxChar **argv) wxOVERRIDE;
virtual void CleanUp() wxOVERRIDE;
virtual void OnAssertFailure(const wxChar *file,
int line,
const wxChar *func,
const wxChar *cond,
const wxChar *msg) wxOVERRIDE;
// GTK-specific methods
// -------------------
// this can be overridden to return a specific visual to be used for GTK+
// instead of the default one (it's used by wxGLApp)
//
// must return XVisualInfo pointer (it is not freed by caller)
virtual void *GetXVisualInfo() { return NULL; }
// Check if we're using a global menu. Currently this is only true when
// running under Ubuntu Unity and global menu is not disabled.
//
// This is mostly used in the implementation in order to work around
// various bugs arising due to this.
static bool GTKIsUsingGlobalMenu();
// implementation only from now on
// -------------------------------
// check for pending events, without interference from our idle source
bool EventsPending();
bool DoIdle();
private:
// true if we're inside an assert modal dialog
bool m_isInAssert;
#if wxUSE_THREADS
wxMutex m_idleMutex;
#endif
unsigned m_idleSourceId;
wxDECLARE_DYNAMIC_CLASS(wxApp);
};
#endif // _WX_GTK_APP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/animate.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/animate.h
// Purpose: Animation classes
// Author: Julian Smart and Guillermo Rodriguez Garcia
// Modified by: Francesco Montorsi
// Created: 13/8/99
// Copyright: (c) Julian Smart and Guillermo Rodriguez Garcia
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKANIMATEH__
#define _WX_GTKANIMATEH__
typedef struct _GdkPixbufAnimation GdkPixbufAnimation;
typedef struct _GdkPixbufAnimationIter GdkPixbufAnimationIter;
// ----------------------------------------------------------------------------
// wxAnimation
// Unlike the generic wxAnimation object (see generic\animate.cpp), we won't
// use directly wxAnimationHandlers as gdk-pixbuf already provides the
// concept of handler and will automatically use the available handlers.
// Like generic wxAnimation object, this implementation of wxAnimation is
// refcounted so that assignment is very fast
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxAnimation : public wxAnimationBase
{
public:
wxAnimation(const wxString &name, wxAnimationType type = wxANIMATION_TYPE_ANY)
: m_pixbuf(NULL) { LoadFile(name, type); }
wxAnimation(GdkPixbufAnimation *p = NULL);
wxAnimation(const wxAnimation&);
~wxAnimation() { UnRef(); }
wxAnimation& operator= (const wxAnimation&);
virtual bool IsOk() const wxOVERRIDE
{ return m_pixbuf != NULL; }
// unfortunately GdkPixbufAnimation does not expose these info:
virtual unsigned int GetFrameCount() const wxOVERRIDE { return 0; }
virtual wxImage GetFrame(unsigned int frame) const wxOVERRIDE;
// we can retrieve the delay for a frame only after building
// a GdkPixbufAnimationIter...
virtual int GetDelay(unsigned int WXUNUSED(frame)) const wxOVERRIDE { return 0; }
virtual wxSize GetSize() const wxOVERRIDE;
virtual bool LoadFile(const wxString &name, wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
virtual bool Load(wxInputStream &stream, wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
// Implementation
public: // used by GTK callbacks
GdkPixbufAnimation *GetPixbuf() const
{ return m_pixbuf; }
void SetPixbuf(GdkPixbufAnimation* p);
protected:
GdkPixbufAnimation *m_pixbuf;
private:
void UnRef();
typedef wxAnimationBase base_type;
wxDECLARE_DYNAMIC_CLASS(wxAnimation);
};
// ----------------------------------------------------------------------------
// wxAnimationCtrl
// ----------------------------------------------------------------------------
// Resize to animation size if this is set
#define wxAN_FIT_ANIMATION 0x0010
class WXDLLIMPEXP_ADV wxAnimationCtrl: public wxAnimationCtrlBase
{
public:
wxAnimationCtrl() { Init(); }
wxAnimationCtrl(wxWindow *parent,
wxWindowID id,
const wxAnimation& anim = wxNullAnimation,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxAC_DEFAULT_STYLE,
const wxString& name = wxAnimationCtrlNameStr)
{
Init();
Create(parent, id, anim, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxAnimation& anim = wxNullAnimation,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxAC_DEFAULT_STYLE,
const wxString& name = wxAnimationCtrlNameStr);
~wxAnimationCtrl();
public: // event handler
void OnTimer(wxTimerEvent &);
public: // public API
virtual bool LoadFile(const wxString& filename, wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
virtual bool Load(wxInputStream& stream, wxAnimationType type = wxANIMATION_TYPE_ANY) wxOVERRIDE;
virtual void SetAnimation(const wxAnimation &anim) wxOVERRIDE;
virtual wxAnimation GetAnimation() const wxOVERRIDE
{ return wxAnimation(m_anim); }
virtual bool Play() wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual bool IsPlaying() const wxOVERRIDE;
bool SetBackgroundColour( const wxColour &colour ) wxOVERRIDE;
protected:
virtual void DisplayStaticImage() wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
void FitToAnimation();
void ClearToBackgroundColour();
void ResetAnim();
void ResetIter();
protected: // internal vars
GdkPixbufAnimation *m_anim;
GdkPixbufAnimationIter *m_iter;
wxTimer m_timer;
bool m_bPlaying;
private:
typedef wxAnimationCtrlBase base_type;
void Init();
wxDECLARE_DYNAMIC_CLASS(wxAnimationCtrl);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_GTKANIMATEH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/dcmemory.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/dcmemory.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_DCMEMORY_H_
#define _WX_GTK_DCMEMORY_H_
#include "wx/dcmemory.h"
#include "wx/gtk/dcclient.h"
//-----------------------------------------------------------------------------
// wxMemoryDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMemoryDCImpl : public wxWindowDCImpl
{
public:
wxMemoryDCImpl( wxMemoryDC *owner );
wxMemoryDCImpl( wxMemoryDC *owner, wxBitmap& bitmap );
wxMemoryDCImpl( wxMemoryDC *owner, wxDC *dc );
virtual ~wxMemoryDCImpl();
// these get reimplemented for mono-bitmaps to behave
// more like their Win32 couterparts. They now interpret
// wxWHITE, wxWHITE_BRUSH and wxWHITE_PEN as drawing 0
// and everything else as drawing 1.
virtual void SetPen( const wxPen &pen ) wxOVERRIDE;
virtual void SetBrush( const wxBrush &brush ) wxOVERRIDE;
virtual void SetBackground( const wxBrush &brush ) wxOVERRIDE;
virtual void SetTextForeground( const wxColour &col ) wxOVERRIDE;
virtual void SetTextBackground( const wxColour &col ) wxOVERRIDE;
// overridden from wxDCImpl
virtual void DoGetSize( int *width, int *height ) const wxOVERRIDE;
virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const wxOVERRIDE;
virtual void* GetHandle() const wxOVERRIDE;
// overridden for wxMemoryDC Impl
virtual void DoSelect(const wxBitmap& bitmap) wxOVERRIDE;
virtual const wxBitmap& GetSelectedBitmap() const wxOVERRIDE;
virtual wxBitmap& GetSelectedBitmap() wxOVERRIDE;
private:
wxBitmap m_selected;
void Init();
wxDECLARE_ABSTRACT_CLASS(wxMemoryDCImpl);
};
#endif
// _WX_GTK_DCMEMORY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/anybutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/anybutton.h
// Purpose: wxGTK wxAnyButton class declaration
// Author: Robert Roebling
// Created: 1998-05-20 (extracted from button.h)
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_ANYBUTTON_H_
#define _WX_GTK_ANYBUTTON_H_
//-----------------------------------------------------------------------------
// wxAnyButton
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAnyButton : public wxAnyButtonBase
{
public:
wxAnyButton()
{
m_isCurrent =
m_isPressed = false;
}
virtual bool Enable( bool enable = true ) wxOVERRIDE;
// implementation
// --------------
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// called from GTK callbacks: they update the button state and call
// GTKUpdateBitmap()
void GTKMouseEnters();
void GTKMouseLeaves();
void GTKPressed();
void GTKReleased();
protected:
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
virtual wxBitmap DoGetBitmap(State which) const wxOVERRIDE;
virtual void DoSetBitmap(const wxBitmap& bitmap, State which) wxOVERRIDE;
virtual void DoSetBitmapPosition(wxDirection dir) wxOVERRIDE;
private:
typedef wxAnyButtonBase base_type;
// focus event handler: calls GTKUpdateBitmap()
void GTKOnFocus(wxFocusEvent& event);
// update the bitmap to correspond to the current button state
void GTKUpdateBitmap();
// return the state whose bitmap is being currently shown (so this is
// different from the real current state, e.g. it could be State_Normal
// even if the button is pressed if no button was set for State_Pressed)
State GTKGetCurrentBitmapState() const;
// show the given bitmap (must be valid)
void GTKDoShowBitmap(const wxBitmap& bitmap);
// the bitmaps for the different state of the buttons, all of them may be
// invalid and the button only shows a bitmap at all if State_Normal bitmap
// is valid
wxBitmap m_bitmaps[State_Max];
// true iff mouse is currently over the button
bool m_isCurrent;
// true iff the button is in pressed state
bool m_isPressed;
wxDECLARE_NO_COPY_CLASS(wxAnyButton);
};
#endif // _WX_GTK_ANYBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/toplevel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/toplevel.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_TOPLEVEL_H_
#define _WX_GTK_TOPLEVEL_H_
class WXDLLIMPEXP_FWD_CORE wxGUIEventLoop;
//-----------------------------------------------------------------------------
// wxTopLevelWindowGTK
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindowGTK : public wxTopLevelWindowBase
{
typedef wxTopLevelWindowBase base_type;
public:
// construction
wxTopLevelWindowGTK() { Init(); }
wxTopLevelWindowGTK(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 ~wxTopLevelWindowGTK();
// implement base class pure virtuals
virtual void Maximize(bool maximize = true) wxOVERRIDE;
virtual bool IsMaximized() const wxOVERRIDE;
virtual void Iconize(bool iconize = true) wxOVERRIDE;
virtual bool IsIconized() const wxOVERRIDE;
virtual void SetIcons(const wxIconBundle& icons) wxOVERRIDE;
virtual void Restore() wxOVERRIDE;
virtual bool EnableCloseButton(bool enable = true) wxOVERRIDE;
virtual void ShowWithoutActivating() wxOVERRIDE;
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) wxOVERRIDE;
virtual bool IsFullScreen() const wxOVERRIDE { return m_fsIsShowing; }
virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO) wxOVERRIDE;
virtual void SetWindowStyleFlag( long style ) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual void Raise() wxOVERRIDE;
virtual bool IsActive() wxOVERRIDE;
virtual void SetTitle( const wxString &title ) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE { return m_title; }
virtual void SetLabel(const wxString& label) wxOVERRIDE { SetTitle( label ); }
virtual wxString GetLabel() const wxOVERRIDE { return GetTitle(); }
virtual bool SetTransparent(wxByte alpha) wxOVERRIDE;
virtual bool CanSetTransparent() wxOVERRIDE;
// Experimental, to allow help windows to be
// viewable from within modal dialogs
virtual void AddGrab();
virtual void RemoveGrab();
virtual bool IsGrabbed() const;
virtual void Refresh( bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL ) wxOVERRIDE;
// implementation from now on
// --------------------------
// GTK callbacks
virtual void GTKHandleRealized() wxOVERRIDE;
void GTKConfigureEvent(int x, int y);
// do *not* call this to iconize the frame, this is a private function!
void SetIconizeState(bool iconic);
GtkWidget *m_mainWidget;
bool m_fsIsShowing; /* full screen */
int m_fsSaveGdkFunc, m_fsSaveGdkDecor;
wxRect m_fsSaveFrame;
// m_windowStyle translated to GDK's terms
int m_gdkFunc,
m_gdkDecor;
// size of WM decorations
struct DecorSize
{
int left, right, top, bottom;
};
DecorSize m_decorSize;
// private gtk_timeout_add result for mimicing wxUSER_ATTENTION_INFO and
// wxUSER_ATTENTION_ERROR difference, -2 for no hint, -1 for ERROR hint, rest for GtkTimeout handle.
int m_urgency_hint;
// timer for detecting WM with broken _NET_REQUEST_FRAME_EXTENTS handling
unsigned m_netFrameExtentsTimerId;
// return the size of the window without WM decorations
void GTKDoGetSize(int *width, int *height) const;
void GTKUpdateDecorSize(const DecorSize& decorSize);
protected:
// give hints to the Window Manager for how the size
// of the TLW can be changed by dragging
virtual void DoSetSizeHints( int minW, int minH,
int maxW, int maxH,
int incW, int incH) wxOVERRIDE;
// move the window to the specified location and resize it
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
// take into account WM decorations here
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
// string shown in the title bar
wxString m_title;
bool m_deferShow;
private:
void Init();
DecorSize& GetCachedDecorSize();
// size hint increments
int m_incWidth, m_incHeight;
// is the frame currently iconized?
bool m_isIconized;
// is the frame currently grabbed explicitly by the application?
wxGUIEventLoop* m_grabbedEventLoop;
bool m_updateDecorSize;
bool m_deferShowAllowed;
};
#endif // _WX_GTK_TOPLEVEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/tooltip.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/tooltip.h
// Purpose: wxToolTip class
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKTOOLTIP_H_
#define _WX_GTKTOOLTIP_H_
#include "wx/string.h"
#include "wx/object.h"
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxWindow;
//-----------------------------------------------------------------------------
// wxToolTip
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxToolTip : public wxObject
{
public:
wxToolTip( const wxString &tip );
// globally change the tooltip parameters
static void Enable( bool flag );
static void SetDelay( long msecs );
// set the delay after which the tooltip disappears or how long the tooltip remains visible
static void SetAutoPop(long msecs);
// set the delay between subsequent tooltips to appear
static void SetReshow(long msecs);
// get/set the tooltip text
void SetTip( const wxString &tip );
wxString GetTip() const { return m_text; }
wxWindow *GetWindow() const { return m_window; }
// Implementation
void GTKSetWindow(wxWindow* win);
static void GTKApply(GtkWidget* widget, const char* tip);
private:
wxString m_text;
wxWindow *m_window;
wxDECLARE_ABSTRACT_CLASS(wxToolTip);
};
#endif // _WX_GTKTOOLTIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/stattext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/stattext.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_STATTEXT_H_
#define _WX_GTK_STATTEXT_H_
//-----------------------------------------------------------------------------
// wxStaticText
//-----------------------------------------------------------------------------
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 );
bool Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticTextNameStr );
void SetLabel( const wxString &label ) wxOVERRIDE;
bool SetFont( const wxFont &font ) wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation
// --------------
protected:
virtual bool GTKWidgetNeedsMnemonic() const wxOVERRIDE;
virtual void GTKWidgetDoSetMnemonic(GtkWidget* w) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxString DoGetLabel() const wxOVERRIDE;
virtual void DoSetLabel(const wxString& str) wxOVERRIDE;
#if wxUSE_MARKUP
virtual bool DoSetLabelMarkup(const wxString& markup) wxOVERRIDE;
#endif // wxUSE_MARKUP
private:
// Common part of SetLabel() and DoSetLabelMarkup().
typedef void (wxStaticText::*GTKLabelSetter)(GtkLabel *, const wxString&);
void GTKDoSetLabel(GTKLabelSetter setter, const wxString& label);
wxDECLARE_DYNAMIC_CLASS(wxStaticText);
};
#endif
// _WX_GTK_STATTEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/webviewhistoryitem_webkit.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/gtk/webviewhistoryitem.h
// Purpose: wxWebViewHistoryItem header for GTK
// Author: Steven Lamerton
// Copyright: (c) 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_WEBVIEWHISTORYITEM_H_
#define _WX_GTK_WEBVIEWHISTORYITEM_H_
#include "wx/setup.h"
#if wxUSE_WEBVIEW && (wxUSE_WEBVIEW_WEBKIT || wxUSE_WEBVIEW_WEBKIT2) && defined(__WXGTK__)
class WXDLLIMPEXP_WEBVIEW wxWebViewHistoryItem
{
public:
wxWebViewHistoryItem(const wxString& url, const wxString& title) :
m_url(url), m_title(title) {}
wxString GetUrl() { return m_url; }
wxString GetTitle() { return m_title; }
friend class wxWebViewWebKit;
private:
wxString m_url, m_title;
void* m_histItem;
};
#endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_WEBKIT && defined(__WXGTK__)
#endif // _WX_GTK_WEBVIEWHISTORYITEM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/radiobut.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/radiobut.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_RADIOBUT_H_
#define _WX_GTK_RADIOBUT_H_
//-----------------------------------------------------------------------------
// wxRadioButton
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioButton: public wxControl
{
public:
wxRadioButton() { }
wxRadioButton( wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr )
{
Create( parent, id, label, pos, size, style, validator, name );
}
bool Create( wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr );
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual void SetValue(bool val);
virtual bool GetValue() const;
virtual bool Enable( bool enable = true ) wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual void DoApplyWidgetStyle(GtkRcStyle *style) wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
private:
typedef wxControl base_type;
wxDECLARE_DYNAMIC_CLASS(wxRadioButton);
};
#endif // _WX_GTK_RADIOBUT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/radiobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/radiobox.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_RADIOBOX_H_
#define _WX_GTK_RADIOBOX_H_
#include "wx/bitmap.h"
class WXDLLIMPEXP_FWD_CORE wxGTKRadioButtonInfo;
#include "wx/list.h"
WX_DECLARE_EXPORTED_LIST(wxGTKRadioButtonInfo, wxRadioBoxButtonsInfoList);
//-----------------------------------------------------------------------------
// wxRadioBox
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioBox : public wxControl,
public wxRadioBoxBase
{
public:
// ctors and dtor
wxRadioBox() { }
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0,
const wxString choices[] = (const wxString *) NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Create( parent, id, title, pos, size, n, choices, majorDim, style, val, name );
}
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Create( parent, id, title, pos, size, choices, majorDim, style, val, name );
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0,
const wxString choices[] = (const wxString *) NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
virtual ~wxRadioBox();
// implement wxItemContainerImmutable methods
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 void SetSelection(int n) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
// implement wxRadioBoxBase methods
virtual bool Show(unsigned int n, bool show = true) wxOVERRIDE;
virtual bool Enable(unsigned int n, bool enable = true) wxOVERRIDE;
virtual bool IsItemEnabled(unsigned int n) const wxOVERRIDE;
virtual bool IsItemShown(unsigned int n) const wxOVERRIDE;
// override some base class methods to operate on radiobox itself too
virtual bool Show( bool show = true ) wxOVERRIDE;
virtual bool Enable( bool enable = true ) wxOVERRIDE;
virtual void SetLabel( const wxString& label ) wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
virtual int GetItemFromPoint( const wxPoint& pt ) const wxOVERRIDE;
#if wxUSE_HELP
// override virtual wxWindow::GetHelpTextAtPoint to use common platform independent
// wxRadioBoxBase::DoGetHelpTextAtPoint from the platform independent
// base class-interface wxRadioBoxBase.
virtual wxString GetHelpTextAtPoint(const wxPoint & pt, wxHelpEvent::Origin origin) const wxOVERRIDE
{
return wxRadioBoxBase::DoGetHelpTextAtPoint( this, pt, origin );
}
#endif // wxUSE_HELP
// implementation
// --------------
void GtkDisableEvents();
void GtkEnableEvents();
#if wxUSE_TOOLTIPS
virtual void GTKApplyToolTip(const char* tip) wxOVERRIDE;
#endif // wxUSE_TOOLTIPS
wxRadioBoxButtonsInfoList m_buttonsInfo;
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
#if wxUSE_TOOLTIPS
virtual void DoSetItemToolTip(unsigned int n, wxToolTip *tooltip) wxOVERRIDE;
#endif
virtual void DoApplyWidgetStyle(GtkRcStyle *style) wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
virtual bool GTKNeedsToFilterSameWindowFocus() const wxOVERRIDE { return true; }
virtual bool GTKWidgetNeedsMnemonic() const wxOVERRIDE;
virtual void GTKWidgetDoSetMnemonic(GtkWidget* w) wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
};
#endif // _WX_GTK_RADIOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/hyperlink.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/hyperlink.h
// Purpose: Hyperlink control
// Author: Francesco Montorsi
// Modified by:
// Created: 14/2/2007
// Copyright: (c) 2007 Francesco Montorsi
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKHYPERLINKCTRL_H_
#define _WX_GTKHYPERLINKCTRL_H_
#include "wx/generic/hyperlink.h"
// ----------------------------------------------------------------------------
// wxHyperlinkCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxHyperlinkCtrl : public wxGenericHyperlinkCtrl
{
typedef wxGenericHyperlinkCtrl base_type;
public:
wxHyperlinkCtrl();
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);
virtual ~wxHyperlinkCtrl();
// 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);
// get/set
virtual wxColour GetHoverColour() const wxOVERRIDE;
virtual void SetHoverColour(const wxColour &colour) wxOVERRIDE;
virtual wxColour GetNormalColour() const wxOVERRIDE;
virtual void SetNormalColour(const wxColour &colour) wxOVERRIDE;
virtual wxColour GetVisitedColour() const wxOVERRIDE;
virtual void SetVisitedColour(const wxColour &colour) wxOVERRIDE;
virtual wxString GetURL() const wxOVERRIDE;
virtual void SetURL(const wxString &url) wxOVERRIDE;
virtual void SetVisited(bool visited = true) wxOVERRIDE;
virtual bool GetVisited() const wxOVERRIDE;
virtual void SetLabel(const wxString &label) wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxHyperlinkCtrl);
};
#endif // _WX_GTKHYPERLINKCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/checklst.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/checklst.h
// Purpose: wxCheckListBox class
// Author: Robert Roebling
// Modified by:
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKCHECKLIST_H_
#define _WX_GTKCHECKLIST_H_
//-----------------------------------------------------------------------------
// wxCheckListBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
public:
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);
virtual bool IsChecked(unsigned int index) const wxOVERRIDE;
virtual void Check(unsigned int index, bool check = true) wxOVERRIDE;
int GetItemHeight() const;
void DoCreateCheckList();
private:
wxDECLARE_DYNAMIC_CLASS(wxCheckListBox);
};
#endif // _WX_GTKCHECKLIST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/listbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/listbox.h
// Purpose: wxListBox class declaration
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_LISTBOX_H_
#define _WX_GTK_LISTBOX_H_
struct _wxTreeEntry;
struct _GtkTreeIter;
//-----------------------------------------------------------------------------
// wxListBox
//-----------------------------------------------------------------------------
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[] = (const wxString *) 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);
}
virtual ~wxListBox();
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
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;
virtual void EnsureVisible(int n) wxOVERRIDE;
virtual int GetTopItem() const wxOVERRIDE;
virtual int GetCountPerPage() const wxOVERRIDE;
virtual void Update() wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation from now on
virtual GtkWidget *GetConnectWidget() wxOVERRIDE;
struct _GtkTreeView *m_treeview;
struct _GtkListStore *m_liststore;
#if wxUSE_CHECKLISTBOX
bool m_hasCheckBoxes;
#endif // wxUSE_CHECKLISTBOX
struct _wxTreeEntry* GTKGetEntry(unsigned pos) const;
void GTKDisableEvents();
void GTKEnableEvents();
void GTKOnSelectionChanged();
void GTKOnActivated(int item);
protected:
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual void DoApplyWidgetStyle(GtkRcStyle *style) wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
virtual void DoSetSelection(int n, bool select) wxOVERRIDE;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual int DoInsertOneItem(const wxString& item, unsigned int pos) wxOVERRIDE;
virtual void DoSetFirstItem(int n) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
virtual int DoListHitTest(const wxPoint& point) const wxOVERRIDE;
// get the iterator for the given index, returns false if invalid
bool GTKGetIteratorFor(unsigned pos, _GtkTreeIter *iter) const;
// get the index for the given iterator, return wxNOT_FOUND on failure
int GTKGetIndexFor(_GtkTreeIter& iter) const;
// common part of DoSetFirstItem() and EnsureVisible()
void DoScrollToCell(int n, float alignY, float alignX);
private:
void Init(); //common construction
wxDECLARE_DYNAMIC_CLASS(wxListBox);
};
#endif // _WX_GTK_LISTBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/textentry.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/textentry.h
// Purpose: wxGTK-specific wxTextEntry implementation
// Author: Vadim Zeitlin
// Created: 2007-09-24
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_TEXTENTRY_H_
#define _WX_GTK_TEXTENTRY_H_
typedef struct _GdkEventKey GdkEventKey;
typedef struct _GtkEditable GtkEditable;
typedef struct _GtkEntry GtkEntry;
class wxTextAutoCompleteData; // private class used only by wxTextEntry itself
// ----------------------------------------------------------------------------
// wxTextEntry: roughly corresponds to GtkEditable
// ----------------------------------------------------------------------------
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;
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;
#ifdef __WXGTK3__
virtual bool SetHint(const wxString& hint) wxOVERRIDE;
virtual wxString GetHint() const wxOVERRIDE;
#endif
// implementation only from now on
void SendMaxLenEvent();
bool GTKEntryOnInsertText(const char* text);
bool GTKIsUpperCase() const { return m_isUpperCase; }
protected:
// This method must be called from the derived class Create() to connect
// the handlers for the clipboard (cut/copy/paste) events.
void GTKConnectClipboardSignals(GtkWidget* entry);
// And this one to connect "insert-text" signal.
void GTKConnectInsertTextSignal(GtkEntry* entry);
virtual void DoSetValue(const wxString& value, int flags) wxOVERRIDE;
virtual wxString DoGetValue() const wxOVERRIDE;
// margins functions
virtual bool DoSetMargins(const wxPoint& pt) wxOVERRIDE;
virtual wxPoint DoGetMargins() const wxOVERRIDE;
virtual bool DoAutoCompleteStrings(const wxArrayString& choices) wxOVERRIDE;
virtual bool DoAutoCompleteCustom(wxTextCompleter *completer) wxOVERRIDE;
// Override the base class method to use GtkEntry IM context.
virtual int GTKIMFilterKeypress(GdkEventKey* event) const;
static int GTKGetEntryTextLength(GtkEntry* entry);
private:
// implement this to return the associated GtkEntry or another widget
// implementing GtkEditable
virtual GtkEditable *GetEditable() const = 0;
// implement this to return the associated GtkEntry
virtual GtkEntry *GetEntry() const = 0;
// Various auto-completion-related stuff, only used if any of AutoComplete()
// methods are called.
wxTextAutoCompleteData *m_autoCompleteData;
// It needs to call our GetEntry() method.
friend class wxTextAutoCompleteData;
bool m_isUpperCase;
};
// We don't need the generic version.
#define wxHAS_NATIVE_TEXT_FORCEUPPER
#endif // _WX_GTK_TEXTENTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/fontdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/fontdlg.h
// Purpose: wxFontDialog
// Author: Robert Roebling
// Created:
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_FONTDLG_H_
#define _WX_GTK_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 ~wxFontDialog();
protected:
// create the GTK dialog
virtual bool DoCreate(wxWindow *parent) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS(wxFontDialog);
};
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/filedlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/filedlg.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKFILEDLG_H_
#define _WX_GTKFILEDLG_H_
#include "wx/gtk/filectrl.h" // for wxGtkFileChooser
//-------------------------------------------------------------------------
// wxFileDialog
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDialog: public wxFileDialogBase
{
public:
wxFileDialog() { }
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);
bool Create(wxWindow *parent,
const wxString& message = wxFileSelectorPromptStr,
const wxString& defaultDir = wxEmptyString,
const wxString& defaultFile = wxEmptyString,
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = wxFD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& sz = wxDefaultSize,
const wxString& name = wxFileDialogNameStr);
virtual ~wxFileDialog();
virtual wxString GetPath() const wxOVERRIDE;
virtual void GetPaths(wxArrayString& paths) const wxOVERRIDE;
virtual wxString GetFilename() const wxOVERRIDE;
virtual void GetFilenames(wxArrayString& files) const wxOVERRIDE;
virtual int GetFilterIndex() const wxOVERRIDE;
virtual void SetMessage(const wxString& message) wxOVERRIDE;
virtual void SetPath(const wxString& path) wxOVERRIDE;
virtual void SetDirectory(const wxString& dir) wxOVERRIDE;
virtual void SetFilename(const wxString& name) wxOVERRIDE;
virtual void SetWildcard(const wxString& wildCard) wxOVERRIDE;
virtual void SetFilterIndex(int filterIndex) wxOVERRIDE;
virtual int ShowModal() wxOVERRIDE;
virtual bool SupportsExtraControl() const wxOVERRIDE { return true; }
// Implementation only.
void GTKSelectionChanged(const wxString& filename);
protected:
// override this from wxTLW since the native
// form doesn't have any m_wxwindow
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
private:
void OnFakeOk( wxCommandEvent &event );
void OnSize(wxSizeEvent&);
virtual void AddChildGTK(wxWindowGTK* child) wxOVERRIDE;
wxGtkFileChooser m_fc;
wxDECLARE_DYNAMIC_CLASS(wxFileDialog);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_GTKFILEDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/spinbutt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/spinbutt.h
// Purpose: wxSpinButton class
// Author: Robert Roebling
// Modified by:
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_SPINBUTT_H_
#define _WX_GTK_SPINBUTT_H_
//-----------------------------------------------------------------------------
// wxSpinButton
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSpinButton : public wxSpinButtonBase
{
public:
wxSpinButton();
wxSpinButton(wxWindow *parent,
wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL,
const wxString& name = wxSPIN_BUTTON_NAME)
{
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL,
const wxString& name = wxSPIN_BUTTON_NAME);
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue( int value ) wxOVERRIDE;
virtual void SetRange( int minVal, int maxVal ) wxOVERRIDE;
virtual int GetMin() const wxOVERRIDE;
virtual int GetMax() const wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
virtual bool Enable( bool enable = true ) wxOVERRIDE;
// implementation
int m_pos;
protected:
void GtkDisableEvents() const;
void GtkEnableEvents() const;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
private:
typedef wxSpinButtonBase base_type;
wxDECLARE_DYNAMIC_CLASS(wxSpinButton);
};
#endif // _WX_GTK_SPINBUTT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/statbmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/statbmp.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSTATICBITMAPH__
#define __GTKSTATICBITMAPH__
#include "wx/icon.h"
//-----------------------------------------------------------------------------
// wxStaticBitmap
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
public:
wxStaticBitmap();
wxStaticBitmap( wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr );
bool Create( wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual void SetIcon(const wxIcon& icon) wxOVERRIDE { SetBitmap( icon ); }
virtual void SetBitmap( const wxBitmap& bitmap ) wxOVERRIDE;
virtual wxBitmap GetBitmap() const wxOVERRIDE { return m_bitmap; }
// for compatibility with wxMSW
wxIcon GetIcon() const wxOVERRIDE
{
// don't use wxDynamicCast, icons and bitmaps are really the same thing
// in wxGTK
return (const wxIcon &)m_bitmap;
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
private:
wxBitmap m_bitmap;
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
};
#endif // __GTKSTATICBITMAPH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/slider.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/slider.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_SLIDER_H_
#define _WX_GTK_SLIDER_H_
// ----------------------------------------------------------------------------
// wxSlider
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSlider : public wxSliderBase
{
public:
wxSlider();
wxSlider(wxWindow *parent,
wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr)
{
Create( parent, id, value, minValue, maxValue,
pos, size, style, validator, name );
}
~wxSlider();
bool Create(wxWindow *parent,
wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
// implement the base class pure virtuals
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int value) wxOVERRIDE;
virtual void SetRange(int minValue, int maxValue) wxOVERRIDE;
virtual int GetMin() const wxOVERRIDE;
virtual int GetMax() const wxOVERRIDE;
virtual void SetLineSize(int lineSize) wxOVERRIDE;
virtual void SetPageSize(int pageSize) wxOVERRIDE;
virtual int GetLineSize() const wxOVERRIDE;
virtual int GetPageSize() const wxOVERRIDE;
virtual void SetThumbLength(int lenPixels) wxOVERRIDE;
virtual int GetThumbLength() const wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation
void GTKDisableEvents();
void GTKEnableEvents();
bool GTKEventsDisabled() const;
double m_pos;
int m_scrollEventType;
bool m_needThumbRelease;
GtkWidget *m_scale;
protected:
GtkWidget *m_minLabel,*m_maxLabel;
bool m_blockScrollEvent;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
// set the slider value unconditionally
void GTKSetValue(int value);
wxDECLARE_DYNAMIC_CLASS(wxSlider);
};
#endif // _WX_GTK_SLIDER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/menuitem.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/menuitem.h
// Purpose: wxMenuItem class
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKMENUITEM_H_
#define _WX_GTKMENUITEM_H_
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// wxMenuItem
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuItem : public wxMenuItemBase
{
public:
wxMenuItem(wxMenu *parentMenu = NULL,
int id = wxID_SEPARATOR,
const wxString& text = wxEmptyString,
const wxString& help = wxEmptyString,
wxItemKind kind = wxITEM_NORMAL,
wxMenu *subMenu = NULL);
virtual ~wxMenuItem();
// implement base class virtuals
virtual void SetItemLabel( const wxString& str ) wxOVERRIDE;
virtual void Enable( bool enable = true ) wxOVERRIDE;
virtual void Check( bool check = true ) wxOVERRIDE;
virtual bool IsChecked() const wxOVERRIDE;
virtual void SetBitmap(const wxBitmap& bitmap);
virtual const wxBitmap& GetBitmap() const { return m_bitmap; }
// implementation
void SetMenuItem(GtkWidget *menuItem);
GtkWidget *GetMenuItem() const { return m_menuItem; }
void SetGtkLabel();
#if WXWIN_COMPATIBILITY_2_8
// compatibility only, don't use in new code
wxDEPRECATED_CONSTRUCTOR(
wxMenuItem(wxMenu *parentMenu,
int id,
const wxString& text,
const wxString& help,
bool isCheckable,
wxMenu *subMenu = NULL)
);
#endif
private:
wxBitmap m_bitmap; // Bitmap for menuitem, if any
GtkWidget *m_menuItem; // GtkMenuItem
wxDECLARE_DYNAMIC_CLASS(wxMenuItem);
};
#endif // _WX_GTKMENUITEM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/calctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/calctrl.h
// Purpose: wxGtkCalendarCtrl control
// Author: Marcin Wojdyr
// Copyright: (C) 2008 Marcin Wojdyr
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef GTK_CALCTRL_H__
#define GTK_CALCTRL_H__
class WXDLLIMPEXP_ADV wxGtkCalendarCtrl : public wxCalendarCtrlBase
{
public:
wxGtkCalendarCtrl() {}
wxGtkCalendarCtrl(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)
{
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 ~wxGtkCalendarCtrl() {}
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;
// implementation
// --------------
void GTKGenerateEvent(wxEventType type);
private:
bool IsInValidRange(const wxDateTime& dt) const;
// Range of the dates that can be selected by user, either or both may be
// invalid to indicate that no corresponding restriction is set.
wxDateTime m_validStart,
m_validEnd;
// Last known selected date, may be different from the real selection in
// the control while a handler for day-selected is running.
wxDateTime m_selectedDate;
wxDECLARE_DYNAMIC_CLASS(wxGtkCalendarCtrl);
wxDECLARE_NO_COPY_CLASS(wxGtkCalendarCtrl);
};
#endif // GTK_CALCTRL_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/toolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/toolbar.h
// Purpose: GTK toolbar
// Author: Robert Roebling
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_TOOLBAR_H_
#define _WX_GTK_TOOLBAR_H_
typedef struct _GtkTooltips GtkTooltips;
// ----------------------------------------------------------------------------
// wxToolBar
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
// construction/destruction
wxToolBar() { Init(); }
wxToolBar( wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 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();
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual void SetToolShortHelp(int id, const wxString& helpString) wxOVERRIDE;
virtual void SetWindowStyleFlag( long style ) wxOVERRIDE;
virtual void SetToolNormalBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolDisabledBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bitmap1,
const wxBitmap& bitmap2 = wxNullBitmap,
wxItemKind kind = wxITEM_NORMAL,
wxObject *clientData = NULL,
const wxString& shortHelpString = wxEmptyString,
const wxString& longHelpString = wxEmptyString) wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label) wxOVERRIDE;
// implementation from now on
// --------------------------
GtkToolbar* GTKGetToolbar() const { return m_toolbar; }
protected:
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_DEFAULT; }
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
// 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;
private:
void Init();
void GtkSetStyle();
GSList* GetRadioGroup(size_t pos);
virtual void AddChildGTK(wxWindowGTK* child) wxOVERRIDE;
GtkToolbar* m_toolbar;
GtkTooltips* m_tooltips;
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
};
#endif
// _WX_GTK_TOOLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/gauge.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/gauge.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_GAUGE_H_
#define _WX_GTK_GAUGE_H_
//-----------------------------------------------------------------------------
// wxGauge
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGauge: public wxGaugeBase
{
public:
wxGauge() { Init(); }
wxGauge( wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr )
{
Init();
Create(parent, id, range, pos, size, style, validator, name);
}
bool Create( wxWindow *parent,
wxWindowID id, int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr );
// implement base class virtual methods
void SetRange(int range) wxOVERRIDE;
int GetRange() const wxOVERRIDE;
void SetValue(int pos) wxOVERRIDE;
int GetValue() const wxOVERRIDE;
virtual void Pulse() wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE;
// implementation
// -------------
// the max and current gauge values
int m_rangeMax,
m_gaugePos;
protected:
// set the gauge value to the value of m_gaugePos
void DoSetGauge();
virtual wxSize DoGetBestSize() const wxOVERRIDE;
private:
void Init() { m_rangeMax = m_gaugePos = 0; }
wxDECLARE_DYNAMIC_CLASS(wxGauge);
};
#endif
// _WX_GTK_GAUGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/spinctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/spinctrl.h
// Purpose: wxSpinCtrl class
// Author: Robert Roebling
// Modified by:
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_SPINCTRL_H_
#define _WX_GTK_SPINCTRL_H_
//-----------------------------------------------------------------------------
// wxSpinCtrlGTKBase - Base class for GTK versions of the wxSpinCtrl[Double]
//
// This class manages a double valued GTK spinctrl through the DoGet/SetXXX
// functions that are made public as Get/SetXXX functions for int or double
// for the wxSpinCtrl and wxSpinCtrlDouble classes respectively to avoid
// function ambiguity.
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSpinCtrlGTKBase : public wxSpinCtrlBase
{
public:
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
long style,
double min, double max, double initial,
double inc,
const wxString& name);
// wxSpinCtrl(Double) methods call DoXXX functions of the same name
// accessors
// T GetValue() const
// T GetMin() const
// T GetMax() const
// T GetIncrement() const
virtual bool GetSnapToTicks() const wxOVERRIDE;
// operations
virtual void SetValue(const wxString& value) wxOVERRIDE;
// void SetValue(T val)
// void SetRange(T minVal, T maxVal)
// void SetIncrement(T inc)
void SetSnapToTicks( bool snap_to_ticks ) wxOVERRIDE;
// Select text in the textctrl
void SetSelection(long from, long to) wxOVERRIDE;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation
void OnChar( wxKeyEvent &event );
protected:
double DoGetValue() const;
double DoGetMin() const;
double DoGetMax() const;
double DoGetIncrement() const;
void DoSetValue(double val);
void DoSetValue(const wxString& strValue);
void DoSetRange(double min_val, double max_val);
void DoSetIncrement(double inc);
void GtkDisableEvents() const;
void GtkEnableEvents() const;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const wxOVERRIDE;
// Widgets that use the style->base colour for the BG colour should
// override this and return true.
virtual bool UseGTKStyleBase() const wxOVERRIDE { return true; }
friend class wxSpinCtrlEventDisabler;
wxDECLARE_EVENT_TABLE();
};
//-----------------------------------------------------------------------------
// wxSpinCtrl - An integer valued spin control
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSpinCtrl : public wxSpinCtrlGTKBase
{
public:
wxSpinCtrl() { Init(); }
wxSpinCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
int min = 0, int max = 100, int initial = 0,
const wxString& name = wxS("wxSpinCtrl"))
{
Init();
Create(parent, id, value, pos, size, style, min, max, initial, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
int min = 0, int max = 100, int initial = 0,
const wxString& name = wxS("wxSpinCtrl"))
{
return wxSpinCtrlGTKBase::Create(parent, id, value, pos, size,
style, min, max, initial, 1, name);
}
// accessors
int GetValue() const { return int(DoGetValue()); }
int GetMin() const { return int(DoGetMin()); }
int GetMax() const { return int(DoGetMax()); }
int GetIncrement() const { return int(DoGetIncrement()); }
// operations
void SetValue(const wxString& value) wxOVERRIDE { wxSpinCtrlGTKBase::SetValue(value); } // visibility problem w/ gcc
void SetValue( int value ) { DoSetValue(value); }
void SetRange( int minVal, int maxVal ) { DoSetRange(minVal, maxVal); }
void SetIncrement(int inc) { DoSetIncrement(inc); }
virtual int GetBase() const wxOVERRIDE { return m_base; }
virtual bool SetBase(int base) wxOVERRIDE;
private:
// Common part of all ctors.
void Init()
{
m_base = 10;
}
int m_base;
wxDECLARE_DYNAMIC_CLASS(wxSpinCtrl);
};
//-----------------------------------------------------------------------------
// wxSpinCtrlDouble - a double valued spin control
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSpinCtrlDouble : public wxSpinCtrlGTKBase
{
public:
wxSpinCtrlDouble() {}
wxSpinCtrlDouble(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
double min = 0, double max = 100, double initial = 0,
double inc = 1,
const wxString& name = wxS("wxSpinCtrlDouble"))
{
Create(parent, id, value, pos, size, style,
min, max, initial, inc, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
double min = 0, double max = 100, double initial = 0,
double inc = 1,
const wxString& name = wxS("wxSpinCtrlDouble"))
{
return wxSpinCtrlGTKBase::Create(parent, id, value, pos, size,
style, min, max, initial, inc, name);
}
// accessors
double GetValue() const { return DoGetValue(); }
double GetMin() const { return DoGetMin(); }
double GetMax() const { return DoGetMax(); }
double GetIncrement() const { return DoGetIncrement(); }
unsigned GetDigits() const;
// operations
void SetValue(const wxString& value) wxOVERRIDE { wxSpinCtrlGTKBase::SetValue(value); } // visibility problem w/ gcc
void SetValue(double value) { DoSetValue(value); }
void SetRange(double minVal, double maxVal) { DoSetRange(minVal, maxVal); }
void SetIncrement(double inc) { DoSetIncrement(inc); }
void SetDigits(unsigned digits);
virtual int GetBase() const wxOVERRIDE { return 10; }
virtual bool SetBase(int WXUNUSED(base)) wxOVERRIDE { return false; }
wxDECLARE_DYNAMIC_CLASS(wxSpinCtrlDouble);
};
#endif // _WX_GTK_SPINCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/region.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/region.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_REGION_H_
#define _WX_GTK_REGION_H_
#ifdef __WXGTK3__
typedef struct _cairo_region cairo_region_t;
#endif
// ----------------------------------------------------------------------------
// wxRegion
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRegion : public wxRegionBase
{
public:
wxRegion() { }
wxRegion( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
{
InitRect(x, y, w, h);
}
wxRegion( const wxPoint& topLeft, const wxPoint& bottomRight )
{
InitRect(topLeft.x, topLeft.y,
bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
}
wxRegion( const wxRect& rect )
{
InitRect(rect.x, rect.y, rect.width, rect.height);
}
wxRegion( size_t n, const wxPoint *points,
wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
#if wxUSE_IMAGE
wxRegion( const wxBitmap& bmp)
{
Union(bmp);
}
wxRegion( const wxBitmap& bmp,
const wxColour& transColour, int tolerance = 0)
{
Union(bmp, transColour, tolerance);
}
#endif // wxUSE_IMAGE
virtual ~wxRegion();
// wxRegionBase methods
virtual void Clear() wxOVERRIDE;
virtual bool IsEmpty() const wxOVERRIDE;
#ifdef __WXGTK3__
cairo_region_t* GetRegion() const;
#else
wxRegion(const GdkRegion* region);
GdkRegion *GetRegion() const;
#endif
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
// wxRegionBase pure virtuals
virtual bool DoIsEqual(const wxRegion& region) const wxOVERRIDE;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const wxOVERRIDE;
virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual wxRegionContain DoContainsRect(const wxRect& rect) const wxOVERRIDE;
virtual bool DoOffset(wxCoord x, wxCoord y) wxOVERRIDE;
virtual bool DoUnionWithRect(const wxRect& rect) wxOVERRIDE;
virtual bool DoUnionWithRegion(const wxRegion& region) wxOVERRIDE;
virtual bool DoIntersect(const wxRegion& region) wxOVERRIDE;
virtual bool DoSubtract(const wxRegion& region) wxOVERRIDE;
virtual bool DoXor(const wxRegion& region) wxOVERRIDE;
// common part of ctors for a rectangle region
void InitRect(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
private:
wxDECLARE_DYNAMIC_CLASS(wxRegion);
};
// ----------------------------------------------------------------------------
// wxRegionIterator: decomposes a region into rectangles
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRegionIterator: public wxObject
{
public:
wxRegionIterator();
wxRegionIterator(const wxRegion& region);
wxRegionIterator(const wxRegionIterator& ri) : wxObject(ri) { Init(); *this = ri; }
~wxRegionIterator();
wxRegionIterator& operator=(const wxRegionIterator& ri);
void Reset() { m_current = 0u; }
void Reset(const wxRegion& region);
bool HaveRects() const;
operator bool () const { return HaveRects(); }
wxRegionIterator& operator ++ ();
wxRegionIterator operator ++ (int);
wxCoord GetX() const;
wxCoord GetY() const;
wxCoord GetW() const;
wxCoord GetWidth() const { return GetW(); }
wxCoord GetH() const;
wxCoord GetHeight() const { return GetH(); }
wxRect GetRect() const;
private:
void Init();
void CreateRects( const wxRegion& r );
wxRegion m_region;
wxRect *m_rects;
int m_numRects;
int m_current;
wxDECLARE_DYNAMIC_CLASS(wxRegionIterator);
};
#endif
// _WX_GTK_REGION_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/evtloop.h
// Purpose: wxGTK event loop implementation
// Author: Vadim Zeitlin
// Created: 2008-12-27
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_EVTLOOP_H_
#define _WX_GTK_EVTLOOP_H_
// ----------------------------------------------------------------------------
// wxGUIEventLoop for wxGTK
// ----------------------------------------------------------------------------
typedef union _GdkEvent GdkEvent;
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxEventLoopBase
{
public:
wxGUIEventLoop();
virtual void ScheduleExit(int rc = 0) wxOVERRIDE;
virtual bool Pending() const wxOVERRIDE;
virtual bool Dispatch() wxOVERRIDE;
virtual int DispatchTimeout(unsigned long timeout) wxOVERRIDE;
virtual void WakeUp() wxOVERRIDE;
void StoreGdkEventForLaterProcessing(GdkEvent* ev)
{ m_arrGdkEvents.Add(ev); }
protected:
virtual int DoRun() wxOVERRIDE;
virtual void DoYieldFor(long eventsToProcess) wxOVERRIDE;
private:
// the exit code of this event loop
int m_exitcode;
// used to temporarily store events in DoYield()
wxArrayPtrVoid m_arrGdkEvents;
wxDECLARE_NO_COPY_CLASS(wxGUIEventLoop);
};
#endif // _WX_GTK_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk/menu.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/menu.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTKMENU_H_
#define _WX_GTKMENU_H_
//-----------------------------------------------------------------------------
// wxMenuBar
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuBar : public wxMenuBarBase
{
public:
// ctors
wxMenuBar();
wxMenuBar(long style);
wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style = 0);
~wxMenuBar();
// implement base class (pure) virtuals
virtual bool Append( wxMenu *menu, const wxString &title ) wxOVERRIDE;
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Remove(size_t pos) wxOVERRIDE;
virtual int FindMenuItem(const wxString& menuString,
const wxString& itemString) const wxOVERRIDE;
virtual wxMenuItem* FindItem( int id, wxMenu **menu = NULL ) const wxOVERRIDE;
virtual void EnableTop( size_t pos, bool flag ) wxOVERRIDE;
virtual bool IsEnabledTop(size_t pos) const wxOVERRIDE;
virtual void SetMenuLabel( size_t pos, const wxString& label ) wxOVERRIDE;
virtual wxString GetMenuLabel( size_t pos ) const wxOVERRIDE;
void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
wxLayoutDirection GetLayoutDirection() const wxOVERRIDE;
virtual void Attach(wxFrame *frame) wxOVERRIDE;
virtual void Detach() wxOVERRIDE;
private:
// common part of Append and Insert
void GtkAppend(wxMenu* menu, const wxString& title, int pos = -1);
void Init(size_t n, wxMenu *menus[], const wxString titles[], long style);
// wxMenuBar is not a top level window but it still doesn't need a parent
// window
virtual bool GTKNeedsParent() const wxOVERRIDE { return false; }
GtkWidget* m_menubar;
wxDECLARE_DYNAMIC_CLASS(wxMenuBar);
};
//-----------------------------------------------------------------------------
// wxMenu
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenu : public wxMenuBase
{
public:
// ctors & dtor
wxMenu(const wxString& title, long style = 0)
: wxMenuBase(title, style) { Init(); }
wxMenu(long style = 0) : wxMenuBase(style) { Init(); }
virtual ~wxMenu();
void Attach(wxMenuBarBase *menubar) wxOVERRIDE;
void SetLayoutDirection(wxLayoutDirection dir);
wxLayoutDirection GetLayoutDirection() const;
// Returns the title, with mnemonics translated to wx format
wxString GetTitle() const;
// Sets the title, with mnemonics translated to gtk format
virtual void SetTitle(const wxString& title) wxOVERRIDE;
// implementation GTK only
GtkWidget *m_menu; // GtkMenu
GtkWidget *m_owner;
GtkAccelGroup *m_accel;
bool m_popupShown;
protected:
virtual wxMenuItem* DoAppend(wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoInsert(size_t pos, wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoRemove(wxMenuItem *item) wxOVERRIDE;
private:
// common code for all constructors:
void Init();
// common part of Append (if pos == -1) and Insert
void GtkAppend(wxMenuItem* item, int pos = -1);
wxDECLARE_DYNAMIC_CLASS(wxMenu);
};
#endif
// _WX_GTKMENU_H_
| h |
Subsets and Splits