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/tooltip.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/tooltip.h
// Purpose: wxToolTip class - tooltip control
// Author: Vadim Zeitlin
// Modified by:
// Created: 31.01.99
// Copyright: (c) 1999 Robert Roebling, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TOOLTIP_H_
#define _WX_MSW_TOOLTIP_H_
#include "wx/object.h"
#include "wx/gdicmn.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
class wxToolTipOtherWindows;
class WXDLLIMPEXP_CORE wxToolTip : public wxObject
{
public:
// ctor & dtor
wxToolTip(const wxString &tip);
virtual ~wxToolTip();
// ctor used by wxStatusBar to associate a tooltip to a portion of
// the status bar window:
wxToolTip(wxWindow* win, unsigned int id,
const wxString &tip, const wxRect& rc);
// accessors
// tip text
void SetTip(const wxString& tip);
const wxString& GetTip() const { return m_text; }
// the window we're associated with
void SetWindow(wxWindow *win);
wxWindow *GetWindow() const { return m_window; }
// controlling tooltip behaviour: globally change tooltip parameters
// enable or disable the tooltips globally
static void Enable(bool flag);
// set the delay after which the tooltip appears
static void SetDelay(long milliseconds);
// set the delay after which the tooltip disappears or how long the
// tooltip remains visible
static void SetAutoPop(long milliseconds);
// set the delay between subsequent tooltips to appear
static void SetReshow(long milliseconds);
// set maximum width for the new tooltips: -1 disables wrapping
// entirely, 0 restores the default behaviour
static void SetMaxWidth(int width);
// implementation only from now on
// -------------------------------
// should be called in response to WM_MOUSEMOVE
static void RelayEvent(WXMSG *msg);
// add a window to the tooltip control
void AddOtherWindow(WXHWND hwnd);
// remove any tooltip from the window
static void Remove(WXHWND hwnd, unsigned int id, const wxRect& rc);
// Set the rectangle we're associated with. This rectangle is only used for
// the main window, not any sub-windows added with Add() so in general it
// makes sense to use it for tooltips associated with a single window only.
void SetRect(const wxRect& rc);
// Called when TLW shown state is changed and hides the tooltip itself if
// the window it's associated with is hidden.
static void UpdateVisibility();
private:
// This module calls our DeleteToolTipCtrl().
friend class wxToolTipModule;
// Adds a window other than our main m_window to this tooltip.
void DoAddHWND(WXHWND hWnd);
// Perform the specified operation for the given window only.
void DoSetTip(WXHWND hWnd);
void DoRemove(WXHWND hWnd);
// Call the given function for all windows we're associated with.
void DoForAllWindows(void (wxToolTip::*func)(WXHWND));
// the one and only one tooltip control we use - never access it directly
// but use GetToolTipCtrl() which will create it when needed
static WXHWND ms_hwndTT;
// create the tooltip ctrl if it doesn't exist yet and return its HWND
static WXHWND GetToolTipCtrl();
// to be used in wxModule for deleting tooltip ctrl window when exiting mainloop
static void DeleteToolTipCtrl();
// new tooltip maximum width, defaults to min(display width, 400)
static int ms_maxWidth;
// remove this tooltip from the tooltip control
void Remove();
// adjust tooltip max width based on current tooltip text
bool AdjustMaxWidth();
wxString m_text; // tooltip text
wxWindow* m_window; // main window we're associated with
wxToolTipOtherWindows *m_others; // other windows associated with it or NULL
wxRect m_rect; // the rect of the window for which this tooltip is shown
// (or a rect with width/height == 0 to show it for the entire window)
unsigned int m_id; // the id of this tooltip (ignored when m_rect width/height is 0)
wxDECLARE_ABSTRACT_CLASS(wxToolTip);
wxDECLARE_NO_COPY_CLASS(wxToolTip);
};
#endif // _WX_MSW_TOOLTIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/stattext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stattext.h
// Purpose: wxStaticText class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATTEXT_H_
#define _WX_STATTEXT_H_
class WXDLLIMPEXP_CORE wxStaticText : public wxStaticTextBase
{
public:
wxStaticText() { }
wxStaticText(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr);
// override some methods to resize the window properly
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
// implement/override some base class virtuals
virtual void DoSetSize(int x, int y, int w, int h,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual wxString DoGetLabel() const wxOVERRIDE;
virtual void DoSetLabel(const wxString& str) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticText);
};
#endif
// _WX_STATTEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/genrcdefs.h | /*
* Name: wx/msw/genrcdefs.h
* Purpose: Emit preprocessor symbols into rcdefs.h for resource compiler
* Author: Mike Wetherell
* Copyright: (c) 2005 Mike Wetherell
* Licence: wxWindows licence
*/
#define EMIT(line) line
EMIT(#ifndef _WX_RCDEFS_H)
EMIT(#define _WX_RCDEFS_H)
#ifdef _MSC_FULL_VER
#if _MSC_FULL_VER < 140040130
EMIT(#define wxUSE_RC_MANIFEST 1)
#endif
#else
EMIT(#define wxUSE_RC_MANIFEST 1)
#endif
#if defined _M_AMD64 || defined __x86_64__
EMIT(#define WX_CPU_AMD64)
#endif
#ifdef _M_ARM
EMIT(#define WX_CPU_ARM)
#endif
#ifdef _M_ARM64
EMIT(#define WX_CPU_ARM64)
#endif
#if defined _M_IA64 || defined __ia64__
EMIT(#define WX_CPU_IA64)
#endif
#if defined _M_IX86 || defined _X86_
EMIT(#define WX_CPU_X86)
#endif
#ifdef _M_PPC
EMIT(#define WX_CPU_PPC)
#endif
#ifdef _M_SH
EMIT(#define WX_CPU_SH)
#endif
EMIT(#endif)
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/imaglist.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/imaglist.h
// Purpose: wxImageList class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGLIST_H_
#define _WX_IMAGLIST_H_
#include "wx/bitmap.h"
// Eventually we'll make this a reference-counted wxGDIObject. For
// now, the app must take care of ownership issues. That is, the
// image lists must be explicitly deleted after the control(s) that uses them
// is (are) deleted, or when the app exits.
class WXDLLIMPEXP_CORE wxImageList : public wxObject
{
public:
/*
* Public interface
*/
wxImageList();
// Creates an image list.
// Specify the width and height of the images in the list,
// whether there are masks associated with them (e.g. if creating images
// from icons), and the initial size of the list.
wxImageList(int width, int height, bool mask = true, int initialCount = 1)
{
Create(width, height, mask, initialCount);
}
virtual ~wxImageList();
// Attributes
////////////////////////////////////////////////////////////////////////////
// Returns the number of images in the image list.
int GetImageCount() const;
// Returns the size (same for all images) of the images in the list
bool GetSize(int index, int &width, int &height) const;
// Returns the overall size
wxSize GetSize() const { return m_size; }
// Operations
////////////////////////////////////////////////////////////////////////////
// Creates an image list
// width, height specify the size of the images in the list (all the same).
// mask specifies whether the images have masks or not.
// initialNumber is the initial number of images to reserve.
bool Create(int width, int height, bool mask = true, int initialNumber = 1);
// Adds a bitmap, and optionally a mask bitmap.
// Note that wxImageList creates *new* bitmaps, so you may delete
// 'bitmap' and 'mask' after calling Add.
int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
// Adds a bitmap, using the specified colour to create the mask bitmap
// Note that wxImageList creates *new* bitmaps, so you may delete
// 'bitmap' after calling Add.
int Add(const wxBitmap& bitmap, const wxColour& maskColour);
// Adds a bitmap and mask from an icon.
int Add(const wxIcon& icon);
// Replaces a bitmap, optionally passing a mask bitmap.
// Note that wxImageList creates new bitmaps, so you may delete
// 'bitmap' and 'mask' after calling Replace.
bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
// Replaces a bitmap and mask from an icon.
// You can delete 'icon' after calling Replace.
bool Replace(int index, const wxIcon& icon);
// Removes the image at the given index.
bool Remove(int index);
// Remove all images
bool RemoveAll();
// Draws the given image on a dc at the specified position.
// If 'solidBackground' is true, Draw sets the image list background
// colour to the background colour of the wxDC, to speed up
// drawing by eliminating masked drawing where possible.
bool Draw(int index, wxDC& dc, int x, int y,
int flags = wxIMAGELIST_DRAW_NORMAL,
bool solidBackground = false);
// Get a bitmap
wxBitmap GetBitmap(int index) const;
// Get an icon
wxIcon GetIcon(int index) const;
// TODO: miscellaneous functionality
/*
wxIcon *MakeIcon(int index);
bool SetOverlayImage(int index, int overlayMask);
*/
// TODO: Drag-and-drop related functionality.
#if 0
// Creates a new drag image by combining the given image (typically a mouse cursor image)
// with the current drag image.
bool SetDragCursorImage(int index, const wxPoint& hotSpot);
// If successful, returns a pointer to the temporary image list that is used for dragging;
// otherwise, NULL.
// dragPos: receives the current drag position.
// hotSpot: receives the offset of the drag image relative to the drag position.
static wxImageList *GetDragImageList(wxPoint& dragPos, wxPoint& hotSpot);
// Call this function to begin dragging an image. This function creates a temporary image list
// that is used for dragging. The image combines the specified image and its mask with the
// current cursor. In response to subsequent mouse move messages, you can move the drag image
// by using the DragMove member function. To end the drag operation, you can use the EndDrag
// member function.
bool BeginDrag(int index, const wxPoint& hotSpot);
// Ends a drag operation.
bool EndDrag();
// Call this function to move the image that is being dragged during a drag-and-drop operation.
// This function is typically called in response to a mouse move message. To begin a drag
// operation, use the BeginDrag member function.
static bool DragMove(const wxPoint& point);
// During a drag operation, locks updates to the window specified by lockWindow and displays
// the drag image at the position specified by point.
// The coordinates are relative to the window's upper left corner, so you must compensate
// for the widths of window elements, such as the border, title bar, and menu bar, when
// specifying the coordinates.
// If lockWindow is NULL, this function draws the image in the display context associated
// with the desktop window, and coordinates are relative to the upper left corner of the screen.
// This function locks all other updates to the given window during the drag operation.
// If you need to do any drawing during a drag operation, such as highlighting the target
// of a drag-and-drop operation, you can temporarily hide the dragged image by using the
// wxImageList::DragLeave function.
// lockWindow: pointer to the window that owns the drag image.
// point: position at which to display the drag image. Coordinates are relative to the
// upper left corner of the window (not the client area).
static bool DragEnter( wxWindow *lockWindow, const wxPoint& point );
// Unlocks the window specified by pWndLock and hides the drag image, allowing the
// window to be updated.
static bool DragLeave( wxWindow *lockWindow );
/* Here's roughly how you'd use these functions:
1) Starting to drag:
wxImageList *dragImageList = new wxImageList(16, 16, true);
dragImageList->Add(myDragImage); // Provide an image to combine with the current cursor
dragImageList->BeginDrag(0, wxPoint(0, 0));
wxShowCursor(false); // wxShowCursor not yet implemented in wxWin
myWindow->CaptureMouse();
2) Dragging:
// Called within mouse move event. Could also use dragImageList instead of assuming
// these are static functions.
// These two functions could possibly be combined into one, since DragEnter is
// a bit obscure.
wxImageList::DragMove(wxPoint(x, y)); // x, y are current cursor position
wxImageList::DragEnter(NULL, wxPoint(x, y)); // NULL assumes dragging across whole screen
3) Finishing dragging:
dragImageList->EndDrag();
myWindow->ReleaseMouse();
wxShowCursor(true);
*/
#endif
// Implementation
////////////////////////////////////////////////////////////////////////////
// Returns the native image list handle
WXHIMAGELIST GetHIMAGELIST() const { return m_hImageList; }
protected:
WXHIMAGELIST m_hImageList;
wxSize m_size;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxImageList);
};
#endif
// _WX_IMAGLIST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/gdiimage.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/gdiimage.h
// Purpose: wxGDIImage class: base class for wxBitmap, wxIcon, wxCursor
// under MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.11.99
// Copyright: (c) 1999 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// NB: this is a private header, it is not intended to be directly included by
// user code (but may be included from other, public, wxWin headers
#ifndef _WX_MSW_GDIIMAGE_H_
#define _WX_MSW_GDIIMAGE_H_
#include "wx/gdiobj.h" // base class
#include "wx/gdicmn.h" // wxBITMAP_TYPE_INVALID
#include "wx/list.h"
class WXDLLIMPEXP_FWD_CORE wxGDIImageRefData;
class WXDLLIMPEXP_FWD_CORE wxGDIImageHandler;
class WXDLLIMPEXP_FWD_CORE wxGDIImage;
WX_DECLARE_EXPORTED_LIST(wxGDIImageHandler, wxGDIImageHandlerList);
// ----------------------------------------------------------------------------
// wxGDIImageRefData: common data fields for all derived classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImageRefData : public wxGDIRefData
{
public:
wxGDIImageRefData()
{
m_width = m_height = m_depth = 0;
m_handle = 0;
}
wxGDIImageRefData(const wxGDIImageRefData& data) : wxGDIRefData()
{
m_width = data.m_width;
m_height = data.m_height;
m_depth = data.m_depth;
// can't copy handles like this, derived class copy ctor must do it!
m_handle = NULL;
}
// accessors
virtual bool IsOk() const wxOVERRIDE { return m_handle != 0; }
void SetSize(int w, int h) { m_width = w; m_height = h; }
// free the resources we allocated
virtual void Free() = 0;
// for compatibility, the member fields are public
// the size of the image
int m_width, m_height;
// the depth of the image
int m_depth;
// the handle to it
union
{
WXHANDLE m_handle; // for untyped access
WXHBITMAP m_hBitmap;
WXHICON m_hIcon;
WXHCURSOR m_hCursor;
};
};
// ----------------------------------------------------------------------------
// wxGDIImage: this class supports GDI image handlers which may be registered
// dynamically and will be used for loading/saving the images in the specified
// format. It also falls back to wxImage if no appropriate image is found.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImage : public wxGDIObject
{
public:
// handlers list interface
static wxGDIImageHandlerList& GetHandlers() { return ms_handlers; }
static void AddHandler(wxGDIImageHandler *handler);
static void InsertHandler(wxGDIImageHandler *handler);
static bool RemoveHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& extension, long type);
static wxGDIImageHandler *FindHandler(long type);
static void InitStandardHandlers();
static void CleanUpHandlers();
// access to the ref data casted to the right type
wxGDIImageRefData *GetGDIImageData() const
{ return (wxGDIImageRefData *)m_refData; }
// accessors
WXHANDLE GetHandle() const
{ return IsNull() ? 0 : GetGDIImageData()->m_handle; }
void SetHandle(WXHANDLE handle)
{ AllocExclusive(); GetGDIImageData()->m_handle = handle; }
int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_width; }
int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_height; }
int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_depth; }
wxSize GetSize() const
{
return IsNull() ? wxSize(0,0) :
wxSize(GetGDIImageData()->m_width, GetGDIImageData()->m_height);
}
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_INLINE(void SetWidth(int w), AllocExclusive(); GetGDIImageData()->m_width = w; )
wxDEPRECATED_INLINE(void SetHeight(int h), AllocExclusive(); GetGDIImageData()->m_height = h; )
wxDEPRECATED_INLINE(void SetDepth(int d), AllocExclusive(); GetGDIImageData()->m_depth = d; )
wxDEPRECATED_INLINE(void SetSize(int w, int h), AllocExclusive(); GetGDIImageData()->SetSize(w, h); )
wxDEPRECATED_INLINE(void SetSize(const wxSize& size), AllocExclusive(); GetGDIImageData()->SetSize(size.x, size.y); )
#endif // WXWIN_COMPATIBILITY_3_0
// forward some of base class virtuals to wxGDIImageRefData
bool FreeResource(bool force = false) wxOVERRIDE;
virtual WXHANDLE GetResourceHandle() const wxOVERRIDE;
protected:
// create the data for the derived class here
virtual wxGDIImageRefData *CreateData() const = 0;
// implement the wxGDIObject method in terms of our, more specific, one
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE { return CreateData(); }
// we can't [efficiently] clone objects of this class
virtual wxGDIRefData *
CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const wxOVERRIDE
{
wxFAIL_MSG( wxT("must be implemented if used") );
return NULL;
}
static wxGDIImageHandlerList ms_handlers;
};
// ----------------------------------------------------------------------------
// wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImageHandler : public wxObject
{
public:
// ctor
wxGDIImageHandler() { m_type = wxBITMAP_TYPE_INVALID; }
wxGDIImageHandler(const wxString& name,
const wxString& ext,
wxBitmapType type)
: m_name(name), m_extension(ext), m_type(type) { }
// accessors
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetType(wxBitmapType type) { m_type = type; }
const wxString& GetName() const { return m_name; }
const wxString& GetExtension() const { return m_extension; }
wxBitmapType GetType() const { return m_type; }
// real handler operations: to implement in derived classes
virtual bool Create(wxGDIImage *image,
const void* data,
wxBitmapType flags,
int width, int height, int depth = 1) = 0;
virtual bool Load(wxGDIImage *image,
const wxString& name,
wxBitmapType flags,
int desiredWidth, int desiredHeight) = 0;
virtual bool Save(const wxGDIImage *image,
const wxString& name,
wxBitmapType type) const = 0;
protected:
wxString m_name;
wxString m_extension;
wxBitmapType m_type;
};
#endif // _WX_MSW_GDIIMAGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/radiobut.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/radiobut.h
// Purpose: wxRadioButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBUT_H_
#define _WX_RADIOBUT_H_
#include "wx/msw/ownerdrawnbutton.h"
class WXDLLIMPEXP_CORE wxRadioButton : public wxMSWOwnerDrawnButton<wxControl>
{
public:
// ctors and creation functions
wxRadioButton() { Init(); }
wxRadioButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr)
{
Init();
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr);
// implement the radio button interface
virtual void SetValue(bool value);
virtual bool GetValue() const;
// implementation only from now on
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// Implement wxMSWOwnerDrawnButtonBase methods.
virtual int MSWGetButtonStyle() const wxOVERRIDE;
virtual void MSWOnButtonResetOwnerDrawn() wxOVERRIDE;
virtual int MSWGetButtonCheckedFlag() const wxOVERRIDE;
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) wxOVERRIDE;
private:
// common part of all ctors
void Init();
// we need to store the state internally as the result of GetValue()
// sometimes gets out of sync in WM_COMMAND handler
bool m_isChecked;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxRadioButton);
};
#endif // _WX_RADIOBUT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/radiobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/radiobox.h
// Purpose: wxRadioBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBOX_H_
#define _WX_RADIOBOX_H_
#include "wx/statbox.h"
class WXDLLIMPEXP_FWD_CORE wxSubwindows;
// ----------------------------------------------------------------------------
// wxRadioBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioBox : public wxStaticBox, public wxRadioBoxBase
{
public:
wxRadioBox() { Init(); }
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, n, choices, majorDim,
style, val, name);
}
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, choices, majorDim,
style, val, name);
}
virtual ~wxRadioBox();
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
// implement the radiobox interface
virtual void SetSelection(int n) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE { return m_selectedButton; }
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& label) wxOVERRIDE;
virtual bool Enable(unsigned int n, bool enable = true) wxOVERRIDE;
virtual bool Show(unsigned int n, bool show = true) wxOVERRIDE;
virtual bool IsItemEnabled(unsigned int n) const wxOVERRIDE;
virtual bool IsItemShown(unsigned int n) const wxOVERRIDE;
virtual int GetItemFromPoint(const wxPoint& pt) const wxOVERRIDE;
// override some base class methods
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool CanBeFocused() const wxOVERRIDE;
virtual void SetFocus() wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual bool HasToolTips() const wxOVERRIDE;
#endif // wxUSE_TOOLTIPS
#if wxUSE_HELP
// override virtual function with a platform-independent implementation
virtual wxString GetHelpTextAtPoint(const wxPoint & pt, wxHelpEvent::Origin origin) const wxOVERRIDE
{
return wxRadioBoxBase::DoGetHelpTextAtPoint( this, pt, origin );
}
#endif // wxUSE_HELP
virtual bool Reparent(wxWindowBase *newParent) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
void SetLabelFont(const wxFont& WXUNUSED(font)) {}
void SetButtonFont(const wxFont& font) { SetFont(font); }
// implementation only from now on
// -------------------------------
// This function can be used to check if the given radio button HWND
// belongs to one of our radio boxes. If it doesn't, NULL is returned.
static wxRadioBox *GetFromRadioButtonHWND(WXHWND hwnd);
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
void Command(wxCommandEvent& event) wxOVERRIDE;
void SendNotificationEvent();
protected:
// common part of all ctors
void Init();
// subclass one radio button
void SubclassRadioButton(WXHWND hWndBtn);
// get the max size of radio buttons
wxSize GetMaxButtonSize() const;
// get the total size occupied by the radio box buttons
wxSize GetTotalButtonSize(const wxSize& sizeBtn) const;
// Adjust all the buttons to the new window size.
void PositionAllButtons(int x, int y, int width, int height);
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetItemToolTip(unsigned int n, wxToolTip * tooltip) wxOVERRIDE;
#endif
virtual WXHRGN MSWGetRegionWithoutChildren() wxOVERRIDE;
// resolve ambiguity in base classes
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxRadioBoxBase::GetDefaultBorder(); }
// the buttons we contain
wxSubwindows *m_radioButtons;
// and the special dummy button used only as a tab group boundary
WXHWND m_dummyHwnd;
wxWindowIDRef m_dummyId;
// currently selected button or wxNOT_FOUND if none
int m_selectedButton;
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
wxDECLARE_NO_COPY_CLASS(wxRadioBox);
};
#endif
// _WX_RADIOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/hyperlink.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/hyperlink.h
// Purpose: Hyperlink control
// Author: Rickard Westerlund
// Created: 2010-08-04
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_HYPERLINK_H_
#define _WX_MSW_HYPERLINK_H_
#include "wx/generic/hyperlink.h"
// ----------------------------------------------------------------------------
// wxHyperlinkCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxHyperlinkCtrl : public wxGenericHyperlinkCtrl
{
public:
// Default constructor (for two-step construction).
wxHyperlinkCtrl() { }
// Constructor.
wxHyperlinkCtrl(wxWindow *parent,
wxWindowID id,
const wxString& label, const wxString& url,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHL_DEFAULT_STYLE,
const wxString& name = wxHyperlinkCtrlNameStr)
{
(void)Create(parent, id, label, url, pos, size, style, name);
}
// Creation function (for two-step construction).
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label, const wxString& url,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHL_DEFAULT_STYLE,
const wxString& name = wxHyperlinkCtrlNameStr);
// overridden base class methods
// -----------------------------
virtual void SetURL(const wxString &url) wxOVERRIDE;
virtual void SetLabel(const wxString &label) wxOVERRIDE;
protected:
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
private:
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS( wxHyperlinkCtrl );
};
#endif // _WX_MSW_HYPERLINK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/stdpaths.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stdpaths.h
// Purpose: wxStandardPaths for Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-10-19
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STDPATHS_H_
#define _WX_MSW_STDPATHS_H_
struct _GUID;
// ----------------------------------------------------------------------------
// wxStandardPaths
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStandardPaths : public wxStandardPathsBase
{
public:
// implement base class pure virtuals
virtual wxString GetExecutablePath() const wxOVERRIDE;
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
virtual wxString GetDataDir() const wxOVERRIDE;
virtual wxString GetUserDataDir() const wxOVERRIDE;
virtual wxString GetUserLocalDataDir() const wxOVERRIDE;
virtual wxString GetPluginsDir() const wxOVERRIDE;
virtual wxString GetUserDir(Dir userDir) const wxOVERRIDE;
virtual wxString MakeConfigFileName(const wxString& basename,
ConfigFileConv conv = ConfigFileConv_Ext
) const wxOVERRIDE;
// MSW-specific methods
// This class supposes that data, plugins &c files are located under the
// program directory which is the directory containing the application
// binary itself. But sometimes this binary may be in a subdirectory of the
// main program directory, e.g. this happens in at least the following
// common cases:
// 1. The program is in "bin" subdirectory of the installation directory.
// 2. The program is in "debug" subdirectory of the directory containing
// sources and data files during development
//
// By calling this function you instruct the class to remove the last
// component of the path if it matches its argument. Notice that it may be
// called more than once, e.g. you can call both IgnoreAppSubDir("bin") and
// IgnoreAppSubDir("debug") to take care of both production and development
// cases above but that each call will only remove the last path component.
// Finally note that the argument can contain wild cards so you can also
// call IgnoreAppSubDir("vc*msw*") to ignore all build directories at once
// when using wxWidgets-inspired output directories names.
void IgnoreAppSubDir(const wxString& subdirPattern);
// This function is used to ignore all common build directories and is
// called from the ctor -- use DontIgnoreAppSubDir() to undo this.
void IgnoreAppBuildSubDirs();
// Undo the effects of all preceding IgnoreAppSubDir() calls.
void DontIgnoreAppSubDir();
// Returns the directory corresponding to the specified Windows shell CSIDL
static wxString MSWGetShellDir(int csidl);
protected:
// Ctor is protected, use wxStandardPaths::Get() instead of instantiating
// objects of this class directly.
//
// It calls IgnoreAppBuildSubDirs() and also sets up the object to use
// both vendor and application name by default.
wxStandardPaths();
// get the path corresponding to the given standard CSIDL_XXX constant
static wxString DoGetDirectory(int csidl);
static wxString DoGetKnownFolder(const _GUID& rfid);
// return the directory of the application itself
wxString GetAppDir() const;
// directory returned by GetAppDir()
mutable wxString m_appDir;
};
// ----------------------------------------------------------------------------
// wxStandardPathsWin16: this class is for internal use only
// ----------------------------------------------------------------------------
// override config file locations to be compatible with the values used by
// wxFileConfig (dating from Win16 days which explains the class name)
class WXDLLIMPEXP_BASE wxStandardPathsWin16 : public wxStandardPaths
{
public:
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
};
#endif // _WX_MSW_STDPATHS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/checklst.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/checklst.h
// Purpose: wxCheckListBox class - a listbox with checkable items
// Author: Vadim Zeitlin
// Modified by:
// Created: 16.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef __CHECKLST__H_
#define __CHECKLST__H_
#if !wxUSE_OWNER_DRAWN
#error "wxCheckListBox class requires owner-drawn functionality."
#endif
class WXDLLIMPEXP_FWD_CORE wxOwnerDrawn;
class WXDLLIMPEXP_FWD_CORE wxCheckListBoxItem; // fwd decl, defined in checklst.cpp
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
public:
// ctors
wxCheckListBox();
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// items may be checked
virtual bool IsChecked(unsigned int uiIndex) const wxOVERRIDE;
virtual void Check(unsigned int uiIndex, bool bCheck = true) wxOVERRIDE;
virtual void Toggle(unsigned int uiIndex);
// we create our items ourselves and they have non-standard size,
// so we need to override these functions
virtual wxOwnerDrawn *CreateLboxItem(size_t n) wxOVERRIDE;
virtual bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item) wxOVERRIDE;
protected:
// pressing space or clicking the check box toggles the item
void OnKeyDown(wxKeyEvent& event);
void OnLeftClick(wxMouseEvent& event);
// send an "item checked" event
void SendEvent(unsigned int uiIndex)
{
wxCommandEvent event(wxEVT_CHECKLISTBOX, GetId());
event.SetInt(uiIndex);
event.SetEventObject(this);
event.SetString(GetString(uiIndex));
ProcessCommand(event);
}
wxSize DoGetBestClientSize() const wxOVERRIDE;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckListBox);
};
#endif //_CHECKLST_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/htmlhelp.h | /*
* wx/msw/htmlhelp.h
* Copyright 2004 Jacek Caban
*
* Originally written for the Wine project, and issued under
* the wxWindows licence by kind permission of the author.
*
* Licence: wxWindows licence
*/
#ifndef __HTMLHELP_H__
#define __HTMLHELP_H__
#define HH_DISPLAY_TOPIC 0x00
#define HH_HELP_FINDER 0x00
#define HH_DISPLAY_TOC 0x01
#define HH_DISPLAY_INDEX 0x02
#define HH_DISPLAY_SEARCH 0x03
#define HH_SET_WIN_TYPE 0x04
#define HH_GET_WIN_TYPE 0x05
#define HH_GET_WIN_HANDLE 0x06
#define HH_ENUM_INFO_TYPE 0x07
#define HH_SET_INFO_TYPE 0x08
#define HH_SYNC 0x09
#define HH_RESERVED1 0x0A
#define HH_RESERVED2 0x0B
#define HH_RESERVED3 0x0C
#define HH_KEYWORD_LOOKUP 0x0D
#define HH_DISPLAY_TEXT_POPUP 0x0E
#define HH_HELP_CONTEXT 0x0F
#define HH_TP_HELP_CONTEXTMENU 0x10
#define HH_TP_HELP_WM_HELP 0x11
#define HH_CLOSE_ALL 0x12
#define HH_ALINK_LOOKUP 0x13
#define HH_GET_LAST_ERROR 0x14
#define HH_ENUM_CATEGORY 0x15
#define HH_ENUM_CATEGORY_IT 0x16
#define HH_RESET_IT_FILTER 0x17
#define HH_SET_INCLUSIVE_FILTER 0x18
#define HH_SET_EXCLUSIVE_FILTER 0x19
#define HH_INITIALIZE 0x1C
#define HH_UNINITIALIZE 0x1D
#define HH_PRETRANSLATEMESSAGE 0xFD
#define HH_SET_GLOBAL_PROPERTY 0xFC
#define HHWIN_PROP_TAB_AUTOHIDESHOW 0x00000001
#define HHWIN_PROP_ONTOP 0x00000002
#define HHWIN_PROP_NOTITLEBAR 0x00000004
#define HHWIN_PROP_NODEF_STYLES 0x00000008
#define HHWIN_PROP_NODEF_EXSTYLES 0x00000010
#define HHWIN_PROP_TRI_PANE 0x00000020
#define HHWIN_PROP_NOTB_TEXT 0x00000040
#define HHWIN_PROP_POST_QUIT 0x00000080
#define HHWIN_PROP_AUTO_SYNC 0x00000100
#define HHWIN_PROP_TRACKING 0x00000200
#define HHWIN_PROP_TAB_SEARCH 0x00000400
#define HHWIN_PROP_TAB_HISTORY 0x00000800
#define HHWIN_PROP_TAB_FAVORITES 0x00001000
#define HHWIN_PROP_CHANGE_TITLE 0x00002000
#define HHWIN_PROP_NAV_ONLY_WIN 0x00004000
#define HHWIN_PROP_NO_TOOLBAR 0x00008000
#define HHWIN_PROP_MENU 0x00010000
#define HHWIN_PROP_TAB_ADVSEARCH 0x00020000
#define HHWIN_PROP_USER_POS 0x00040000
#define HHWIN_PROP_TAB_CUSTOM1 0x00080000
#define HHWIN_PROP_TAB_CUSTOM2 0x00100000
#define HHWIN_PROP_TAB_CUSTOM3 0x00200000
#define HHWIN_PROP_TAB_CUSTOM4 0x00400000
#define HHWIN_PROP_TAB_CUSTOM5 0x00800000
#define HHWIN_PROP_TAB_CUSTOM6 0x01000000
#define HHWIN_PROP_TAB_CUSTOM7 0x02000000
#define HHWIN_PROP_TAB_CUSTOM8 0x04000000
#define HHWIN_PROP_TAB_CUSTOM9 0x08000000
#define HHWIN_TB_MARGIN 0x10000000
#define HHWIN_PARAM_PROPERTIES 0x00000002
#define HHWIN_PARAM_STYLES 0x00000004
#define HHWIN_PARAM_EXSTYLES 0x00000008
#define HHWIN_PARAM_RECT 0x00000010
#define HHWIN_PARAM_NAV_WIDTH 0x00000020
#define HHWIN_PARAM_SHOWSTATE 0x00000040
#define HHWIN_PARAM_INFOTYPES 0x00000080
#define HHWIN_PARAM_TB_FLAGS 0x00000100
#define HHWIN_PARAM_EXPANSION 0x00000200
#define HHWIN_PARAM_TABPOS 0x00000400
#define HHWIN_PARAM_TABORDER 0x00000800
#define HHWIN_PARAM_HISTORY_COUNT 0x00001000
#define HHWIN_PARAM_CUR_TAB 0x00002000
#define HHWIN_BUTTON_EXPAND 0x00000002
#define HHWIN_BUTTON_BACK 0x00000004
#define HHWIN_BUTTON_FORWARD 0x00000008
#define HHWIN_BUTTON_STOP 0x00000010
#define HHWIN_BUTTON_REFRESH 0x00000020
#define HHWIN_BUTTON_HOME 0x00000040
#define HHWIN_BUTTON_BROWSE_FWD 0x00000080
#define HHWIN_BUTTON_BROWSE_BCK 0x00000100
#define HHWIN_BUTTON_NOTES 0x00000200
#define HHWIN_BUTTON_CONTENTS 0x00000400
#define HHWIN_BUTTON_SYNC 0x00000800
#define HHWIN_BUTTON_OPTIONS 0x00001000
#define HHWIN_BUTTON_PRINT 0x00002000
#define HHWIN_BUTTON_INDEX 0x00004000
#define HHWIN_BUTTON_SEARCH 0x00008000
#define HHWIN_BUTTON_HISTORY 0x00010000
#define HHWIN_BUTTON_FAVORITES 0x00020000
#define HHWIN_BUTTON_JUMP1 0x00040000
#define HHWIN_BUTTON_JUMP2 0x00080000
#define HHWIN_BUTTON_ZOOM 0x00100000
#define HHWIN_BUTTON_TOC_NEXT 0x00200000
#define HHWIN_BUTTON_TOC_PREV 0x00400000
#define HHWIN_DEF_BUTTONS \
(HHWIN_BUTTON_EXPAND | HHWIN_BUTTON_BACK | HHWIN_BUTTON_OPTIONS | HHWIN_BUTTON_PRINT)
#define IDTB_EXPAND 200
#define IDTB_CONTRACT 201
#define IDTB_STOP 202
#define IDTB_REFRESH 203
#define IDTB_BACK 204
#define IDTB_HOME 205
#define IDTB_SYNC 206
#define IDTB_PRINT 207
#define IDTB_OPTIONS 208
#define IDTB_FORWARD 209
#define IDTB_NOTES 210
#define IDTB_BROWSE_FWD 211
#define IDTB_BROWSE_BACK 212
#define IDTB_CONTENTS 213
#define IDTB_INDEX 214
#define IDTB_SEARCH 215
#define IDTB_HISTORY 216
#define IDTB_FAVORITES 217
#define IDTB_JUMP1 218
#define IDTB_JUMP2 219
#define IDTB_CUSTOMIZE 221
#define IDTB_ZOOM 222
#define IDTB_TOC_NEXT 223
#define IDTB_TOC_PREV 224
#define HHN_FIRST (0U-860U)
#define HHN_LAST (0U-879U)
#define HHN_NAVCOMPLETE HHN_FIRST
#define HHN_TRACK (HHN_FIRST-1)
#define HHN_WINDOW_CREATE (HHN_FIRST-2)
#ifdef __cplusplus
extern "C" {
#endif
typedef struct tagHH_NOTIFY {
NMHDR hdr;
PCSTR pszurl;
} HH_NOTIFY;
typedef struct tagHH_POPUPA {
int cbStruct;
HINSTANCE hinst;
UINT idString;
LPCSTR pszText;
POINT pt;
COLORREF clrForeground;
COLORREF clrBackground;
RECT rcMargins;
LPCSTR pszFont;
} HH_POPUPA;
typedef struct tagHH_POPUPW {
int cbStruct;
HINSTANCE hinst;
UINT idString;
LPCWSTR pszText;
POINT pt;
COLORREF clrForeground;
COLORREF clrBackground;
RECT rcMargins;
LPCWSTR pszFont;
} HH_POPUPW;
#ifdef _UNICODE
typedef HH_POPUPW HH_POPUP;
#else
typedef HH_POPUPA HH_POPUP;
#endif
typedef struct tagHH_ALINKA {
int cbStruct;
BOOL fReserved;
LPCSTR pszKeywords;
LPCSTR pszUrl;
LPCSTR pszMsgText;
LPCSTR pszMsgTitle;
LPCSTR pszWindow;
BOOL fIndexOnFail;
} HH_ALINKA;
typedef struct tagHH_ALINKW {
int cbStruct;
BOOL fReserved;
LPCWSTR pszKeywords;
LPCWSTR pszUrl;
LPCWSTR pszMsgText;
LPCWSTR pszMsgTitle;
LPCWSTR pszWindow;
BOOL fIndexOnFail;
} HH_ALINKW;
#ifdef _UNICODE
typedef HH_ALINKW HH_ALINK;
typedef HH_ALINKW HH_AKLINK;
#else
typedef HH_ALINKA HH_ALINK;
typedef HH_ALINKA HH_AKLINK;
#endif
enum {
HHWIN_NAVTYPE_TOC,
HHWIN_NAVTYPE_INDEX,
HHWIN_NAVTYPE_SEARCH,
HHWIN_NAVTYPE_FAVORITES,
HHWIN_NAVTYPE_HISTORY,
HHWIN_NAVTYPE_AUTHOR,
HHWIN_NAVTYPE_CUSTOM_FIRST = 11
};
enum {
IT_INCLUSIVE,
IT_EXCLUSIVE,
IT_HIDDEN
};
typedef struct tagHH_ENUM_IT {
int cbStruct;
int iType;
LPCSTR pszCatName;
LPCSTR pszITName;
LPCSTR pszITDescription;
} HH_ENUM_IT, *PHH_ENUM_IT;
typedef struct tagHH_ENUM_CAT {
int cbStruct;
LPCSTR pszCatName;
LPCSTR pszCatDescription;
} HH_ENUM_CAT, *PHH_ENUM_CAT;
typedef struct tagHH_SET_INFOTYPE {
int cbStruct;
LPCSTR pszCatName;
LPCSTR pszInfoTypeName;
} HH_SET_INFOTYPE;
typedef DWORD HH_INFOTYPE, *PHH_INFOTYPE;
enum {
HHWIN_NAVTAB_TOP,
HHWIN_NAVTAB_LEFT,
HHWIN_NAVTAB_BOTTOM
};
#define HH_MAX_TABS 19
enum {
HH_TAB_CONTENTS,
HH_TAB_INDEX,
HH_TAB_SEARCH,
HH_TAB_FAVORITES,
HH_TAB_HISTORY,
HH_TAB_AUTHOR,
HH_TAB_CUSTOM_FIRST = 11,
HH_TAB_CUSTOM_LAST = HH_MAX_TABS
};
#define HH_MAX_TABS_CUSTOM (HH_TAB_CUSTOM_LAST-HH_TAB_CUSTOM_FIRST+1)
#define HH_FTS_DEFAULT_PROXIMITY -1
typedef struct tagHH_FTS_QUERYA {
int cbStruct;
BOOL fUniCodeStrings;
LPCSTR pszSearchQuery;
LONG iProximity;
BOOL fStemmedSearch;
BOOL fTitleOnly;
BOOL fExecute;
LPCSTR pszWindow;
} HH_FTS_QUERYA;
typedef struct tagHH_FTS_QUERYW {
int cbStruct;
BOOL fUniCodeStrings;
LPCWSTR pszSearchQuery;
LONG iProximity;
BOOL fStemmedSearch;
BOOL fTitleOnly;
BOOL fExecute;
LPCWSTR pszWindow;
} HH_FTS_QUERYW;
#ifdef _UNICODE
typedef HH_FTS_QUERYW HH_FTS_QUERY;
#else
typedef HH_FTS_QUERYA HH_FTS_QUERY;
#endif
typedef struct tagHH_WINTYPEA {
int cbStruct;
BOOL fUniCodeStrings;
LPCSTR pszType;
DWORD fsValidMembers;
DWORD fsWinProperties;
LPCSTR pszCaption;
DWORD dwStyles;
DWORD dwExStyles;
RECT rcWindowPos;
int nShowState;
HWND hwndHelp;
HWND hwndCaller;
PHH_INFOTYPE paInfoTypes;
HWND hwndToolBar;
HWND hwndNavigation;
HWND hwndHTML;
int iNavWidth;
RECT rcHTML;
LPCSTR pszToc;
LPCSTR pszIndex;
LPCSTR pszFile;
LPCSTR pszHome;
DWORD fsToolBarFlags;
BOOL fNotExpanded;
int curNavType;
int tabpos;
int idNotify;
BYTE tabOrder[HH_MAX_TABS+1];
int cHistory;
LPCSTR pszJump1;
LPCSTR pszJump2;
LPCSTR pszUrlJump1;
LPCSTR pszUrlJump2;
RECT rcMinSize;
int cbInfoTypes;
LPCSTR pszCustomTabs;
} HH_WINTYPEA, *PHH_WINTYPEA;
typedef struct tagHH_WINTYPEW {
int cbStruct;
BOOL fUniCodeStrings;
LPCWSTR pszType;
DWORD fsValidMembers;
DWORD fsWinProperties;
LPCWSTR pszCaption;
DWORD dwStyles;
DWORD dwExStyles;
RECT rcWindowPos;
int nShowState;
HWND hwndHelp;
HWND hwndCaller;
PHH_INFOTYPE paInfoTypes;
HWND hwndToolBar;
HWND hwndNavigation;
HWND hwndHTML;
int iNavWidth;
RECT rcHTML;
LPCWSTR pszToc;
LPCWSTR pszIndex;
LPCWSTR pszFile;
LPCWSTR pszHome;
DWORD fsToolBarFlags;
BOOL fNotExpanded;
int curNavType;
int tabpos;
int idNotify;
BYTE tabOrder[HH_MAX_TABS+1];
int cHistory;
LPCWSTR pszJump1;
LPCWSTR pszJump2;
LPCWSTR pszUrlJump1;
LPCWSTR pszUrlJump2;
RECT rcMinSize;
int cbInfoTypes;
LPCWSTR pszCustomTabs;
} HH_WINTYPEW, *PHH_WINTYPEW;
#ifdef _UNICODE
typedef HH_WINTYPEW HH_WINTYPE;
#else
typedef HH_WINTYPEA HH_WINTYPE;
#endif
enum {
HHACT_TAB_CONTENTS,
HHACT_TAB_INDEX,
HHACT_TAB_SEARCH,
HHACT_TAB_HISTORY,
HHACT_TAB_FAVORITES,
HHACT_EXPAND,
HHACT_CONTRACT,
HHACT_BACK,
HHACT_FORWARD,
HHACT_STOP,
HHACT_REFRESH,
HHACT_HOME,
HHACT_SYNC,
HHACT_OPTIONS,
HHACT_PRINT,
HHACT_HIGHLIGHT,
HHACT_CUSTOMIZE,
HHACT_JUMP1,
HHACT_JUMP2,
HHACT_ZOOM,
HHACT_TOC_NEXT,
HHACT_TOC_PREV,
HHACT_NOTES,
HHACT_LAST_ENUM
};
typedef struct tagHH_NTRACKA {
NMHDR hdr;
PCSTR pszCurUrl;
int idAction;
PHH_WINTYPEA phhWinType;
} HH_NTRACKA;
typedef struct tagHH_NTRACKW {
NMHDR hdr;
PCSTR pszCurUrl;
int idAction;
PHH_WINTYPEW phhWinType;
} HH_NTRACKW;
#ifdef _UNICODE
typedef HH_NTRACKW HH_NTRACK;
#else
typedef HH_NTRACKA HH_NTRACK;
#endif
HWND WINAPI HtmlHelpA(HWND,LPCSTR,UINT,DWORD);
HWND WINAPI HtmlHelpA(HWND,LPCSTR,UINT,DWORD);
#define HtmlHelp WINELIB_NAME_AW(HtmlHelp)
#define ATOM_HTMLHELP_API_ANSI (LPTSTR)14
#define ATOM_HTMLHELP_API_UNICODE (LPTSTR)15
typedef enum tagHH_GPROPID {
HH_GPROPID_SINGLETHREAD = 1,
HH_GPROPID_TOOLBAR_MARGIN = 2,
HH_GPROPID_UI_LANGUAGE = 3,
HH_GPROPID_CURRENT_SUBSET = 4,
HH_GPROPID_CONTENT_LANGUAGE = 5
} HH_GPROPID;
#ifdef __WIDL_OAIDL_H
typedef struct tagHH_GLOBAL_PROPERTY
{
HH_GPROPID id;
VARIANT var;
} HH_GLOBAL_PROPERTY ;
#endif /* __WIDL_OAIDL_H */
#ifdef __cplusplus
}
#endif
#endif /* __HTMLHELP_H__ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/listbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/listbox.h
// Purpose: wxListBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTBOX_H_
#define _WX_LISTBOX_H_
#if wxUSE_LISTBOX
// ----------------------------------------------------------------------------
// simple types
// ----------------------------------------------------------------------------
#if wxUSE_OWNER_DRAWN
class WXDLLIMPEXP_FWD_CORE wxOwnerDrawn;
// define the array of list box items
#include "wx/dynarray.h"
WX_DEFINE_EXPORTED_ARRAY_PTR(wxOwnerDrawn *, wxListBoxItemsArray);
#endif // wxUSE_OWNER_DRAWN
// forward declaration for GetSelections()
class WXDLLIMPEXP_FWD_BASE wxArrayInt;
// ----------------------------------------------------------------------------
// List box control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxListBox : public wxListBoxBase
{
public:
// ctors and such
wxListBox() { Init(); }
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Init();
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Init();
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
virtual ~wxListBox();
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& s) wxOVERRIDE;
virtual int FindString(const wxString& s, bool bCase = false) const wxOVERRIDE;
virtual bool IsSelected(int n) const wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual int GetSelections(wxArrayInt& aSelections) const wxOVERRIDE;
// return the index of the item at this position or wxNOT_FOUND
int HitTest(const wxPoint& pt) const { return DoHitTestList(pt); }
int HitTest(wxCoord x, wxCoord y) const { return DoHitTestList(wxPoint(x, y)); }
virtual void EnsureVisible(int n) wxOVERRIDE;
virtual int GetTopItem() const wxOVERRIDE;
virtual int GetCountPerPage() const wxOVERRIDE;
// ownerdrawn wxListBox and wxCheckListBox support
#if wxUSE_OWNER_DRAWN
// override base class virtuals
virtual bool SetFont(const wxFont &font) wxOVERRIDE;
bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item) wxOVERRIDE;
bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE;
// plug-in for derived classes
virtual wxOwnerDrawn *CreateLboxItem(size_t n);
// allows to get the item and use SetXXX functions to set it's appearance
wxOwnerDrawn *GetItem(size_t n) const { return m_aItems[n]; }
// get the index of the given item
int GetItemIndex(wxOwnerDrawn *item) const { return m_aItems.Index(item); }
// get rect of the given item index
bool GetItemRect(size_t n, wxRect& rect) const;
// redraw the given item
bool RefreshItem(size_t n);
#endif // wxUSE_OWNER_DRAWN
// Windows-specific code to update the horizontal extent of the listbox, if
// necessary. If s is non-empty, the horizontal extent is increased to the
// length of this string if it's currently too short, otherwise the maximum
// extent of all strings is used. In any case calls InvalidateBestSize()
virtual void SetHorizontalExtent(const wxString& s = wxEmptyString);
// Windows callbacks
bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// under XP when using "transition effect for menus and tooltips" if we
// return true for WM_PRINTCLIENT here then it causes noticeable slowdown
virtual bool MSWShouldPropagatePrintChild() wxOVERRIDE
{
return false;
}
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL)
{
return GetCompositeControlsDefaultAttributes(variant);
}
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
virtual void OnInternalIdle() wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual void DoSetSelection(int n, bool select) wxOVERRIDE;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual void DoSetFirstItem(int n) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
// this can't be called DoHitTest() because wxWindow already has this method
virtual int DoHitTestList(const wxPoint& point) const;
// free memory (common part of Clear() and dtor)
void Free();
unsigned int m_noItems;
#if wxUSE_OWNER_DRAWN
// control items
wxListBoxItemsArray m_aItems;
#endif
private:
// common part of all ctors
void Init();
// call this when items are added to or deleted from the listbox or an
// items text changes
void MSWOnItemsChanged();
// flag indicating whether the max horizontal extent should be updated,
// i.e. if we need to call SetHorizontalExtent() from OnInternalIdle()
bool m_updateHorizontalExtent;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxListBox);
};
#endif // wxUSE_LISTBOX
#endif
// _WX_LISTBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/textentry.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/textentry.h
// Purpose: wxMSW-specific wxTextEntry implementation
// Author: Vadim Zeitlin
// Created: 2007-09-26
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TEXTENTRY_H_
#define _WX_MSW_TEXTENTRY_H_
class wxTextAutoCompleteData; // private class used only by wxTextEntry itself
// ----------------------------------------------------------------------------
// wxTextEntry: common part of wxComboBox and (single line) wxTextCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTextEntry : public wxTextEntryBase
{
public:
wxTextEntry();
virtual ~wxTextEntry();
// implement wxTextEntryBase pure virtual methods
virtual void WriteText(const wxString& text) wxOVERRIDE;
virtual void Remove(long from, long to) wxOVERRIDE;
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
virtual void SetInsertionPoint(long pos) wxOVERRIDE;
virtual long GetInsertionPoint() const wxOVERRIDE;
virtual long GetLastPosition() const wxOVERRIDE;
virtual void SetSelection(long from, long to) wxOVERRIDE
{ DoSetSelection(from, to); }
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
virtual void SetEditable(bool editable) wxOVERRIDE;
virtual void SetMaxLength(unsigned long len) wxOVERRIDE;
virtual void ForceUpper() wxOVERRIDE;
#if wxUSE_UXTHEME
virtual bool SetHint(const wxString& hint) wxOVERRIDE;
virtual wxString GetHint() const wxOVERRIDE;
#endif // wxUSE_UXTHEME
protected:
virtual wxString DoGetValue() const wxOVERRIDE;
// this is really a hook for multiline text controls as the single line
// ones don't need to ever scroll to show the selection but having it here
// allows us to put Remove() in the base class
enum
{
SetSel_NoScroll = 0, // don't do anything special
SetSel_Scroll = 1 // default: scroll to make the selection visible
};
virtual void DoSetSelection(long from, long to, int flags = SetSel_Scroll);
// margins functions
virtual bool DoSetMargins(const wxPoint& pt) wxOVERRIDE;
virtual wxPoint DoGetMargins() const wxOVERRIDE;
// auto-completion uses COM under Windows so they won't work without
// wxUSE_OLE as OleInitialize() is not called then
#if wxUSE_OLE
virtual bool DoAutoCompleteStrings(const wxArrayString& choices) wxOVERRIDE;
#if wxUSE_DYNLIB_CLASS
virtual bool DoAutoCompleteFileNames(int flags) wxOVERRIDE;
#endif // wxUSE_DYNLIB_CLASS
virtual bool DoAutoCompleteCustom(wxTextCompleter *completer) wxOVERRIDE;
#endif // wxUSE_OLE
private:
// implement this to return the HWND of the EDIT control
virtual WXHWND GetEditHWND() const = 0;
#if wxUSE_OLE
// This method is called to process special keys such as Return and Tab
// before they're consumed by the auto-completer. Notice that it is only
// called if we do need to process the key, i.e. if the corresponding
// wxTE_PROCESS_XXX style is set in the associated object.
//
// It is not pure virtual because it won't get called if the derived class
// doesn't use auto-completer, but it does need to be overridden if it can
// be called and the default implementation asserts if this is not the case.
virtual void MSWProcessSpecialKey(wxKeyEvent& event);
// Get the auto-complete object creating it if necessary. Returns NULL if
// creating it failed.
wxTextAutoCompleteData *GetOrCreateCompleter();
// Various auto-completion-related stuff, only used if any of AutoComplete()
// methods are called. Use the function above to access it.
wxTextAutoCompleteData *m_autoCompleteData;
// It needs to call our GetEditableWindow() and GetEditHWND() methods.
friend class wxTextAutoCompleteData;
#endif // wxUSE_OLE
};
// We don't need the generic version.
#define wxHAS_NATIVE_TEXT_FORCEUPPER
#endif // _WX_MSW_TEXTENTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/wrapwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapwin.h
// Purpose: Wrapper around <windows.h>, to be included instead of it
// Author: Vaclav Slavik
// Created: 2003/07/22
// Copyright: (c) 2003 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WRAPWIN_H_
#define _WX_WRAPWIN_H_
#include "wx/platform.h"
// before including windows.h, define version macros at (currently) maximal
// values because we do all our checks at run-time anyhow
#include "wx/msw/winver.h"
// strict type checking to detect conversion from HFOO to HBAR at compile-time
#ifndef STRICT
#define STRICT 1
#endif
// this macro tells windows.h to not define min() and max() as macros: we need
// this as otherwise they conflict with standard C++ functions
#ifndef NOMINMAX
#define NOMINMAX
#endif // NOMINMAX
// For IPv6 support, we must include winsock2.h before winsock.h, and
// windows.h include winsock.h so do it before including it
#if wxUSE_IPV6
#include <winsock2.h>
#endif
// Disable any warnings inside Windows headers.
#ifdef __VISUALC__
#pragma warning(push, 1)
#endif
#include <windows.h>
#ifdef __VISUALC__
#pragma warning(pop)
#endif
// #undef the macros defined in winsows.h which conflict with code elsewhere
#include "wx/msw/winundef.h"
#endif // _WX_WRAPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/fontdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/fontdlg.h
// Purpose: wxFontDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_FONTDLG_H_
#define _WX_MSW_FONTDLG_H_
// ----------------------------------------------------------------------------
// wxFontDialog
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFontDialog : public wxFontDialogBase
{
public:
wxFontDialog() : wxFontDialogBase() { /* must be Create()d later */ }
wxFontDialog(wxWindow *parent)
: wxFontDialogBase(parent) { Create(parent); }
wxFontDialog(wxWindow *parent, const wxFontData& data)
: wxFontDialogBase(parent, data) { Create(parent, data); }
virtual int ShowModal() wxOVERRIDE;
virtual void SetTitle(const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
protected:
wxString m_title;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxFontDialog);
};
#endif
// _WX_MSW_FONTDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/filedlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/filedlg.h
// Purpose: wxFileDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FILEDLG_H_
#define _WX_FILEDLG_H_
//-------------------------------------------------------------------------
// wxFileDialog
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDialog: public wxFileDialogBase
{
public:
wxFileDialog(wxWindow *parent,
const wxString& message = wxFileSelectorPromptStr,
const wxString& defaultDir = wxEmptyString,
const wxString& defaultFile = wxEmptyString,
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = wxFD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& sz = wxDefaultSize,
const wxString& name = wxFileDialogNameStr);
virtual void GetPaths(wxArrayString& paths) const wxOVERRIDE;
virtual void GetFilenames(wxArrayString& files) const wxOVERRIDE;
virtual bool SupportsExtraControl() const wxOVERRIDE { return true; }
void MSWOnInitDialogHook(WXHWND hwnd);
virtual int ShowModal() wxOVERRIDE;
// wxMSW-specific implementation from now on
// -----------------------------------------
// called from the hook procedure on CDN_INITDONE reception
virtual void MSWOnInitDone(WXHWND hDlg);
// called from the hook procedure on CDN_SELCHANGE.
void MSWOnSelChange(WXHWND hDlg);
protected:
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoCentre(int dir) wxOVERRIDE;
virtual void DoGetSize( int *width, int *height ) const wxOVERRIDE;
virtual void DoGetPosition( int *x, int *y ) const wxOVERRIDE;
private:
wxArrayString m_fileNames;
// remember if our SetPosition() or Centre() (which requires special
// treatment) was called
bool m_bMovedWindow;
int m_centreDir; // nothing to do if 0
wxDECLARE_DYNAMIC_CLASS(wxFileDialog);
wxDECLARE_NO_COPY_CLASS(wxFileDialog);
};
#endif // _WX_FILEDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/gccpriv.h | /*
Name: wx/msw/gccpriv.h
Purpose: MinGW/Cygwin definitions
Author: Vadim Zeitlin
Modified by:
Created:
Copyright: (c) Vadim Zeitlin
Licence: wxWindows Licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_MSW_GCCPRIV_H_
#define _WX_MSW_GCCPRIV_H_
#if defined(__MINGW32__) && !defined(__GNUWIN32__)
#define __GNUWIN32__
#endif
#if defined(__MINGW32__)
/*
Include the header defining __MINGW32_{MAJ,MIN}OR_VERSION but check
that UNICODE or _UNICODE is already defined, as _mingw.h relies on them
being set and we'd get weird compilation errors later if it is included
without them being defined, better give a clearer error right now.
*/
#if !defined(UNICODE)
#ifndef wxUSE_UNICODE
#error "wxUSE_UNICODE must be defined before including this header."
#endif
#if wxUSE_UNICODE
#error "UNICODE must be defined before including this header."
#endif
#endif
/*
MinGW 5.3.0 (and presumably later) predefines _WIN32_WINNT and WINVER
in sdkddkver.h included from _mingw.h to very low (Windows 2000!)
values. We really want to predefine them ourselves instead, so do it
before including _mingw.h.
*/
#include "wx/msw/winver.h"
#include <_mingw.h>
/*
MinGW-w64 project provides compilers for both Win32 and Win64 but only
defines the same __MINGW32__ symbol for the former as MinGW32 toolchain
which is quite different (notably doesn't provide many SDK headers that
MinGW-w64 does include). So we define a separate symbol which, unlike
the predefined __MINGW64__, can be used to detect this toolchain in
both 32 and 64 bit builds.
And define __MINGW32_TOOLCHAIN__ for consistency and also because it's
convenient as we often want to have some workarounds only for the (old)
MinGW32 but not (newer) MinGW-w64, which still predefines __MINGW32__.
*/
#ifdef __MINGW64_VERSION_MAJOR
#ifndef __MINGW64_TOOLCHAIN__
#define __MINGW64_TOOLCHAIN__
#endif
#else
#ifndef __MINGW32_TOOLCHAIN__
#define __MINGW32_TOOLCHAIN__
#endif
#endif
#define wxCHECK_MINGW32_VERSION( major, minor ) \
( ( ( __MINGW32_MAJOR_VERSION > (major) ) \
|| ( __MINGW32_MAJOR_VERSION == (major) && __MINGW32_MINOR_VERSION >= (minor) ) ) )
#else
#define wxCHECK_MINGW32_VERSION( major, minor ) (0)
#endif
#if defined( __MINGW32__ ) && !defined(__WINE__) && !defined( HAVE_W32API_H )
#if __MINGW32_MAJOR_VERSION >= 1
#define HAVE_W32API_H
#endif
#elif defined( __CYGWIN__ ) && !defined( HAVE_W32API_H )
#if ( __GNUC__ > 2 )
#define HAVE_W32API_H
#endif
#endif
/* check for MinGW/Cygwin w32api version ( releases >= 0.5, only ) */
#if defined( HAVE_W32API_H )
#include <w32api.h>
#endif
#if defined(__W32API_MAJOR_VERSION) && defined(__W32API_MINOR_VERSION)
#define wxCHECK_W32API_VERSION( major, minor ) \
( ( ( __W32API_MAJOR_VERSION > (major) ) \
|| ( __W32API_MAJOR_VERSION == (major) && __W32API_MINOR_VERSION >= (minor) ) ) )
#else
#define wxCHECK_W32API_VERSION( major, minor ) (0)
#endif
/* Cygwin 1.0 */
#if defined(__CYGWIN__) && ((__GNUC__==2) && (__GNUC_MINOR__==9))
#define __CYGWIN10__
#endif
/*
Traditional MinGW (but not MinGW-w64 nor TDM-GCC) omits many POSIX
functions from their headers when compiled with __STRICT_ANSI__ defined.
Unfortunately this means that they are not available when using -std=c++98
(not very common) or -std=c++11 (much more so), but we still need them even
in this case. As the intention behind using -std=c++11 is probably to get
the new C++11 features and not disable the use of POSIX functions, we just
manually declare the functions we need in this case if necessary.
*/
#ifdef __MINGW32_TOOLCHAIN__
/*
The macro below is used in wx/wxcrtbase.h included from C regex library
code, so make sure it compiles in non-C++ code too.
*/
#ifdef __cplusplus
#define wxEXTERNC extern "C"
#else
#define wxEXTERNC
#endif
/*
This macro is somewhat unusual as it takes the list of parameters
inside parentheses and includes semicolon inside it as putting the
semicolon outside wouldn't do the right thing when this macro is empty.
*/
#define wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params) \
wxEXTERNC _CRTIMP rettype __cdecl __MINGW_NOTHROW func params ;
#ifdef __STRICT_ANSI__
#define wxNEEDS_STRICT_ANSI_WORKAROUNDS
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params) \
wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params)
/*
There is a bug resulting in a compilation error in MinGW standard
math.h header, see https://sourceforge.net/p/mingw/bugs/2250/, work
around it here because math.h is also included from several other
standard headers (e.g. <algorithm>) and we don't want to duplicate this
hack everywhere this happens.
*/
wxDECL_FOR_STRICT_MINGW32(double, _hypot, (double, double))
#else
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params)
#endif
#else
#define wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params)
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params)
#endif
#endif
/* _WX_MSW_GCCPRIV_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/apptrait.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/apptrait.h
// Purpose: class implementing wxAppTraits for MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 21.06.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_APPTRAIT_H_
#define _WX_MSW_APPTRAIT_H_
// ----------------------------------------------------------------------------
// wxGUI/ConsoleAppTraits: must derive from wxAppTraits, not wxAppTraitsBase
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxConsoleAppTraits : public wxConsoleAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
virtual void *BeforeChildWaitLoop() wxOVERRIDE;
virtual void AfterChildWaitLoop(void *data) wxOVERRIDE;
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif // wxUSE_TIMER
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() wxOVERRIDE;
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags) wxOVERRIDE;
#endif // wxUSE_THREADS
virtual bool CanUseStderr() wxOVERRIDE { return true; }
virtual bool WriteToStderr(const wxString& text) wxOVERRIDE;
};
#if wxUSE_GUI
#if defined(__WXMSW__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
virtual void *BeforeChildWaitLoop() wxOVERRIDE;
virtual void AfterChildWaitLoop(void *data) wxOVERRIDE;
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif // wxUSE_TIMER
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() wxOVERRIDE;
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags) wxOVERRIDE;
#endif // wxUSE_THREADS
wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const wxOVERRIDE;
virtual bool CanUseStderr() wxOVERRIDE;
virtual bool WriteToStderr(const wxString& text) wxOVERRIDE;
};
#elif defined(__WXGTK__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop();
virtual void *BeforeChildWaitLoop() { return NULL; }
virtual void AfterChildWaitLoop(void *WXUNUSED(data)) { }
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer);
#endif
#if wxUSE_THREADS && defined(__WXGTK20__)
virtual void MutexGuiEnter();
virtual void MutexGuiLeave();
#endif
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() { return true; }
virtual WXDWORD WaitForThread(WXHANDLE hThread, int WXUNUSED(flags))
{ return DoSimpleWaitForThread(hThread); }
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const;
virtual bool CanUseStderr() { return false; }
virtual bool WriteToStderr(const wxString& WXUNUSED(text)) { return false; }
};
#elif defined(__WXQT__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop();
virtual void *BeforeChildWaitLoop() { return NULL; }
virtual void AfterChildWaitLoop(void*) { }
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer);
#endif
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() { return true; }
virtual WXDWORD WaitForThread(WXHANDLE hThread, int WXUNUSED(flags))
{ return DoSimpleWaitForThread(hThread); }
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const;
virtual bool CanUseStderr() { return false; }
virtual bool WriteToStderr(const wxString&) { return false; }
};
#endif
#endif // wxUSE_GUI
#endif // _WX_MSW_APPTRAIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/spinbutt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/spinbutt.h
// Purpose: wxSpinButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SPINBUTT_H_
#define _WX_SPINBUTT_H_
#include "wx/control.h"
#include "wx/event.h"
#if wxUSE_SPINBTN
class WXDLLIMPEXP_CORE wxSpinButton : public wxSpinButtonBase
{
public:
// construction
wxSpinButton() { }
wxSpinButton(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME)
{
Create(parent, id, pos, size, style, name);
}
virtual ~wxSpinButton();
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME);
// accessors
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int val) wxOVERRIDE;
virtual void SetRange(int minVal, int maxVal) wxOVERRIDE;
// implementation
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
// a wxSpinButton can't do anything useful with focus, only wxSpinCtrl can
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// ensure that the control displays a value in the current range
virtual void NormalizeValue();
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxSpinButton);
};
#endif // wxUSE_SPINBTN
#endif // _WX_SPINBUTT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/helpbest.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpbest.h
// Purpose: Tries to load MS HTML Help, falls back to wxHTML upon failure
// Author: Mattia Barbon
// Modified by:
// Created: 02/04/2001
// Copyright: (c) Mattia Barbon
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPBEST_H_
#define _WX_HELPBEST_H_
#if wxUSE_HELP && wxUSE_MS_HTML_HELP \
&& wxUSE_WXHTML_HELP && !defined(__WXUNIVERSAL__)
#include "wx/helpbase.h"
#include "wx/html/helpfrm.h" // for wxHF_DEFAULT_STYLE
class WXDLLIMPEXP_HTML wxBestHelpController: public wxHelpControllerBase
{
public:
wxBestHelpController(wxWindow* parentWindow = NULL,
int style = wxHF_DEFAULT_STYLE)
: wxHelpControllerBase(parentWindow),
m_helpControllerType(wxUseNone),
m_helpController(NULL),
m_style(style)
{
}
virtual ~wxBestHelpController() { delete m_helpController; }
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE
{
return m_helpController->LoadFile( GetValidFilename( file ) );
}
virtual bool DisplayContents() wxOVERRIDE
{
return m_helpController->DisplayContents();
}
virtual bool DisplaySection(int sectionNo) wxOVERRIDE
{
return m_helpController->DisplaySection( sectionNo );
}
virtual bool DisplaySection(const wxString& section) wxOVERRIDE
{
return m_helpController->DisplaySection( section );
}
virtual bool DisplayBlock(long blockNo) wxOVERRIDE
{
return m_helpController->DisplayBlock( blockNo );
}
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE
{
return m_helpController->DisplayContextPopup( contextId );
}
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos) wxOVERRIDE
{
return m_helpController->DisplayTextPopup( text, pos );
}
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE
{
return m_helpController->KeywordSearch( k, mode );
}
virtual bool Quit() wxOVERRIDE
{
return m_helpController->Quit();
}
// Allows one to override the default settings for the help frame.
virtual void SetFrameParameters(const wxString& title,
const wxSize& size,
const wxPoint& pos = wxDefaultPosition,
bool newFrameEachTime = false) wxOVERRIDE
{
m_helpController->SetFrameParameters( title, size, pos,
newFrameEachTime );
}
// Obtains the latest settings used by the help frame and the help frame.
virtual wxFrame *GetFrameParameters(wxSize *size = NULL,
wxPoint *pos = NULL,
bool *newFrameEachTime = NULL) wxOVERRIDE
{
return m_helpController->GetFrameParameters( size, pos,
newFrameEachTime );
}
/// Set the window that can optionally be used for the help window's parent.
virtual void SetParentWindow(wxWindow* win) wxOVERRIDE { m_helpController->SetParentWindow(win); }
/// Get the window that can optionally be used for the help window's parent.
virtual wxWindow* GetParentWindow() const wxOVERRIDE { return m_helpController->GetParentWindow(); }
protected:
// Append/change extension if necessary.
wxString GetValidFilename(const wxString& file) const;
protected:
enum HelpControllerType { wxUseNone, wxUseHtmlHelp, wxUseChmHelp };
HelpControllerType m_helpControllerType;
wxHelpControllerBase* m_helpController;
int m_style;
wxDECLARE_DYNAMIC_CLASS(wxBestHelpController);
wxDECLARE_NO_COPY_CLASS(wxBestHelpController);
};
#endif // wxUSE_HELP && wxUSE_MS_HTML_HELP && wxUSE_WXHTML_HELP
#endif
// _WX_HELPBEST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/registry.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/registry.h
// Purpose: Registry classes and functions
// Author: Vadim Zeitlin
// Modified by:
// Created: 03.04.1998
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_REGISTRY_H_
#define _WX_MSW_REGISTRY_H_
#include "wx/defs.h"
#if wxUSE_REGKEY
class WXDLLIMPEXP_FWD_BASE wxOutputStream;
// ----------------------------------------------------------------------------
// class wxRegKey encapsulates window HKEY handle
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxRegKey
{
public:
// NB: do _not_ change the values of elements in these enumerations!
// registry value types (with comments from winnt.h)
enum ValueType
{
Type_None, // No value type
Type_String, // Unicode nul terminated string
Type_Expand_String, // Unicode nul terminated string
// (with environment variable references)
Type_Binary, // Free form binary
Type_Dword, // 32-bit number
Type_Dword_little_endian // 32-bit number
= Type_Dword, // (same as Type_DWORD)
Type_Dword_big_endian, // 32-bit number
Type_Link, // Symbolic Link (unicode)
Type_Multi_String, // Multiple Unicode strings
Type_Resource_list, // Resource list in the resource map
Type_Full_resource_descriptor, // Resource list in the hardware description
Type_Resource_requirements_list // ???
};
// predefined registry keys
enum StdKey
{
HKCR, // classes root
HKCU, // current user
HKLM, // local machine
HKUSR, // users
HKPD, // (obsolete under XP and later)
HKCC, // current config
HKDD, // (obsolete under XP and later)
HKMAX
};
// access mode for the key
enum AccessMode
{
Read, // read-only
Write // read and write
};
// Different registry views supported under WOW64.
enum WOW64ViewMode
{
// 32 bit registry for 32 bit applications, 64 bit registry
// for 64 bit ones.
WOW64ViewMode_Default,
// Can be used in 64 bit apps to access 32 bit registry,
// has no effect (i.e. treated as default) in 32 bit apps.
WOW64ViewMode_32,
// Can be used in 32 bit apps to access 64 bit registry,
// has no effect (i.e. treated as default) in 64 bit apps.
WOW64ViewMode_64
};
// information about standard (predefined) registry keys
// number of standard keys
static const size_t nStdKeys;
// get the name of a standard key
static const wxChar *GetStdKeyName(size_t key);
// get the short name of a standard key
static const wxChar *GetStdKeyShortName(size_t key);
// get StdKey from root HKEY
static StdKey GetStdKeyFromHkey(WXHKEY hkey);
// extracts the std key prefix from the string (return value) and
// leaves only the part after it (i.e. modifies the string passed!)
static StdKey ExtractKeyName(wxString& str);
// ctors
// root key is set to HKCR (the only root key under Win16)
wxRegKey(WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the full name of the key (i.e. starting with HKEY_xxx...)
wxRegKey(const wxString& strKey,
WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the name of key under (standard key) keyParent
wxRegKey(StdKey keyParent,
const wxString& strKey,
WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the name of key under (previously created) keyParent
wxRegKey(const wxRegKey& keyParent, const wxString& strKey);
// dtor closes the key
~wxRegKey();
// change key (closes the previously opened key if any)
// the name is absolute, i.e. should start with HKEY_xxx
void SetName(const wxString& strKey);
// the name is relative to the parent key
void SetName(StdKey keyParent, const wxString& strKey);
// the name is relative to the parent key
void SetName(const wxRegKey& keyParent, const wxString& strKey);
// hKey should be opened and will be closed in wxRegKey dtor
void SetHkey(WXHKEY hKey);
// get information about the key
// get the (full) key name. Abbreviate std root keys if bShortPrefix.
wxString GetName(bool bShortPrefix = true) const;
// Retrieves the registry view used by this key.
WOW64ViewMode GetView() const { return m_viewMode; }
// return true if the key exists
bool Exists() const;
// get the info about key (any number of these pointers may be NULL)
bool GetKeyInfo(size_t *pnSubKeys, // number of subkeys
size_t *pnMaxKeyLen, // max length of subkey name
size_t *pnValues, // number of values
size_t *pnMaxValueLen) const;
// return true if the key is opened
bool IsOpened() const { return m_hKey != 0; }
// for "if ( !key ) wxLogError(...)" kind of expressions
operator bool() const { return m_dwLastError == 0; }
// operations on the key itself
// explicitly open the key (will be automatically done by all functions
// which need the key to be opened if the key is not opened yet)
bool Open(AccessMode mode = Write);
// create the key: will fail if the key already exists and !bOkIfExists
bool Create(bool bOkIfExists = true);
// rename a value from old name to new one
bool RenameValue(const wxString& szValueOld, const wxString& szValueNew);
// rename the key
bool Rename(const wxString& szNewName);
// copy value to another key possibly changing its name (by default it will
// remain the same)
bool CopyValue(const wxString& szValue, wxRegKey& keyDst,
const wxString& szNewName = wxEmptyString);
// copy the entire contents of the key recursively to another location
bool Copy(const wxString& szNewName);
// same as Copy() but using a key and not the name
bool Copy(wxRegKey& keyDst);
// close the key (will be automatically done in dtor)
bool Close();
// deleting keys/values
// deletes this key and all of it's subkeys/values
bool DeleteSelf();
// deletes the subkey with all of it's subkeys/values recursively
bool DeleteKey(const wxString& szKey);
// deletes the named value (may be empty string to remove the default value)
bool DeleteValue(const wxString& szValue);
// access to values and subkeys
// get value type
ValueType GetValueType(const wxString& szValue) const;
// returns true if the value contains a number (else it's some string)
bool IsNumericValue(const wxString& szValue) const;
// assignment operators set the default value of the key
wxRegKey& operator=(const wxString& strValue)
{ SetValue(wxEmptyString, strValue); return *this; }
// query the default value of the key: implicitly or explicitly
wxString QueryDefaultValue() const;
operator wxString() const { return QueryDefaultValue(); }
// named values
// set the string value
bool SetValue(const wxString& szValue, const wxString& strValue);
// retrieve the string value
bool QueryValue(const wxString& szValue, wxString& strValue) const
{ return QueryValue(szValue, strValue, false); }
// retrieve raw string value
bool QueryRawValue(const wxString& szValue, wxString& strValue) const
{ return QueryValue(szValue, strValue, true); }
// retrieve either raw or expanded string value
bool QueryValue(const wxString& szValue, wxString& strValue, bool raw) const;
// set the numeric value
bool SetValue(const wxString& szValue, long lValue);
// return the numeric value
bool QueryValue(const wxString& szValue, long *plValue) const;
// set the binary value
bool SetValue(const wxString& szValue, const wxMemoryBuffer& buf);
// return the binary value
bool QueryValue(const wxString& szValue, wxMemoryBuffer& buf) const;
// query existence of a key/value
// return true if value exists
bool HasValue(const wxString& szKey) const;
// return true if given subkey exists
bool HasSubKey(const wxString& szKey) const;
// return true if any subkeys exist
bool HasSubkeys() const;
// return true if any values exist
bool HasValues() const;
// return true if the key is empty (nothing under this key)
bool IsEmpty() const { return !HasSubkeys() && !HasValues(); }
// enumerate values and subkeys
bool GetFirstValue(wxString& strValueName, long& lIndex);
bool GetNextValue (wxString& strValueName, long& lIndex) const;
bool GetFirstKey (wxString& strKeyName , long& lIndex);
bool GetNextKey (wxString& strKeyName , long& lIndex) const;
// export the contents of this key and all its subkeys to the given file
// (which won't be overwritten, it's an error if it already exists)
//
// note that we export the key in REGEDIT4 format, not RegSaveKey() binary
// format nor newer REGEDIT5 one
bool Export(const wxString& filename) const;
// same as above but write to the given (opened) stream
bool Export(wxOutputStream& ostr) const;
// for wxRegConfig usage only: preallocate some memory for the name
void ReserveMemoryForName(size_t bytes) { m_strKey.reserve(bytes); }
private:
// common part of all ctors
void Init()
{
m_hKey = (WXHKEY) NULL;
m_dwLastError = 0;
}
// recursive helper for Export()
bool DoExport(wxOutputStream& ostr) const;
// export a single value
bool DoExportValue(wxOutputStream& ostr, const wxString& name) const;
// return the text representation (in REGEDIT4 format) of the value with the
// given name
wxString FormatValue(const wxString& name) const;
WXHKEY m_hKey, // our handle
m_hRootKey; // handle of the top key (i.e. StdKey)
wxString m_strKey; // key name (relative to m_hRootKey)
WOW64ViewMode m_viewMode; // which view to select under WOW64
AccessMode m_mode; // valid only if key is opened
long m_dwLastError; // last error (0 if none)
wxDECLARE_NO_COPY_CLASS(wxRegKey);
};
#endif // wxUSE_REGKEY
#endif // _WX_MSW_REGISTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/statbmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/statbmp.h
// Purpose: wxStaticBitmap class for wxMSW
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATBMP_H_
#define _WX_STATBMP_H_
#include "wx/control.h"
#include "wx/icon.h"
#include "wx/bitmap.h"
extern WXDLLIMPEXP_DATA_CORE(const char) wxStaticBitmapNameStr[];
// a control showing an icon or a bitmap
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
public:
wxStaticBitmap() { Init(); }
wxStaticBitmap(wxWindow *parent,
wxWindowID id,
const wxGDIImage& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr)
{
Init();
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxGDIImage& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual ~wxStaticBitmap() { Free(); }
virtual void SetIcon(const wxIcon& icon) wxOVERRIDE { SetImage(&icon); }
virtual void SetBitmap(const wxBitmap& bitmap) wxOVERRIDE { SetImage(&bitmap); }
virtual wxBitmap GetBitmap() const wxOVERRIDE;
virtual wxIcon GetIcon() const wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// ctor/dtor helpers
void Init();
void Free();
// true if icon/bitmap is valid
bool ImageIsOk() const;
void SetImage(const wxGDIImage* image);
void SetImageNoCopy( wxGDIImage* image );
// draw the bitmap ourselves here if the OS can't do it correctly (if it
// can we leave it to it)
void DoPaintManually(wxPaintEvent& event);
void WXHandleSize(wxSizeEvent& event);
// we can have either an icon or a bitmap
bool m_isIcon;
wxGDIImage *m_image;
// handle used in last call to STM_SETIMAGE
WXHANDLE m_currentHandle;
private:
// Flag indicating whether we own m_currentHandle, i.e. should delete it.
bool m_ownsCurrentHandle;
// Replace the image at the native control level with the given HBITMAP or
// HICON (which can be 0) and destroy the previous image if necessary.
void MSWReplaceImageHandle(WXLPARAM handle);
// Delete the current handle only if we own it.
void DeleteCurrentHandleIfNeeded();
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxStaticBitmap);
};
#endif
// _WX_STATBMP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/slider.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/slider.h
// Purpose: wxSlider class implementation using trackbar control
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SLIDER_H_
#define _WX_SLIDER_H_
class WXDLLIMPEXP_FWD_CORE wxSubwindows;
// Slider
class WXDLLIMPEXP_CORE wxSlider : public wxSliderBase
{
public:
wxSlider() { Init(); }
wxSlider(wxWindow *parent,
wxWindowID id,
int value,
int minValue,
int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr)
{
Init();
(void)Create(parent, id, value, minValue, maxValue,
pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
int value,
int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
virtual ~wxSlider();
// slider methods
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int) wxOVERRIDE;
void SetRange(int minValue, int maxValue) wxOVERRIDE;
int GetMin() const wxOVERRIDE { return m_rangeMin; }
int GetMax() const wxOVERRIDE { return m_rangeMax; }
// Win32-specific slider methods
int GetTickFreq() const wxOVERRIDE { return m_tickFreq; }
void SetPageSize(int pageSize) wxOVERRIDE;
int GetPageSize() const wxOVERRIDE;
void ClearSel() wxOVERRIDE;
void ClearTicks() wxOVERRIDE;
void SetLineSize(int lineSize) wxOVERRIDE;
int GetLineSize() const wxOVERRIDE;
int GetSelEnd() const wxOVERRIDE;
int GetSelStart() const wxOVERRIDE;
void SetSelection(int minPos, int maxPos) wxOVERRIDE;
void SetThumbLength(int len) wxOVERRIDE;
int GetThumbLength() const wxOVERRIDE;
void SetTick(int tickPos) wxOVERRIDE;
// implementation only from now on
WXHWND GetStaticMin() const;
WXHWND GetStaticMax() const;
WXHWND GetEditValue() const;
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE;
// we should let background show through the slider (and its labels)
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Enable(bool show = true) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// format an integer value as string
static wxString Format(int n) { return wxString::Format(wxT("%d"), n); }
// get the boundig box for the slider and possible labels
wxRect GetBoundingBox() const;
// Get the height and, if the pointers are non NULL, widths of both labels.
//
// Notice that the return value will be 0 if we don't have wxSL_LABELS
// style but we do fill widthMin and widthMax even if we don't have
// wxSL_MIN_MAX_LABELS style set so the caller should account for it.
int GetLabelsSize(int *widthMin = NULL, int *widthMax = NULL) const;
// overridden base class virtuals
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
WXHBRUSH DoMSWControlColor(WXHDC pDC, wxColour colBg, WXHWND hWnd) wxOVERRIDE;
// the labels windows, if any
wxSubwindows *m_labels;
// Last background brush we returned from DoMSWControlColor(), see there.
WXHBRUSH m_hBrushBg;
int m_rangeMin;
int m_rangeMax;
int m_pageSize;
int m_lineSize;
int m_tickFreq;
// flag needed to detect whether we're getting THUMBRELEASE event because
// of dragging the thumb or scrolling the mouse wheel
bool m_isDragging;
// Platform-specific implementation of SetTickFreq
virtual void DoSetTickFreq(int freq) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxSlider);
};
#endif // _WX_SLIDER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/crashrpt.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/crashrpt.h
// Purpose: helpers for the structured exception handling (SEH) under Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 13.07.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CRASHRPT_H_
#define _WX_MSW_CRASHRPT_H_
#include "wx/defs.h"
#if wxUSE_CRASHREPORT
struct _EXCEPTION_POINTERS;
// ----------------------------------------------------------------------------
// crash report generation flags
// ----------------------------------------------------------------------------
enum
{
// we always report where the crash occurred
wxCRASH_REPORT_LOCATION = 0,
// if this flag is given, the call stack is dumped
//
// this results in dump/crash report as small as possible, this is the
// default flag
wxCRASH_REPORT_STACK = 1,
// if this flag is given, the values of the local variables are dumped
//
// note that with the current implementation it requires dumping the full
// process address space and so this will result in huge dump file and will
// take some time to generate
//
// it's probably not a good idea to use this by default, start with default
// mini dump and ask your users to set WX_CRASH_FLAGS environment variable
// to 2 or 4 if you need more information in the dump
wxCRASH_REPORT_LOCALS = 2,
// if this flag is given, the values of all global variables are dumped
//
// this creates a much larger mini dump than just wxCRASH_REPORT_STACK but
// still much smaller than wxCRASH_REPORT_LOCALS one
wxCRASH_REPORT_GLOBALS = 4,
// default is to create the smallest possible crash report
wxCRASH_REPORT_DEFAULT = wxCRASH_REPORT_LOCATION | wxCRASH_REPORT_STACK
};
// ----------------------------------------------------------------------------
// wxCrashContext: information about the crash context
// ----------------------------------------------------------------------------
struct WXDLLIMPEXP_BASE wxCrashContext
{
// initialize this object with the given information or from the current
// global exception info which is only valid inside wxApp::OnFatalException
wxCrashContext(_EXCEPTION_POINTERS *ep = NULL);
// get the name for this exception code
wxString GetExceptionString() const;
// exception code
size_t code;
// exception address
void *addr;
// machine-specific registers vaues
struct
{
#ifdef __INTEL__
wxInt32 eax, ebx, ecx, edx, esi, edi,
ebp, esp, eip,
cs, ds, es, fs, gs, ss,
flags;
#endif // __INTEL__
} regs;
};
// ----------------------------------------------------------------------------
// wxCrashReport: this class is used to create crash reports
// ----------------------------------------------------------------------------
struct WXDLLIMPEXP_BASE wxCrashReport
{
// set the name of the file to which the report is written, it is
// constructed from the .exe name by default
static void SetFileName(const wxString& filename);
// return the current file name
static wxString GetFileName();
// write the exception report to the file, return true if it could be done
// or false otherwise
//
// if ep pointer is NULL, the global exception info which is valid only
// inside wxApp::OnFatalException() is used
static bool Generate(int flags = wxCRASH_REPORT_DEFAULT,
_EXCEPTION_POINTERS *ep = NULL);
// generate a crash report from outside of wxApp::OnFatalException(), this
// can be used to take "snapshots" of the program in wxApp::OnAssert() for
// example
static bool GenerateNow(int flags = wxCRASH_REPORT_DEFAULT);
};
#endif // wxUSE_CRASHREPORT
#endif // _WX_MSW_CRASHRPT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/menuitem.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/menuitem.h
// Purpose: wxMenuItem class
// Author: Vadim Zeitlin
// Modified by:
// Created: 11.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _MENUITEM_H
#define _MENUITEM_H
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/bitmap.h"
#if wxUSE_OWNER_DRAWN
#include "wx/ownerdrw.h"
struct tagRECT;
#endif
// ----------------------------------------------------------------------------
// wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuItem : public wxMenuItemBase
#if wxUSE_OWNER_DRAWN
, public wxOwnerDrawn
#endif
{
public:
// ctor & dtor
wxMenuItem(wxMenu *parentMenu = NULL,
int id = wxID_SEPARATOR,
const wxString& name = wxEmptyString,
const wxString& help = wxEmptyString,
wxItemKind kind = wxITEM_NORMAL,
wxMenu *subMenu = NULL);
virtual ~wxMenuItem();
// override base class virtuals
virtual void SetItemLabel(const wxString& strName) wxOVERRIDE;
virtual void Enable(bool bDoEnable = true) wxOVERRIDE;
virtual void Check(bool bDoCheck = true) wxOVERRIDE;
virtual bool IsChecked() const wxOVERRIDE;
// unfortunately needed to resolve ambiguity between
// wxMenuItemBase::IsCheckable() and wxOwnerDrawn::IsCheckable()
bool IsCheckable() const { return wxMenuItemBase::IsCheckable(); }
// the id for a popup menu is really its menu handle (as required by
// ::AppendMenu() API), so this function will return either the id or the
// menu handle depending on what we are
//
// notice that it also returns the id as an unsigned int, as required by
// Win32 API
WXWPARAM GetMSWId() const;
#if WXWIN_COMPATIBILITY_2_8
// compatibility only, don't use in new code
wxDEPRECATED(
wxMenuItem(wxMenu *parentMenu,
int id,
const wxString& text,
const wxString& help,
bool isCheckable,
wxMenu *subMenu = NULL)
);
#endif
void SetBitmaps(const wxBitmap& bmpChecked,
const wxBitmap& bmpUnchecked = wxNullBitmap)
{
DoSetBitmap(bmpChecked, true);
DoSetBitmap(bmpUnchecked, false);
}
void SetBitmap(const wxBitmap& bmp, bool bChecked = true)
{
DoSetBitmap(bmp, bChecked);
}
const wxBitmap& GetBitmap(bool bChecked = true) const
{ return (bChecked ? m_bmpChecked : m_bmpUnchecked); }
#if wxUSE_OWNER_DRAWN
void SetDisabledBitmap(const wxBitmap& bmpDisabled)
{
m_bmpDisabled = bmpDisabled;
SetOwnerDrawn(true);
}
const wxBitmap& GetDisabledBitmap() const
{ return m_bmpDisabled; }
int MeasureAccelWidth() const;
// override wxOwnerDrawn base class virtuals
virtual wxString GetName() const wxOVERRIDE;
virtual bool OnMeasureItem(size_t *pwidth, size_t *pheight) wxOVERRIDE;
virtual bool OnDrawItem(wxDC& dc, const wxRect& rc, wxODAction act, wxODStatus stat) wxOVERRIDE;
protected:
virtual void GetFontToUse(wxFont& font) const wxOVERRIDE;
virtual void GetColourToUse(wxODStatus stat, wxColour& colText, wxColour& colBack) const wxOVERRIDE;
private:
// helper function for draw std menu check mark
void DrawStdCheckMark(WXHDC hdc, const tagRECT* rc, wxODStatus stat);
// helper function to determine if the item must be owner-drawn
bool MSWMustUseOwnerDrawn();
#endif // wxUSE_OWNER_DRAWN
enum BitmapKind
{
Normal,
Checked,
Unchecked
};
// helper function to get a handle for bitmap associated with item
WXHBITMAP GetHBitmapForMenu(BitmapKind kind) const;
// helper function to set/change the bitmap
void DoSetBitmap(const wxBitmap& bmp, bool bChecked);
private:
// common part of all ctors
void Init();
// Return the item position in the menu containing it.
//
// Returns -1 if the item is not attached to a menu or if we can't find its
// position (which is not really supposed to ever happen).
int MSGetMenuItemPos() const;
// item bitmaps
wxBitmap m_bmpChecked, // bitmap to put near the item
m_bmpUnchecked; // (checked is used also for 'uncheckable' items)
#if wxUSE_OWNER_DRAWN
wxBitmap m_bmpDisabled;
#endif // wxUSE_OWNER_DRAWN
// Give wxMenu access to our MSWMustUseOwnerDrawn() and GetHBitmapForMenu().
friend class wxMenu;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuItem);
};
#endif //_MENUITEM_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ownerdrawnbutton.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ownerdrawnbutton.h
// Purpose: Common base class for wxCheckBox and wxRadioButton
// Author: Vadim Zeitlin
// Created: 2014-05-04
// Copyright: (c) 2014 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_OWNERDRAWNBUTTON_H_
#define _WX_MSW_OWNERDRAWNBUTTON_H_
// ----------------------------------------------------------------------------
// wxMSWOwnerDrawnButton: base class for any kind of Windows buttons
// ----------------------------------------------------------------------------
// This class contains the type-independent part of wxMSWOwnerDrawnButton and
// is implemented in src/msw/control.cpp.
//
// Notice that this class is internal implementation detail only and is
// intentionally not documented. Ideally it wouldn't be even exported from the
// DLL but this somehow breaks building of applications using wxWidgets with
// Intel compiler using LTCG, so we do export it.
class WXDLLIMPEXP_CORE wxMSWOwnerDrawnButtonBase
{
protected:
// Ctor takes the back pointer to the real window, must be non-NULL.
wxMSWOwnerDrawnButtonBase(wxWindow* win) :
m_win(win)
{
m_isPressed =
m_isHot = false;
}
// Explicitly define the destructor even if it's trivial to make it
// protected. This avoids compiler warnings about the fact that this class
// has virtual functions, but no virtual destructor without making the dtor
// virtual which is not needed here as objects are never deleted via
// pointers to this class (and protected dtor enforces this).
//
// Unfortunately g++ 3.4.5 still complains about the dtor being non virtual
// even if it is protected, but actually does not give any warnings if the
// dtor is not defined at all, so work around this 3.4.5 bug inside our
// general g++ workaround.
#if wxCHECK_GCC_VERSION(4, 0)
~wxMSWOwnerDrawnButtonBase() { }
#endif // g++ 4.0+
// Make the control owner drawn if necessary to implement support for the
// given foreground colour.
void MSWMakeOwnerDrawnIfNecessary(const wxColour& colFg);
// Return true if the control is currently owner drawn.
bool MSWIsOwnerDrawn() const;
// Draw the button if the message information about which is provided in
// the given DRAWITEMSTRUCT asks us to do it, otherwise just return false.
bool MSWDrawButton(WXDRAWITEMSTRUCT *item);
// Methods which must be overridden in the derived concrete class.
// Return the style to use for the non-owner-drawn button.
virtual int MSWGetButtonStyle() const = 0;
// Called after reverting button to non-owner drawn state, provides a hook
// for wxCheckBox-specific hack.
virtual void MSWOnButtonResetOwnerDrawn() { }
// Return the flags (such as wxCONTROL_CHECKED) to use for the control when
// drawing it. Notice that this class already takes care of the common
// logic and sets the other wxCONTROL_XXX flags on its own, this method
// really only needs to return the flags depending on the checked state.
virtual int MSWGetButtonCheckedFlag() const = 0;
// Actually draw the check or radio bitmap, typically just by using the
// appropriate wxRendererNative method.
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) = 0;
private:
// Make the control owner drawn or reset it to normal style.
void MSWMakeOwnerDrawn(bool ownerDrawn);
// Event handlers used to update the appearance of owner drawn button.
void OnMouseEnterOrLeave(wxMouseEvent& event);
void OnMouseLeft(wxMouseEvent& event);
void OnFocus(wxFocusEvent& event);
// The real window.
wxWindow* const m_win;
// true if the checkbox is currently pressed
bool m_isPressed;
// true if mouse is currently over the control
bool m_isHot;
wxDECLARE_NO_COPY_CLASS(wxMSWOwnerDrawnButtonBase);
};
// This class uses a weak version of CRTP, i.e. it's a template class taking
// the base class that the class deriving from it would normally derive from.
template <class T>
class wxMSWOwnerDrawnButton
: public T,
private wxMSWOwnerDrawnButtonBase
{
private:
typedef T Base;
public:
wxMSWOwnerDrawnButton() : wxMSWOwnerDrawnButtonBase(this)
{
}
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE
{
if ( !Base::SetForegroundColour(colour) )
return false;
MSWMakeOwnerDrawnIfNecessary(colour);
return true;
}
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE
{
return MSWDrawButton(item) || Base::MSWOnDraw(item);
}
protected:
bool IsOwnerDrawn() const { return MSWIsOwnerDrawn(); }
};
#endif // _WX_MSW_OWNERDRAWNBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/panel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/panel.h
// Purpose: wxMSW-specific wxPanel class.
// Author: Vadim Zeitlin
// Created: 2011-03-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PANEL_H_
#define _WX_MSW_PANEL_H_
class WXDLLIMPEXP_FWD_CORE wxBrush;
// ----------------------------------------------------------------------------
// wxPanel
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPanel : public wxPanelBase
{
public:
wxPanel() { }
wxPanel(wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, winid, pos, size, style, name);
}
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR(
wxPanel(wxWindow *parent,
int x, int y, int width, int height,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, wxID_ANY, wxPoint(x, y), wxSize(width, height), style, name);
}
)
#endif // WXWIN_COMPATIBILITY_2_8
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxPanel);
};
#endif // _WX_MSW_PANEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/calctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/calctrl.h
// Purpose: wxCalendarCtrl control implementation for MSW
// Author: Vadim Zeitlin
// Copyright: (C) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CALCTRL_H_
#define _WX_MSW_CALCTRL_H_
class WXDLLIMPEXP_ADV wxCalendarCtrl : public wxCalendarCtrlBase
{
public:
wxCalendarCtrl() { Init(); }
wxCalendarCtrl(wxWindow *parent,
wxWindowID id,
const wxDateTime& date = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAL_SHOW_HOLIDAYS,
const wxString& name = wxCalendarNameStr)
{
Init();
Create(parent, id, date, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxDateTime& date = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAL_SHOW_HOLIDAYS,
const wxString& name = wxCalendarNameStr);
virtual bool SetDate(const wxDateTime& date) wxOVERRIDE;
virtual wxDateTime GetDate() const wxOVERRIDE;
virtual bool SetDateRange(const wxDateTime& lowerdate = wxDefaultDateTime,
const wxDateTime& upperdate = wxDefaultDateTime) wxOVERRIDE;
virtual bool GetDateRange(wxDateTime *lowerdate, wxDateTime *upperdate) const wxOVERRIDE;
virtual bool EnableMonthChange(bool enable = true) wxOVERRIDE;
virtual void Mark(size_t day, bool mark) wxOVERRIDE;
virtual void SetHoliday(size_t day) wxOVERRIDE;
virtual wxCalendarHitTestResult HitTest(const wxPoint& pos,
wxDateTime *date = NULL,
wxDateTime::WeekDay *wd = NULL) wxOVERRIDE;
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
void MSWOnClick(wxMouseEvent& event);
void MSWOnDoubleClick(wxMouseEvent& event);
private:
void Init();
// bring the control in sync with m_marks
void UpdateMarks();
// set first day of week in the control to correspond to our
// wxCAL_MONDAY_FIRST flag
void UpdateFirstDayOfWeek();
// reset holiday information
virtual void ResetHolidayAttrs() wxOVERRIDE { m_holidays = 0; }
// redisplay holidays
virtual void RefreshHolidays() wxOVERRIDE { UpdateMarks(); }
// current date, we need to store it instead of simply retrieving it from
// the control as needed in order to be able to generate the correct events
// from MSWOnNotify()
wxDateTime m_date;
// bit field containing the state (marked or not) of all days in the month
wxUint32 m_marks;
// the same but indicating whether a day is a holiday or not
wxUint32 m_holidays;
wxDECLARE_DYNAMIC_CLASS(wxCalendarCtrl);
wxDECLARE_NO_COPY_CLASS(wxCalendarCtrl);
};
#endif // _WX_MSW_CALCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/wrapcdlg.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapcdlg.h
// Purpose: Wrapper for the standard <commdlg.h> header
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 22.03.2005
// Copyright: (c) 2005 Wlodzimierz Skiba
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WRAPCDLG_H_
#define _WX_MSW_WRAPCDLG_H_
#include "wx/defs.h"
#include "wx/msw/wrapwin.h"
#include "wx/msw/private.h"
#include "wx/msw/missing.h"
#if wxUSE_COMMON_DIALOGS
#include <commdlg.h>
#endif
#include "wx/msw/winundef.h"
#endif // _WX_MSW_WRAPCDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/toolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/toolbar.h
// Purpose: wxToolBar class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TBAR95_H_
#define _WX_MSW_TBAR95_H_
#if wxUSE_TOOLBAR
#include "wx/dynarray.h"
#include "wx/imaglist.h"
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
// ctors and dtor
wxToolBar() { Init(); }
wxToolBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr);
virtual ~wxToolBar();
// override/implement base class virtuals
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
virtual void SetToolBitmapSize(const wxSize& size) wxOVERRIDE;
virtual wxSize GetToolSize() const wxOVERRIDE;
virtual void SetRows(int nRows) wxOVERRIDE;
virtual void SetToolNormalBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolDisabledBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolPacking(int packing) wxOVERRIDE;
// implementation only from now on
// -------------------------------
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
void OnMouseEvent(wxMouseEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
void OnEraseBackground(wxEraseEvent& event);
void SetFocus() wxOVERRIDE {}
static WXHBITMAP MapBitmap(WXHBITMAP bitmap, int width, int height);
// override WndProc mainly to process WM_SIZE
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
virtual bool MSWEraseBgHook(WXHDC hDC) wxOVERRIDE;
virtual WXHBRUSH MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child) wxOVERRIDE;
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled = wxNullBitmap,
wxItemKind kind = wxITEM_NORMAL,
wxObject *clientData = NULL,
const wxString& shortHelp = wxEmptyString,
const wxString& longHelp = wxEmptyString) wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// create the native toolbar control
bool MSWCreateToolbar(const wxPoint& pos, const wxSize& size);
// recreate the control completely
void Recreate();
// implement base class pure virtuals
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) wxOVERRIDE;
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
// return the appropriate size and flags for the toolbar control
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// handlers for various events
bool HandleSize(WXWPARAM wParam, WXLPARAM lParam);
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
bool HandlePaint(WXWPARAM wParam, WXLPARAM lParam);
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
void HandleMouseMove(WXWPARAM wParam, WXLPARAM lParam);
// should be called whenever the toolbar size changes
void UpdateSize();
// create m_disabledImgList (but doesn't fill it), set it to NULL if it is
// unneeded
void CreateDisabledImageList();
// get the Windows toolbar style of this control
long GetMSWToolbarStyle() const;
// set native toolbar padding
void MSWSetPadding(WXWORD padding);
// the big bitmap containing all bitmaps of the toolbar buttons
WXHBITMAP m_hBitmap;
// the image list with disabled images, may be NULL if we use
// system-provided versions of them
wxImageList *m_disabledImgList;
// the total number of toolbar elements
size_t m_nButtons;
// the sum of the sizes of the fixed items (i.e. excluding stretchable
// spaces) in the toolbar direction
int m_totalFixedSize;
// the tool the cursor is in
wxToolBarToolBase *m_pInTool;
private:
// makes sure tool bitmap size is sufficient for all tools
void AdjustToolBitmapSize();
// update the sizes of stretchable spacers to consume all extra space we
// have
void UpdateStretchableSpacersSize();
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
// do erase the toolbar background, always do it for the entire control as
// the caller sets the clipping region correctly to exclude parts which
// should not be erased
void MSWDoEraseBackground(WXHDC hDC);
// return the brush to use for erasing the toolbar background
WXHBRUSH MSWGetToolbarBgBrush();
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
wxDECLARE_NO_COPY_CLASS(wxToolBar);
};
#endif // wxUSE_TOOLBAR
#endif // _WX_MSW_TBAR95_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/helpchm.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpchm.h
// Purpose: Help system: MS HTML Help implementation
// Author: Julian Smart
// Modified by:
// Created: 16/04/2000
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_HELPCHM_H_
#define _WX_MSW_HELPCHM_H_
#if wxUSE_MS_HTML_HELP
#include "wx/helpbase.h"
class WXDLLIMPEXP_CORE wxCHMHelpController : public wxHelpControllerBase
{
public:
wxCHMHelpController(wxWindow* parentWindow = NULL): wxHelpControllerBase(parentWindow) { }
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE;
virtual bool DisplayContents() wxOVERRIDE;
virtual bool DisplaySection(int sectionNo) wxOVERRIDE;
virtual bool DisplaySection(const wxString& section) wxOVERRIDE;
virtual bool DisplayBlock(long blockNo) wxOVERRIDE;
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE;
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos) wxOVERRIDE;
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE;
virtual bool Quit() wxOVERRIDE;
wxString GetHelpFile() const { return m_helpFile; }
// helper of DisplayTextPopup(), also used in wxSimpleHelpProvider::ShowHelp
static bool ShowContextHelpPopup(const wxString& text,
const wxPoint& pos,
wxWindow *window);
protected:
// get the name of the CHM file we use from our m_helpFile
wxString GetValidFilename() const;
// Call HtmlHelp() with the provided parameters (both overloads do the same
// thing but allow to avoid casts in the calling code) and return false
// (but don't crash) if HTML help is unavailable
static bool CallHtmlHelp(wxWindow *win, const wxChar *str,
unsigned cmd, WXWPARAM param);
static bool CallHtmlHelp(wxWindow *win, const wxChar *str,
unsigned cmd, const void *param = NULL)
{
return CallHtmlHelp(win, str, cmd, reinterpret_cast<WXWPARAM>(param));
}
// even simpler wrappers using GetParentWindow() and GetValidFilename() as
// the first 2 HtmlHelp() parameters
bool CallHtmlHelp(unsigned cmd, WXWPARAM param)
{
return CallHtmlHelp(GetParentWindow(), GetValidFilename().t_str(),
cmd, param);
}
bool CallHtmlHelp(unsigned cmd, const void *param = NULL)
{
return CallHtmlHelp(cmd, reinterpret_cast<WXWPARAM>(param));
}
// wrapper around CallHtmlHelp(HH_DISPLAY_TEXT_POPUP): only one of text and
// contextId parameters can be non-NULL/non-zero
static bool DoDisplayTextPopup(const wxChar *text,
const wxPoint& pos,
int contextId,
wxWindow *window);
wxString m_helpFile;
wxDECLARE_DYNAMIC_CLASS(wxCHMHelpController);
};
#endif // wxUSE_MS_HTML_HELP
#endif // _WX_MSW_HELPCHM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/gauge.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/gauge.h
// Purpose: wxGauge implementation for MSW
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_GAUGE_H_
#define _WX_MSW_GAUGE_H_
#if wxUSE_GAUGE
extern WXDLLIMPEXP_DATA_CORE(const char) wxGaugeNameStr[];
// Group box
class WXDLLIMPEXP_CORE wxGauge : public wxGaugeBase
{
public:
wxGauge() { }
wxGauge(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr)
{
(void)Create(parent, id, range, pos, size, style, validator, name);
}
virtual ~wxGauge();
bool Create(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr);
// set gauge range/value
virtual void SetRange(int range) wxOVERRIDE;
virtual void SetValue(int pos) wxOVERRIDE;
// overridden base class virtuals
virtual bool SetForegroundColour(const wxColour& col) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& col) wxOVERRIDE;
virtual void Pulse() wxOVERRIDE;
WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
private:
// returns true if the control is currently in indeterminate (a.k.a.
// "marquee") mode
bool IsInIndeterminateMode() const;
// switch to/from indeterminate mode
void SetIndeterminateMode();
void SetDeterminateMode();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxGauge);
};
#endif // wxUSE_GAUGE
#endif // _WX_MSW_GAUGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/spinctrl.h | ////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/spinctrl.h
// Purpose: wxSpinCtrl class declaration for Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 22.07.99
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_SPINCTRL_H_
#define _WX_MSW_SPINCTRL_H_
#include "wx/spinbutt.h" // the base class
#if wxUSE_SPINCTRL
#include "wx/dynarray.h"
class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
WX_DEFINE_EXPORTED_ARRAY_PTR(wxSpinCtrl *, wxArraySpins);
// ----------------------------------------------------------------------------
// Under Win32, wxSpinCtrl is a wxSpinButton with a buddy (as MSDN docs call
// it) text window whose contents is automatically updated when the spin
// control is clicked.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSpinCtrl : public wxSpinButton
{
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 = wxT("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 = wxT("wxSpinCtrl"));
// a wxTextCtrl-like method (but we can't have GetValue returning wxString
// because the base class already has one returning int!)
void SetValue(const wxString& text);
// another wxTextCtrl-like method
void SetSelection(long from, long to);
// wxSpinCtrlBase methods
virtual int GetBase() const;
virtual bool SetBase(int base);
// implementation only from now on
// -------------------------------
virtual ~wxSpinCtrl();
virtual void SetValue(int val) wxOVERRIDE;
virtual int GetValue() const wxOVERRIDE;
virtual void SetRange(int minVal, int maxVal) wxOVERRIDE;
virtual bool SetFont(const wxFont &font) wxOVERRIDE;
virtual void SetFocus() wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Reparent(wxWindowBase *newParent) wxOVERRIDE;
// wxSpinButton doesn't accept focus, but we do
virtual bool AcceptsFocus() const wxOVERRIDE { return wxWindow::AcceptsFocus(); }
// we're like wxTextCtrl and not (default) wxButton
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL)
{
return GetCompositeControlsDefaultAttributes(variant);
}
// for internal use only
// get the subclassed window proc of the buddy text
WXWNDPROC GetBuddyWndProc() const { return m_wndProcBuddy; }
// return the spinctrl object whose buddy is the given window or NULL
static wxSpinCtrl *GetSpinForTextCtrl(WXHWND hwndBuddy);
// process a WM_COMMAND generated by the buddy text control
bool ProcessTextCommand(WXWORD cmd, WXWORD id);
// recognize buddy window as part of this control at wx level
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE { return hWnd == m_hwndBuddy; }
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
protected:
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void DoGetClientSize(int *x, int *y) const wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE;
#endif // wxUSE_TOOLTIPS
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
// handle processing of special keys
void OnChar(wxKeyEvent& event);
void OnSetFocus(wxFocusEvent& event);
void OnKillFocus(wxFocusEvent& event);
// generate spin control update event with the given value
void SendSpinUpdate(int value);
// called to ensure that the value is in the correct range
virtual void NormalizeValue() wxOVERRIDE;
// the value of the control before the latest change (which might not have
// changed anything in fact -- this is why we need this field)
int m_oldValue;
// the data for the "buddy" text ctrl
WXHWND m_hwndBuddy;
WXWNDPROC m_wndProcBuddy;
// Block text update event after SetValue()
bool m_blockEvent;
private:
// Common part of all ctors.
void Init();
// Adjust the text control style depending on whether we need to enter only
// digits or may need to enter something else (e.g. "-" sign, "x"
// hexadecimal prefix, ...) in it.
void UpdateBuddyStyle();
// Determine the (horizontal) pixel overlap between the spin button
// (up-down control) and the text control (buddy window).
int GetOverlap() const;
wxDECLARE_DYNAMIC_CLASS(wxSpinCtrl);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxSpinCtrl);
};
#endif // wxUSE_SPINCTRL
#endif // _WX_MSW_SPINCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/region.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/region.h
// Purpose: wxRegion class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) 1997-2002 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_REGION_H_
#define _WX_MSW_REGION_H_
class WXDLLIMPEXP_CORE wxRegion : public wxRegionWithCombine
{
public:
wxRegion();
wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
wxRegion(const wxRect& rect);
wxRegion(WXHRGN hRegion); // Hangs on to this region
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;
// Get internal region handle
WXHRGN GetHRGN() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
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 DoCombine(const wxRegion& region, wxRegionOp op) wxOVERRIDE;
friend class WXDLLIMPEXP_FWD_CORE wxRegionIterator;
wxDECLARE_DYNAMIC_CLASS(wxRegion);
};
class WXDLLIMPEXP_CORE wxRegionIterator : public wxObject
{
public:
wxRegionIterator() { Init(); }
wxRegionIterator(const wxRegion& region);
wxRegionIterator(const wxRegionIterator& ri) : wxObject(ri) { Init(); *this = ri; }
wxRegionIterator& operator=(const wxRegionIterator& ri);
virtual ~wxRegionIterator();
void Reset() { m_current = 0; }
void Reset(const wxRegion& region);
bool HaveRects() const { return (m_current < m_numRects); }
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 { return wxRect(GetX(), GetY(), GetW(), GetH()); }
private:
// common part of all ctors
void Init();
long m_current;
long m_numRects;
wxRegion m_region;
wxRect* m_rects;
wxDECLARE_DYNAMIC_CLASS(wxRegionIterator);
};
#endif // _WX_MSW_REGION_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/init.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/init.h
// Purpose: Windows-specific wxEntry() overload
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_INIT_H_
#define _WX_MSW_INIT_H_
// ----------------------------------------------------------------------------
// Windows-specific wxEntry() overload and wxIMPLEMENT_WXWIN_MAIN definition
// ----------------------------------------------------------------------------
// wxEntry() overload using the command line for the current process, instead
// of argc/argv provided by the CRT. This is only really useful when using
// Unicode with a compiler not providing wmain() or similar entry point, but is
// always provided for consistency.
extern int WXDLLIMPEXP_BASE wxEntry();
#if wxUSE_GUI
// we need HINSTANCE declaration to define WinMain()
#include "wx/msw/wrapwin.h"
#ifndef SW_SHOWNORMAL
#define SW_SHOWNORMAL 1
#endif
// WinMain() is always ANSI, even in Unicode build.
typedef char *wxCmdLineArgType;
// Windows-only overloads of wxEntry() and wxEntryStart() which take the
// parameters passed to WinMain() instead of those passed to main()
extern WXDLLIMPEXP_CORE bool
wxEntryStart(HINSTANCE hInstance,
HINSTANCE hPrevInstance = NULL,
wxCmdLineArgType pCmdLine = NULL,
int nCmdShow = SW_SHOWNORMAL);
extern WXDLLIMPEXP_CORE int
wxEntry(HINSTANCE hInstance,
HINSTANCE hPrevInstance = NULL,
wxCmdLineArgType pCmdLine = NULL,
int nCmdShow = SW_SHOWNORMAL);
#if defined(__BORLANDC__) && wxUSE_UNICODE
// Borland C++ has the following nonstandard behaviour: when the -WU
// command line flag is used, the linker expects to find wWinMain instead
// of WinMain. This flag causes the compiler to define _UNICODE and
// UNICODE symbols and there's no way to detect its use, so we have to
// define both WinMain and wWinMain so that wxIMPLEMENT_WXWIN_MAIN works
// for both code compiled with and without -WU.
// See http://sourceforge.net/tracker/?func=detail&atid=309863&aid=1935997&group_id=9863
// for more details.
#define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD \
extern "C" int WINAPI wWinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \
wchar_t * WXUNUSED(lpCmdLine), \
int nCmdShow) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
\
/* NB: wxEntry expects lpCmdLine argument to be char*, not */ \
/* wchar_t*, but fortunately it's not used anywhere */ \
/* and we can simply pass NULL in: */ \
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
}
#else
#define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // defined(__BORLANDC__) && wxUSE_UNICODE
#define wxIMPLEMENT_WXWIN_MAIN \
extern "C" int WINAPI WinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \
wxCmdLineArgType WXUNUSED(lpCmdLine), \
int nCmdShow) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
\
/* NB: We pass NULL in place of lpCmdLine to behave the same as */ \
/* Borland-specific wWinMain() above. If it becomes needed */ \
/* to pass lpCmdLine to wxEntry() here, you'll have to fix */ \
/* wWinMain() above too. */ \
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
} \
wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // wxUSE_GUI
#endif // _WX_MSW_INIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/datectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/datectrl.h
// Purpose: wxDatePickerCtrl for Windows
// Author: Vadim Zeitlin
// Modified by:
// Created: 2005-01-09
// Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DATECTRL_H_
#define _WX_MSW_DATECTRL_H_
// ----------------------------------------------------------------------------
// wxDatePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDatePickerCtrl : public wxDatePickerCtrlBase
{
public:
// ctors
wxDatePickerCtrl() { }
wxDatePickerCtrl(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDP_DEFAULT | wxDP_SHOWCENTURY,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxDatePickerCtrlNameStr)
{
Create(parent, id, dt, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDP_DEFAULT | wxDP_SHOWCENTURY,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxDatePickerCtrlNameStr);
// Override this one to add date-specific (and time-ignoring) checks.
virtual void SetValue(const wxDateTime& dt) wxOVERRIDE;
virtual wxDateTime GetValue() const wxOVERRIDE;
// Implement the base class pure virtuals.
virtual void SetRange(const wxDateTime& dt1, const wxDateTime& dt2) wxOVERRIDE;
virtual bool GetRange(wxDateTime *dt1, wxDateTime *dt2) const wxOVERRIDE;
// Override MSW-specific functions used during control creation.
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
#if wxUSE_INTL
virtual wxLocaleInfo MSWGetFormat() const wxOVERRIDE;
#endif // wxUSE_INTL
virtual bool MSWAllowsNone() const wxOVERRIDE { return HasFlag(wxDP_ALLOWNONE); }
virtual bool MSWOnDateTimeChange(const tagNMDATETIMECHANGE& dtch) wxOVERRIDE;
private:
wxDateTime MSWGetControlValue() const;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDatePickerCtrl);
};
#endif // _WX_MSW_DATECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/winver.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/winver.h
// Purpose: Define Windows version macros if they're not predefined.
// Author: Vadim Zeitlin
// Created: 2017-01-13 (extracted from wx/msw/wrapwin.h)
// Copyright: (c) 2017 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WINVER_H_
#define _WX_MSW_WINVER_H_
// Notice that this header must not include any other wx headers as it's
// indirectly included from wx/defs.h itself when using gcc (via wx/platform.h,
// then wx/compiler.h and wx/msw/gccpriv.h).
// Define WINVER, _WIN32_WINNT and _WIN32_IE to the highest possible values
// because we always check for the version of installed DLLs at runtime anyway
// (see wxGetWinVersion() and wxApp::GetComCtl32Version()) unless the user
// really doesn't want to use APIs only available on later OS versions and had
// defined them to (presumably lower) values -- or, alternatively, wants to use
// even higher version of the API which will become available later.
#ifndef WINVER
#define WINVER 0x0A00
#endif
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#endif
#ifndef _WIN32_IE
#define _WIN32_IE 0x0A00
#endif
#endif // _WX_MSW_WINVER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/evtloop.h
// Purpose: wxEventLoop class for wxMSW port
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-07-31
// Copyright: (c) 2003-2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_EVTLOOP_H_
#define _WX_MSW_EVTLOOP_H_
#include "wx/dynarray.h"
#include "wx/msw/wrapwin.h"
#include "wx/window.h"
#include "wx/msw/evtloopconsole.h" // for wxMSWEventLoopBase
// ----------------------------------------------------------------------------
// wxEventLoop
// ----------------------------------------------------------------------------
WX_DECLARE_EXPORTED_OBJARRAY(MSG, wxMSGArray);
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxMSWEventLoopBase
{
public:
wxGUIEventLoop() { }
// process a single message: calls PreProcessMessage() before dispatching
// it
virtual void ProcessMessage(WXMSG *msg);
// preprocess a message, return true if processed (i.e. no further
// dispatching required)
virtual bool PreProcessMessage(WXMSG *msg);
// set the critical window: this is the window such that all the events
// except those to this window (and its children) stop to be processed
// (typical examples: assert or crash report dialog)
//
// calling this function with NULL argument restores the normal event
// handling
static void SetCriticalWindow(wxWindowMSW *win) { ms_winCritical = win; }
// return true if there is no critical window or if this window is [a child
// of] the critical one
static bool AllowProcessing(wxWindowMSW *win)
{
return !ms_winCritical || IsChildOfCriticalWindow(win);
}
// override/implement base class virtuals
virtual bool Dispatch() wxOVERRIDE;
virtual int DispatchTimeout(unsigned long timeout) wxOVERRIDE;
protected:
virtual void OnNextIteration() wxOVERRIDE;
virtual void DoYieldFor(long eventsToProcess) wxOVERRIDE;
private:
// check if the given window is a child of ms_winCritical (which must be
// non NULL)
static bool IsChildOfCriticalWindow(wxWindowMSW *win);
// array of messages used for temporary storage by YieldFor()
wxMSGArray m_arrMSG;
// critical window or NULL
static wxWindowMSW *ms_winCritical;
};
#endif // _WX_MSW_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/palette.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/palette.h
// Purpose: wxPalette class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PALETTE_H_
#define _WX_PALETTE_H_
#include "wx/gdiobj.h"
class WXDLLIMPEXP_CORE wxPalette : public wxPaletteBase
{
public:
wxPalette() { }
wxPalette(int n,
const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
Create(n, red, green, blue);
}
bool Create(int n,
const unsigned char *red, const unsigned char *green, const unsigned char *blue);
virtual int GetColoursCount() const wxOVERRIDE;
int
GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
bool
GetRGB(int pixel,
unsigned char *red, unsigned char *green, unsigned char *blue) const;
// implementation
WXHPALETTE GetHPALETTE() const;
void SetHPALETTE(WXHPALETTE pal);
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxPalette);
};
#endif // _WX_PALETTE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/menu.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/menu.h
// Purpose: wxMenu, wxMenuBar classes
// Author: Julian Smart
// Modified by: Vadim Zeitlin (wxMenuItem is now in separate file)
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MENU_H_
#define _WX_MENU_H_
#if wxUSE_ACCEL
#include "wx/accel.h"
#include "wx/dynarray.h"
WX_DEFINE_EXPORTED_ARRAY_PTR(wxAcceleratorEntry *, wxAcceleratorArray);
#endif // wxUSE_ACCEL
class WXDLLIMPEXP_FWD_CORE wxFrame;
class wxMenuRadioItemsData;
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// Menu
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenu : public wxMenuBase
{
public:
// ctors & dtor
wxMenu(const wxString& title, long style = 0)
: wxMenuBase(title, style) { Init(); }
wxMenu(long style = 0) : wxMenuBase(style) { Init(); }
virtual ~wxMenu();
virtual void Break() wxOVERRIDE;
virtual void SetTitle(const wxString& title) wxOVERRIDE;
// MSW-only methods
// ----------------
// Create a new menu from the given native HMENU. Takes ownership of the
// menu handle and will delete it when this object is destroyed.
static wxMenu *MSWNewFromHMENU(WXHMENU hMenu) { return new wxMenu(hMenu); }
// Detaches HMENU so that it isn't deleted when this object is destroyed.
// Don't use this object after calling this method.
WXHMENU MSWDetachHMENU() { WXHMENU m = m_hMenu; m_hMenu = NULL; return m; }
// implementation only from now on
// -------------------------------
bool MSWCommand(WXUINT param, WXWORD id);
// get the native menu handle
WXHMENU GetHMenu() const { return m_hMenu; }
// Return the start and end position of the radio group to which the item
// at the given position belongs. Returns false if there is no radio group
// containing this position.
bool MSWGetRadioGroupRange(int pos, int *start, int *end) const;
#if wxUSE_ACCEL
// called by wxMenuBar to build its accel table from the accels of all menus
bool HasAccels() const { return !m_accels.empty(); }
size_t GetAccelCount() const { return m_accels.size(); }
size_t CopyAccels(wxAcceleratorEntry *accels) const;
// called by wxMenuItem when its accels changes
void UpdateAccel(wxMenuItem *item);
void RemoveAccel(wxMenuItem *item);
// helper used by wxMenu itself (returns the index in m_accels)
int FindAccel(int id) const;
// used only by wxMDIParentFrame currently but could be useful elsewhere:
// returns a new accelerator table with accelerators for just this menu
// (shouldn't be called if we don't have any accelerators)
wxAcceleratorTable *CreateAccelTable() const;
#endif // wxUSE_ACCEL
// get the menu with given handle (recursively)
wxMenu* MSWGetMenu(WXHMENU hMenu);
#if wxUSE_OWNER_DRAWN
int GetMaxAccelWidth()
{
if (m_maxAccelWidth == -1)
CalculateMaxAccelWidth();
return m_maxAccelWidth;
}
void ResetMaxAccelWidth()
{
m_maxAccelWidth = -1;
}
private:
void CalculateMaxAccelWidth();
#endif // wxUSE_OWNER_DRAWN
protected:
virtual wxMenuItem* DoAppend(wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoInsert(size_t pos, wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoRemove(wxMenuItem *item) wxOVERRIDE;
private:
// This constructor is private, use MSWNewFromHMENU() to use it.
wxMenu(WXHMENU hMenu);
// Common part of all ctors, it doesn't create a new HMENU.
void InitNoCreate();
// Common part of all ctors except of the one above taking a native menu
// handler: calls InitNoCreate() and also creates a new menu.
void Init();
// common part of Append/Insert (behaves as Append is pos == (size_t)-1)
bool DoInsertOrAppend(wxMenuItem *item, size_t pos = (size_t)-1);
// This variable contains the description of the radio item groups and
// allows to find whether an item at the given position is part of the
// group and also where its group starts and ends.
//
// It is initially NULL and only allocated if we have any radio items.
wxMenuRadioItemsData *m_radioData;
// if true, insert a breal before appending the next item
bool m_doBreak;
// the menu handle of this menu
WXHMENU m_hMenu;
#if wxUSE_ACCEL
// the accelerators for our menu items
wxAcceleratorArray m_accels;
#endif // wxUSE_ACCEL
#if wxUSE_OWNER_DRAWN
// true if the menu has any ownerdrawn items
bool m_ownerDrawn;
// the max width of menu items bitmaps
int m_maxBitmapWidth;
// the max width of menu items accels
int m_maxAccelWidth;
#endif // wxUSE_OWNER_DRAWN
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenu);
};
// ----------------------------------------------------------------------------
// Menu Bar (a la Windows)
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuBar : public wxMenuBarBase
{
public:
// ctors & dtor
// default constructor
wxMenuBar();
// unused under MSW
wxMenuBar(long style);
// menubar takes ownership of the menus arrays but copies the titles
wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style = 0);
virtual ~wxMenuBar();
// menubar construction
virtual bool Append( wxMenu *menu, const wxString &title ) wxOVERRIDE;
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Remove(size_t pos) wxOVERRIDE;
virtual void EnableTop( size_t pos, bool 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;
// implementation from now on
WXHMENU Create();
virtual void Detach() wxOVERRIDE;
virtual void Attach(wxFrame *frame) wxOVERRIDE;
#if wxUSE_ACCEL
// update the accel table (must be called after adding/deleting a menu)
void RebuildAccelTable();
#endif // wxUSE_ACCEL
// get the menu handle
WXHMENU GetHMenu() const { return m_hMenu; }
// if the menubar is modified, the display is not updated automatically,
// call this function to update it (m_menuBarFrame should be !NULL)
void Refresh();
// To avoid compile warning
void Refresh( bool eraseBackground,
const wxRect *rect = (const wxRect *) NULL ) wxOVERRIDE { wxWindow::Refresh(eraseBackground, rect); }
// Get a top level menu position or wxNOT_FOUND from its handle.
int MSWGetTopMenuPos(WXHMENU hMenu) const;
// Get a top level or sub menu with given handle (recursively).
wxMenu* MSWGetMenu(WXHMENU hMenu) const;
protected:
// common part of all ctors
void Init();
WXHMENU m_hMenu;
// Return the MSW position for a wxMenu which is sometimes different from
// the wxWidgets position.
int MSWPositionForWxMenu(wxMenu *menu, int wxpos);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuBar);
};
#endif // _WX_MENU_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/colour.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/colour.h
// Purpose: wxColour class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COLOUR_H_
#define _WX_COLOUR_H_
#include "wx/object.h"
// ----------------------------------------------------------------------------
// Colour
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxColour : public wxColourBase
{
public:
// constructors
// ------------
DEFINE_STD_WXCOLOUR_CONSTRUCTORS
// accessors
// ---------
virtual bool IsOk() const wxOVERRIDE { return m_isInit; }
unsigned char Red() const wxOVERRIDE { return m_red; }
unsigned char Green() const wxOVERRIDE { return m_green; }
unsigned char Blue() const wxOVERRIDE { return m_blue; }
unsigned char Alpha() const wxOVERRIDE { return m_alpha ; }
// comparison
bool operator==(const wxColour& colour) const
{
return m_isInit == colour.m_isInit
&& m_red == colour.m_red
&& m_green == colour.m_green
&& m_blue == colour.m_blue
&& m_alpha == colour.m_alpha;
}
bool operator!=(const wxColour& colour) const { return !(*this == colour); }
WXCOLORREF GetPixel() const { return m_pixel; }
public:
WXCOLORREF m_pixel;
protected:
// Helper function
void Init();
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) wxOVERRIDE;
private:
bool m_isInit;
unsigned char m_red;
unsigned char m_blue;
unsigned char m_green;
unsigned char m_alpha;
private:
wxDECLARE_DYNAMIC_CLASS(wxColour);
};
#endif // _WX_COLOUR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/checkbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/checkbox.h
// Purpose: wxCheckBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHECKBOX_H_
#define _WX_CHECKBOX_H_
#include "wx/msw/ownerdrawnbutton.h"
// Checkbox item (single checkbox)
class WXDLLIMPEXP_CORE wxCheckBox : public wxMSWOwnerDrawnButton<wxCheckBoxBase>
{
public:
wxCheckBox() { }
wxCheckBox(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
virtual void SetValue(bool value) wxOVERRIDE;
virtual bool GetValue() const wxOVERRIDE;
// override some base class virtuals
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
// implementation only from now on
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoSet3StateValue(wxCheckBoxState value) wxOVERRIDE;
virtual wxCheckBoxState DoGet3StateValue() const wxOVERRIDE;
// Implement wxMSWOwnerDrawnButtonBase methods.
virtual int MSWGetButtonStyle() const wxOVERRIDE;
virtual void MSWOnButtonResetOwnerDrawn() wxOVERRIDE;
virtual int MSWGetButtonCheckedFlag() const wxOVERRIDE;
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) wxOVERRIDE;
private:
// common part of all ctors
void Init();
// current state of the checkbox
wxCheckBoxState m_state;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckBox);
};
#endif // _WX_CHECKBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/bmpbuttn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/bmpbuttn.h
// Purpose: wxBitmapButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BMPBUTTN_H_
#define _WX_BMPBUTTN_H_
#include "wx/button.h"
#include "wx/bitmap.h"
#include "wx/brush.h"
class WXDLLIMPEXP_CORE wxBitmapButton : public wxBitmapButtonBase
{
public:
wxBitmapButton() {}
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
protected:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxBitmapButton);
};
#endif // _WX_BMPBUTTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/custombgwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/custombgwin.h
// Purpose: wxMSW implementation of wxCustomBackgroundWindow
// Author: Vadim Zeitlin
// Created: 2011-10-10
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CUSTOMBGWIN_H_
#define _WX_MSW_CUSTOMBGWIN_H_
#include "wx/bitmap.h"
#include "wx/brush.h"
// ----------------------------------------------------------------------------
// wxCustomBackgroundWindow
// ----------------------------------------------------------------------------
template <class W>
class wxCustomBackgroundWindow : public W,
public wxCustomBackgroundWindowBase
{
public:
typedef W BaseWindowClass;
wxCustomBackgroundWindow() { m_backgroundBrush = NULL; }
virtual ~wxCustomBackgroundWindow() { delete m_backgroundBrush; }
protected:
virtual void DoSetBackgroundBitmap(const wxBitmap& bmp) wxOVERRIDE
{
delete m_backgroundBrush;
m_backgroundBrush = bmp.IsOk() ? new wxBrush(bmp) : NULL;
// Our transparent children should use our background if we have it,
// otherwise try to restore m_inheritBgCol to some reasonable value: true
// if we also have non-default background colour or false otherwise.
BaseWindowClass::m_inheritBgCol = bmp.IsOk()
|| BaseWindowClass::UseBgCol();
}
virtual WXHBRUSH MSWGetCustomBgBrush() wxOVERRIDE
{
if ( m_backgroundBrush )
return (WXHBRUSH)m_backgroundBrush->GetResourceHandle();
return BaseWindowClass::MSWGetCustomBgBrush();
}
wxBrush *m_backgroundBrush;
wxDECLARE_NO_COPY_TEMPLATE_CLASS(wxCustomBackgroundWindow, W);
};
#endif // _WX_MSW_CUSTOMBGWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/taskbarbutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/taskbarbutton.h
// Purpose: Defines wxTaskBarButtonImpl class.
// Author: Chaobin Zhang <[email protected]>
// Created: 2014-06-01
// Copyright: (c) 2014 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TASKBARBUTTON_H_
#define _WX_MSW_TASKBARBUTTON_H_
#include "wx/defs.h"
#if wxUSE_TASKBARBUTTON
#include "wx/vector.h"
#include "wx/taskbarbutton.h"
class WXDLLIMPEXP_FWD_CORE wxITaskbarList3;
class WXDLLIMPEXP_CORE wxTaskBarButtonImpl : public wxTaskBarButton
{
public:
virtual ~wxTaskBarButtonImpl();
virtual void SetProgressRange(int range) wxOVERRIDE;
virtual void SetProgressValue(int value) wxOVERRIDE;
virtual void PulseProgress() wxOVERRIDE;
virtual void Show(bool show = true) wxOVERRIDE;
virtual void Hide() wxOVERRIDE;
virtual void SetThumbnailTooltip(const wxString& tooltip) wxOVERRIDE;
virtual void SetProgressState(wxTaskBarButtonState state) wxOVERRIDE;
virtual void SetOverlayIcon(const wxIcon& icon,
const wxString& description = wxString()) wxOVERRIDE;
virtual void SetThumbnailClip(const wxRect& rect) wxOVERRIDE;
virtual void SetThumbnailContents(const wxWindow *child) wxOVERRIDE;
virtual bool InsertThumbBarButton(size_t pos,
wxThumbBarButton *button) wxOVERRIDE;
virtual bool AppendThumbBarButton(wxThumbBarButton *button) wxOVERRIDE;
virtual bool AppendSeparatorInThumbBar() wxOVERRIDE;
virtual wxThumbBarButton* RemoveThumbBarButton(
wxThumbBarButton *button) wxOVERRIDE;
virtual wxThumbBarButton* RemoveThumbBarButton(int id) wxOVERRIDE;
wxThumbBarButton* GetThumbBarButtonByIndex(size_t index);
bool InitOrUpdateThumbBarButtons();
virtual void Realize() wxOVERRIDE;
private:
// This ctor is only used by wxTaskBarButton::New()
wxTaskBarButtonImpl(wxITaskbarList3* taskbarList, wxWindow* parent);
wxWindow* m_parent;
wxITaskbarList3 *m_taskbarList;
typedef wxVector<wxThumbBarButton*> wxThumbBarButtons;
wxThumbBarButtons m_thumbBarButtons;
int m_progressRange;
int m_progressValue;
wxTaskBarButtonState m_progressState;
wxString m_thumbnailTooltip;
wxIcon m_overlayIcon;
wxString m_overlayIconDescription;
wxRect m_thumbnailClipRect;
bool m_hasInitThumbnailToolbar;
friend wxTaskBarButton* wxTaskBarButton::New(wxWindow*);
wxDECLARE_NO_COPY_CLASS(wxTaskBarButtonImpl);
};
#endif // wxUSE_TASKBARBUTTON
#endif // _WX_MSW_TASKBARBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/mdi.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/mdi.h
// Purpose: MDI (Multiple Document Interface) classes
// Author: Julian Smart
// Modified by: 2008-10-31 Vadim Zeitlin: derive from the base classes
// Created: 01/02/97
// Copyright: (c) 1997 Julian Smart
// (c) 2008 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_MDI_H_
#define _WX_MSW_MDI_H_
#include "wx/frame.h"
class WXDLLIMPEXP_FWD_CORE wxAcceleratorTable;
// ---------------------------------------------------------------------------
// wxMDIParentFrame
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMDIParentFrame : public wxMDIParentFrameBase
{
public:
wxMDIParentFrame() { Init(); }
wxMDIParentFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
virtual ~wxMDIParentFrame();
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr);
// override/implement base class [pure] virtual methods
// ----------------------------------------------------
static bool IsTDI() { return false; }
// we don't store the active child in m_currentChild so override this
// function to find it dynamically
virtual wxMDIChildFrame *GetActiveChild() const wxOVERRIDE;
virtual void Cascade() wxOVERRIDE;
virtual void Tile(wxOrientation orient = wxHORIZONTAL) wxOVERRIDE;
virtual void ArrangeIcons() wxOVERRIDE;
virtual void ActivateNext() wxOVERRIDE;
virtual void ActivatePrevious() wxOVERRIDE;
#if wxUSE_MENUS
virtual void SetWindowMenu(wxMenu* menu) wxOVERRIDE;
virtual void DoMenuUpdates(wxMenu* menu = NULL) wxOVERRIDE;
// return the active child menu, if any
virtual WXHMENU MSWGetActiveMenu() const wxOVERRIDE;
#endif // wxUSE_MENUS
// implementation only from now on
// MDI helpers
// -----------
#if wxUSE_MENUS
// called by wxMDIChildFrame after it was successfully created
virtual void AddMDIChild(wxMDIChildFrame *child);
// called by wxMDIChildFrame just before it is destroyed
virtual void RemoveMDIChild(wxMDIChildFrame *child);
#endif // wxUSE_MENUS
// Retrieve the current window menu label: it can be different from
// "Window" when using non-English translations and can also be different
// from wxGetTranslation("Window") if the locale has changed since the
// "Window" menu was added.
const wxString& MSWGetCurrentWindowMenuLabel() const
{ return m_currentWindowMenuLabel; }
// handlers
// --------
// Responds to colour changes
void OnSysColourChanged(wxSysColourChangedEvent& event);
void OnActivate(wxActivateEvent& event);
void OnSize(wxSizeEvent& event);
void OnIconized(wxIconizeEvent& event);
bool HandleActivate(int state, bool minimized, WXHWND activate);
// override window proc for MDI-specific message processing
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXLRESULT MSWDefWindowProc(WXUINT, WXWPARAM, WXLPARAM) wxOVERRIDE;
virtual bool MSWTranslateMessage(WXMSG* msg) wxOVERRIDE;
#if wxUSE_MENUS
// override the menu-relayed methods to also look in the active child menu
// bar and the "Window" menu
virtual wxMenuItem *FindItemInMenuBar(int menuId) const wxOVERRIDE;
virtual wxMenu* MSWFindMenuFromHMENU(WXHMENU hMenu) wxOVERRIDE;
#endif // wxUSE_MENUS
protected:
#if wxUSE_MENUS_NATIVE
virtual void InternalSetMenuBar() wxOVERRIDE;
#endif // wxUSE_MENUS_NATIVE
virtual WXHICON GetDefaultIcon() const wxOVERRIDE;
// set the size of the MDI client window to match the frame size
void UpdateClientSize();
private:
// common part of all ctors
void Init();
#if wxUSE_MENUS
// "Window" menu commands event handlers
void OnMDICommand(wxCommandEvent& event);
void OnMDIChild(wxCommandEvent& event);
// add/remove window menu if we have it (i.e. m_windowMenu != NULL)
void AddWindowMenu();
void RemoveWindowMenu();
// update the window menu (if we have it) to enable or disable the commands
// which only make sense when we have more than one child
void UpdateWindowMenu(bool enable);
#if wxUSE_ACCEL
wxAcceleratorTable *m_accelWindowMenu;
#endif // wxUSE_ACCEL
#endif // wxUSE_MENUS
// return the number of child frames we currently have (maybe 0)
int GetChildFramesCount() const;
// if true, indicates whether the event wasn't really processed even though
// it was "handled", see OnActivate() and HandleActivate()
bool m_activationNotHandled;
// holds the current translation for the window menu label
wxString m_currentWindowMenuLabel;
friend class WXDLLIMPEXP_FWD_CORE wxMDIChildFrame;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxMDIParentFrame);
wxDECLARE_NO_COPY_CLASS(wxMDIParentFrame);
};
// ---------------------------------------------------------------------------
// wxMDIChildFrame
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMDIChildFrame : public wxMDIChildFrameBase
{
public:
wxMDIChildFrame() { Init(); }
wxMDIChildFrame(wxMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual ~wxMDIChildFrame();
// implement MDI operations
virtual void Activate() wxOVERRIDE;
// Override some frame operations too
virtual void Maximize(bool maximize = true) wxOVERRIDE;
virtual void Restore() wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
// Implementation only from now on
// -------------------------------
// Handlers
bool HandleMDIActivate(long bActivate, WXHWND, WXHWND);
bool HandleWindowPosChanging(void *lpPos);
bool HandleGetMinMaxInfo(void *mmInfo);
virtual WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXLRESULT MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual bool MSWTranslateMessage(WXMSG *msg) wxOVERRIDE;
virtual void MSWDestroyWindow() wxOVERRIDE;
bool ResetWindowStyle(void *vrect);
void OnIdle(wxIdleEvent& event);
protected:
virtual void DoGetScreenPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoSetSize(int x, int y, int width, int height, int sizeFlags) wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
virtual void InternalSetMenuBar() wxOVERRIDE;
virtual bool IsMDIChild() const wxOVERRIDE { return true; }
virtual void DetachMenuBar() wxOVERRIDE;
virtual WXHICON GetDefaultIcon() const wxOVERRIDE;
// common part of all ctors
void Init();
private:
bool m_needsResize; // flag which tells us to artificially resize the frame
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMDIChildFrame);
};
// ---------------------------------------------------------------------------
// wxMDIClientWindow
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMDIClientWindow : public wxMDIClientWindowBase
{
public:
wxMDIClientWindow() { Init(); }
// Note: this is virtual, to allow overridden behaviour.
virtual bool CreateClient(wxMDIParentFrame *parent,
long style = wxVSCROLL | wxHSCROLL) wxOVERRIDE;
// Explicitly call default scroll behaviour
void OnScroll(wxScrollEvent& event);
protected:
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
void Init() { m_scrollX = m_scrollY = 0; }
int m_scrollX, m_scrollY;
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMDIClientWindow);
};
#endif // _WX_MSW_MDI_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/libraries.h | /*
* Name: wx/msw/libraries.h
* Purpose: Pragmas for linking libs conditionally
* Author: Michael Wetherell
* Modified by:
* Copyright: (c) 2005 Michael Wetherell
* Licence: wxWindows licence
*/
#ifndef _WX_MSW_LIBRARIES_H_
#define _WX_MSW_LIBRARIES_H_
/*
* Notes:
*
* In general the preferred place to add libs is in the bakefiles. This file
* can be used where libs must be added conditionally, for those compilers that
* support a way to do that.
*/
#if defined __VISUALC__ && wxUSE_ACCESSIBILITY
#pragma comment(lib, "oleacc")
#endif
#if defined __VISUALC__ && wxUSE_UXTHEME
#pragma comment(lib, "uxtheme")
#endif
#endif /* _WX_MSW_LIBRARIES_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/subwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/subwin.h
// Purpose: helper for implementing the controls with subwindows
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-12-11
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_SUBWIN_H_
#define _WX_MSW_SUBWIN_H_
#include "wx/msw/private.h"
// ----------------------------------------------------------------------------
// wxSubwindows contains all HWNDs making part of a single wx control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSubwindows
{
public:
// the number of subwindows can be specified either as parameter to ctor or
// later in Create()
wxSubwindows(size_t n = 0) { Init(); if ( n ) Create(n); }
// allocate enough space for the given number of windows
void Create(size_t n)
{
wxASSERT_MSG( !m_hwnds, wxT("Create() called twice?") );
m_count = n;
m_hwnds = (HWND *)calloc(n, sizeof(HWND));
m_ids = new wxWindowIDRef[n];
}
// non-virtual dtor, this class is not supposed to be used polymorphically
~wxSubwindows()
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
::DestroyWindow(m_hwnds[n]);
}
free(m_hwnds);
delete [] m_ids;
}
// get the number of subwindows
size_t GetCount() const { return m_count; }
// access a given window
HWND& Get(size_t n)
{
wxASSERT_MSG( n < m_count, wxT("subwindow index out of range") );
return m_hwnds[n];
}
HWND operator[](size_t n) const
{
return const_cast<wxSubwindows *>(this)->Get(n);
}
// initialize the given window: id will be stored in wxWindowIDRef ensuring
// that it is not reused while this object exists
void Set(size_t n, HWND hwnd, wxWindowID id)
{
wxASSERT_MSG( n < m_count, wxT("subwindow index out of range") );
m_hwnds[n] = hwnd;
m_ids[n] = id;
}
// check if we have this window
bool HasWindow(HWND hwnd)
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] == hwnd )
return true;
}
return false;
}
// methods which are forwarded to all subwindows
// ---------------------------------------------
// show/hide everything
void Show(bool show)
{
int sw = show ? SW_SHOW : SW_HIDE;
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
::ShowWindow(m_hwnds[n], sw);
}
}
// enable/disable everything
void Enable(bool enable)
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
::EnableWindow(m_hwnds[n], enable);
}
}
// set font for all windows
void SetFont(const wxFont& font)
{
HFONT hfont = GetHfontOf(font);
wxCHECK_RET( hfont, wxT("invalid font") );
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
{
::SendMessage(m_hwnds[n], WM_SETFONT, (WPARAM)hfont, 0);
// otherwise the window might not be redrawn correctly
::InvalidateRect(m_hwnds[n], NULL, FALSE /* don't erase bg */);
}
}
}
// add all windows to update region to force redraw
void Refresh()
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
{
::InvalidateRect(m_hwnds[n], NULL, FALSE /* don't erase bg */);
}
}
}
// find the bounding box for all windows
wxRect GetBoundingBox() const
{
wxRect r;
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
{
RECT rc;
::GetWindowRect(m_hwnds[n], &rc);
r.Union(wxRectFromRECT(rc));
}
}
return r;
}
private:
void Init()
{
m_count = 0;
m_hwnds = NULL;
m_ids = NULL;
}
// number of elements in m_hwnds array
size_t m_count;
// the HWNDs we contain
HWND *m_hwnds;
// the IDs of the windows
wxWindowIDRef *m_ids;
wxDECLARE_NO_COPY_CLASS(wxSubwindows);
};
// convenient macro to forward a few methods which are usually propagated to
// subwindows to a wxSubwindows object
//
// parameters should be:
// - cname the name of the class implementing these methods
// - base the name of its base class
// - subwins the name of the member variable of type wxSubwindows *
#define WX_FORWARD_STD_METHODS_TO_SUBWINDOWS(cname, base, subwins) \
bool cname::ContainsHWND(WXHWND hWnd) const \
{ \
return subwins && subwins->HasWindow((HWND)hWnd); \
} \
\
bool cname::Show(bool show) \
{ \
if ( !base::Show(show) ) \
return false; \
\
if ( subwins ) \
subwins->Show(show); \
\
return true; \
} \
\
bool cname::Enable(bool enable) \
{ \
if ( !base::Enable(enable) ) \
return false; \
\
if ( subwins ) \
subwins->Enable(enable); \
\
return true; \
} \
\
bool cname::SetFont(const wxFont& font) \
{ \
if ( !base::SetFont(font) ) \
return false; \
\
if ( subwins ) \
subwins->SetFont(font); \
\
return true; \
} \
\
bool cname::SetForegroundColour(const wxColour& colour) \
{ \
if ( !base::SetForegroundColour(colour) ) \
return false; \
\
if ( subwins ) \
subwins->Refresh(); \
\
return true; \
} \
\
bool cname::SetBackgroundColour(const wxColour& colour) \
{ \
if ( !base::SetBackgroundColour(colour) ) \
return false; \
\
if ( subwins ) \
subwins->Refresh(); \
\
return true; \
} \
#endif // _WX_MSW_SUBWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/stackwalk.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stackwalk.h
// Purpose: wxStackWalker for MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 2005-01-08
// Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STACKWALK_H_
#define _WX_MSW_STACKWALK_H_
#include "wx/arrstr.h"
// these structs are declared in windows headers
struct _CONTEXT;
struct _EXCEPTION_POINTERS;
// and these in dbghelp.h
struct _SYMBOL_INFO;
struct _SYMBOL_INFOW;
#if wxUSE_UNICODE
#define wxSYMBOL_INFO _SYMBOL_INFOW
#else // !wxUSE_UNICODE
#define wxSYMBOL_INFO _SYMBOL_INFO
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
// ----------------------------------------------------------------------------
// wxStackFrame
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStackFrame : public wxStackFrameBase
{
private:
wxStackFrame *ConstCast() const
{ return const_cast<wxStackFrame *>(this); }
size_t DoGetParamCount() const { return m_paramTypes.GetCount(); }
public:
wxStackFrame(size_t level, void *address, size_t addrFrame)
: wxStackFrameBase(level, address)
{
m_hasName =
m_hasLocation = false;
m_addrFrame = addrFrame;
}
virtual size_t GetParamCount() const
{
ConstCast()->OnGetParam();
return DoGetParamCount();
}
virtual bool
GetParam(size_t n, wxString *type, wxString *name, wxString *value) const;
// callback used by OnGetParam(), don't call directly
void OnParam(wxSYMBOL_INFO *pSymInfo);
protected:
virtual void OnGetName();
virtual void OnGetLocation();
void OnGetParam();
// helper for debug API: it wants to have addresses as DWORDs
size_t GetSymAddr() const
{
return reinterpret_cast<size_t>(m_address);
}
private:
bool m_hasName,
m_hasLocation;
size_t m_addrFrame;
wxArrayString m_paramTypes,
m_paramNames,
m_paramValues;
};
// ----------------------------------------------------------------------------
// wxStackWalker
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStackWalker : public wxStackWalkerBase
{
public:
// we don't use ctor argument, it is for compatibility with Unix version
// only
wxStackWalker(const char * WXUNUSED(argv0) = NULL) { }
virtual void Walk(size_t skip = 1, size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
#if wxUSE_ON_FATAL_EXCEPTION
virtual void WalkFromException(size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
#endif // wxUSE_ON_FATAL_EXCEPTION
// enumerate stack frames from the given context
void WalkFrom(const _CONTEXT *ctx, size_t skip = 1, size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
void WalkFrom(const _EXCEPTION_POINTERS *ep, size_t skip = 1, size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
};
#endif // _WX_MSW_STACKWALK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/iniconf.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/iniconf.h
// Purpose: INI-file based wxConfigBase implementation
// Author: Vadim Zeitlin
// Modified by:
// Created: 27.07.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_INICONF_H_
#define _WX_MSW_INICONF_H_
#include "wx/defs.h"
#if wxUSE_CONFIG && wxUSE_INICONF
// ----------------------------------------------------------------------------
// wxIniConfig is a wxConfig implementation which uses MS Windows INI files to
// store the data. Because INI files don't really support arbitrary nesting of
// groups, we do the following:
// (1) in win.ini file we store all entries in the [vendor] section and
// the value group1/group2/key is mapped to the value group1_group2_key
// in this section, i.e. all path separators are replaced with underscore
// (2) in appname.ini file we map group1/group2/group3/key to the entry
// group2_group3_key in [group1]
//
// Of course, it might lead to indesirable results if '_' is also used in key
// names (i.e. group/key is the same as group_key) and also GetPath() result
// may be not what you would expect it to be.
//
// Another limitation: the keys and section names are never case-sensitive
// which might differ from wxFileConfig it it was compiled with
// wxCONFIG_CASE_SENSITIVE option.
// ----------------------------------------------------------------------------
// for this class, "local" file is the file appname.ini and the global file
// is the [vendor] subsection of win.ini (default for "vendor" is to be the
// same as appname). The file name (strAppName parameter) may, in fact,
// contain the full path to the file. If it doesn't, the file is searched for
// in the Windows directory.
class WXDLLIMPEXP_CORE wxIniConfig : public wxConfigBase
{
public:
// ctor & dtor
// if strAppName doesn't contain the extension and is not an absolute path,
// ".ini" is appended to it. if strVendor is empty, it's taken to be the
// same as strAppName.
wxIniConfig(const wxString& strAppName = wxEmptyString, const wxString& strVendor = wxEmptyString,
const wxString& localFilename = wxEmptyString, const wxString& globalFilename = wxEmptyString, long style = wxCONFIG_USE_LOCAL_FILE);
virtual ~wxIniConfig();
// implement inherited pure virtual functions
virtual void SetPath(const wxString& strPath) wxOVERRIDE;
virtual const wxString& GetPath() const wxOVERRIDE;
virtual bool GetFirstGroup(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextGroup (wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetFirstEntry(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextEntry (wxString& str, long& lIndex) const wxOVERRIDE;
virtual size_t GetNumberOfEntries(bool bRecursive = false) const wxOVERRIDE;
virtual size_t GetNumberOfGroups(bool bRecursive = false) const wxOVERRIDE;
virtual bool HasGroup(const wxString& strName) const wxOVERRIDE;
virtual bool HasEntry(const wxString& strName) const wxOVERRIDE;
// return true if the current group is empty
bool IsEmpty() const;
virtual bool Flush(bool bCurrentOnly = false) wxOVERRIDE;
virtual bool RenameEntry(const wxString& oldName, const wxString& newName) wxOVERRIDE;
virtual bool RenameGroup(const wxString& oldName, const wxString& newName) wxOVERRIDE;
virtual bool DeleteEntry(const wxString& Key, bool bGroupIfEmptyAlso = true) wxOVERRIDE;
virtual bool DeleteGroup(const wxString& szKey) wxOVERRIDE;
virtual bool DeleteAll() wxOVERRIDE;
protected:
// read/write
bool DoReadString(const wxString& key, wxString *pStr) const wxOVERRIDE;
bool DoReadLong(const wxString& key, long *plResult) const wxOVERRIDE;
bool DoReadBinary(const wxString& key, wxMemoryBuffer *buf) const wxOVERRIDE;
bool DoWriteString(const wxString& key, const wxString& szValue) wxOVERRIDE;
bool DoWriteLong(const wxString& key, long lValue) wxOVERRIDE;
bool DoWriteBinary(const wxString& key, const wxMemoryBuffer& buf) wxOVERRIDE;
private:
// helpers
wxString GetPrivateKeyName(const wxString& szKey) const;
wxString GetKeyName(const wxString& szKey) const;
wxString m_strLocalFilename; // name of the private INI file
wxString m_strGroup, // current group in appname.ini file
m_strPath; // the rest of the path (no trailing '_'!)
wxDECLARE_NO_COPY_CLASS(wxIniConfig);
wxDECLARE_ABSTRACT_CLASS(wxIniConfig);
};
#endif // wxUSE_CONFIG && wxUSE_INICONF
#endif // _WX_MSW_INICONF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/private.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private.h
// Purpose: Private declarations: as this header is only included by
// wxWidgets itself, it may contain identifiers which don't start
// with "wx".
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_H_
#define _WX_PRIVATE_H_
#include "wx/msw/wrapwin.h"
#include "wx/log.h"
#if wxUSE_GUI
#include "wx/window.h"
#endif // wxUSE_GUI
class WXDLLIMPEXP_FWD_CORE wxFont;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxWindowBase;
// ---------------------------------------------------------------------------
// private constants
// ---------------------------------------------------------------------------
// 260 was taken from windef.h
#ifndef MAX_PATH
#define MAX_PATH 260
#endif
// ---------------------------------------------------------------------------
// standard icons from the resources
// ---------------------------------------------------------------------------
#if wxUSE_GUI
extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_FRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_MDIPARENTFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_MDICHILDFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_FRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_MDICHILDFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HFONT) wxSTATUS_LINE_FONT;
#endif // wxUSE_GUI
// ---------------------------------------------------------------------------
// global data
// ---------------------------------------------------------------------------
extern WXDLLIMPEXP_DATA_BASE(HINSTANCE) wxhInstance;
extern "C"
{
WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
}
WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
// ---------------------------------------------------------------------------
// define things missing from some compilers' headers
// ---------------------------------------------------------------------------
// this defines a CASTWNDPROC macro which casts a pointer to the type of a
// window proc
#if defined(STRICT) || defined(__GNUC__)
typedef WNDPROC WndProcCast;
#else
typedef FARPROC WndProcCast;
#endif
#define CASTWNDPROC (WndProcCast)
// ---------------------------------------------------------------------------
// misc macros
// ---------------------------------------------------------------------------
#if wxUSE_GUI
#define MEANING_CHARACTER '0'
#define DEFAULT_ITEM_WIDTH 100
#define DEFAULT_ITEM_HEIGHT 80
// Return the height of a native text control corresponding to the given
// character height (as returned by GetCharHeight() or wxGetCharSize()).
//
// The wxWindow parameter must be valid and used for getting the DPI.
inline int wxGetEditHeightFromCharHeight(int cy, const wxWindow* w)
{
// The value 8 here is empiric, i.e. it's not necessarily correct, but
// seems to work relatively well.
return cy + w->FromDIP(8);
}
// Compatibility macro used in the existing code. It assumes that it's called
// from a method of wxWindow-derived object.
#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) \
wxGetEditHeightFromCharHeight((cy), this)
// Generic subclass proc, for panel item moving/sizing and intercept
// EDIT control VK_RETURN messages
extern LONG APIENTRY
wxSubclassedGenericControlProc(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
#endif // wxUSE_GUI
// ---------------------------------------------------------------------------
// useful macros and functions
// ---------------------------------------------------------------------------
// a wrapper macro for ZeroMemory()
#define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj))
// This one is a macro so that it can be tested with #ifdef, it will be
// undefined if it cannot be implemented for a given compiler.
// Vc++, bcc, dmc, ow, mingw akk have _get_osfhandle() and Cygwin has
// get_osfhandle. Others are currently unknown, e.g. Salford, Intel, Visual
// Age.
#if defined(__CYGWIN__)
#define wxGetOSFHandle(fd) ((HANDLE)get_osfhandle(fd))
#elif defined(__VISUALC__) \
|| defined(__BORLANDC__) \
|| defined(__MINGW32__)
#define wxGetOSFHandle(fd) ((HANDLE)_get_osfhandle(fd))
#define wxOpenOSFHandle(h, flags) (_open_osfhandle(wxPtrToUInt(h), flags))
wxDECL_FOR_STRICT_MINGW32(FILE*, _fdopen, (int, const char*))
#define wx_fdopen _fdopen
#endif
// close the handle in the class dtor
template <wxUIntPtr INVALID_VALUE>
class AutoHANDLE
{
public:
explicit AutoHANDLE(HANDLE handle = InvalidHandle()) : m_handle(handle) { }
bool IsOk() const { return m_handle != InvalidHandle(); }
operator HANDLE() const { return m_handle; }
~AutoHANDLE() { if ( IsOk() ) DoClose(); }
void Close()
{
wxCHECK_RET(IsOk(), wxT("Handle must be valid"));
DoClose();
m_handle = InvalidHandle();
}
protected:
// We need this helper function because integer INVALID_VALUE is not
// implicitly convertible to HANDLE, which is a pointer.
static HANDLE InvalidHandle()
{
return reinterpret_cast<HANDLE>(INVALID_VALUE);
}
void DoClose()
{
if ( !::CloseHandle(m_handle) )
wxLogLastError(wxT("CloseHandle"));
}
WXHANDLE m_handle;
};
// a template to make initializing Windows structs less painful: it zeros all
// the struct fields and also sets cbSize member to the correct value (and so
// can be only used with structures which have this member...)
template <class T>
struct WinStruct : public T
{
WinStruct()
{
::ZeroMemory(this, sizeof(T));
// explicit qualification is required here for this to be valid C++
this->cbSize = sizeof(T);
}
};
// Macros for converting wxString to the type expected by API functions.
//
// Normally it is enough to just use wxString::t_str() which is implicitly
// convertible to LPCTSTR, but in some cases an explicit conversion is required.
//
// In such cases wxMSW_CONV_LPCTSTR() should be used. But if an API function
// takes a non-const pointer, wxMSW_CONV_LPTSTR() which casts away the
// constness (but doesn't make it possible to really modify the returned
// pointer, of course) should be used. And if a string is passed as LPARAM, use
// wxMSW_CONV_LPARAM() which does the required ugly reinterpret_cast<> too.
#define wxMSW_CONV_LPCTSTR(s) static_cast<const wxChar *>((s).t_str())
#define wxMSW_CONV_LPTSTR(s) const_cast<wxChar *>(wxMSW_CONV_LPCTSTR(s))
#define wxMSW_CONV_LPARAM(s) reinterpret_cast<LPARAM>(wxMSW_CONV_LPCTSTR(s))
#if wxUSE_GUI
#include "wx/gdicmn.h"
#include "wx/colour.h"
// make conversion from wxColour and COLORREF a bit less painful
inline COLORREF wxColourToRGB(const wxColour& c)
{
return RGB(c.Red(), c.Green(), c.Blue());
}
inline COLORREF wxColourToPalRGB(const wxColour& c)
{
return PALETTERGB(c.Red(), c.Green(), c.Blue());
}
inline wxColour wxRGBToColour(COLORREF rgb)
{
return wxColour(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
}
inline void wxRGBToColour(wxColour& c, COLORREF rgb)
{
c.Set(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
}
// get the standard colour map for some standard colours - see comment in this
// function to understand why is it needed and when should it be used
//
// it returns a wxCOLORMAP (can't use COLORMAP itself here as comctl32.dll
// might be not included/available) array of size wxSTD_COLOUR_MAX
//
// NB: if you change these colours, update wxBITMAP_STD_COLOURS in the
// resources as well: it must have the same number of pixels!
enum wxSTD_COLOUR
{
wxSTD_COL_BTNTEXT,
wxSTD_COL_BTNSHADOW,
wxSTD_COL_BTNFACE,
wxSTD_COL_BTNHIGHLIGHT,
wxSTD_COL_MAX
};
struct WXDLLIMPEXP_CORE wxCOLORMAP
{
COLORREF from, to;
};
// this function is implemented in src/msw/window.cpp
extern wxCOLORMAP *wxGetStdColourMap();
// create a wxRect from Windows RECT
inline wxRect wxRectFromRECT(const RECT& rc)
{
return wxRect(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
}
// copy Windows RECT to our wxRect
inline void wxCopyRECTToRect(const RECT& rc, wxRect& rect)
{
rect = wxRectFromRECT(rc);
}
// and vice versa
inline void wxCopyRectToRECT(const wxRect& rect, RECT& rc)
{
// note that we don't use wxRect::GetRight() as it is one of compared to
// wxRectFromRECT() above
rc.top = rect.y;
rc.left = rect.x;
rc.right = rect.x + rect.width;
rc.bottom = rect.y + rect.height;
}
// translations between HIMETRIC units (which OLE likes) and pixels (which are
// liked by all the others) - implemented in msw/utilsexc.cpp
extern void HIMETRICToPixel(LONG *x, LONG *y);
extern void HIMETRICToPixel(LONG *x, LONG *y, HDC hdcRef);
extern void PixelToHIMETRIC(LONG *x, LONG *y);
extern void PixelToHIMETRIC(LONG *x, LONG *y, HDC hdcRef);
// Windows convention of the mask is opposed to the wxWidgets one, so we need
// to invert the mask each time we pass one/get one to/from Windows
extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0);
// Creates an icon or cursor depending from a bitmap
//
// The bitmap must be valid and it should have a mask. If it doesn't, a default
// mask is created using light grey as the transparent colour.
extern HICON wxBitmapToHICON(const wxBitmap& bmp);
// Same requirements as above apply and the bitmap must also have the correct
// size.
extern
HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY);
#if wxUSE_OWNER_DRAWN
// Draw the bitmap in specified state (this is used by owner drawn controls)
enum wxDSBStates
{
wxDSB_NORMAL = 0,
wxDSB_SELECTED,
wxDSB_DISABLED
};
extern
BOOL wxDrawStateBitmap(HDC hDC, HBITMAP hBitmap, int x, int y, UINT uState);
#endif // wxUSE_OWNER_DRAWN
// get the current state of SHIFT/CTRL/ALT keys
inline bool wxIsModifierDown(int vk)
{
// GetKeyState() returns different negative values on WinME and WinNT,
// so simply test for negative value.
return ::GetKeyState(vk) < 0;
}
inline bool wxIsShiftDown()
{
return wxIsModifierDown(VK_SHIFT);
}
inline bool wxIsCtrlDown()
{
return wxIsModifierDown(VK_CONTROL);
}
inline bool wxIsAltDown()
{
return wxIsModifierDown(VK_MENU);
}
inline bool wxIsAnyModifierDown()
{
return wxIsShiftDown() || wxIsCtrlDown() || wxIsAltDown();
}
// wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
// for Win32
inline RECT wxGetWindowRect(HWND hwnd)
{
RECT rect;
if ( !::GetWindowRect(hwnd, &rect) )
{
wxLogLastError(wxT("GetWindowRect"));
}
return rect;
}
inline RECT wxGetClientRect(HWND hwnd)
{
RECT rect;
if ( !::GetClientRect(hwnd, &rect) )
{
wxLogLastError(wxT("GetClientRect"));
}
return rect;
}
// ---------------------------------------------------------------------------
// small helper classes
// ---------------------------------------------------------------------------
// create an instance of this class and use it as the HDC for screen, will
// automatically release the DC going out of scope
class ScreenHDC
{
public:
ScreenHDC() { m_hdc = ::GetDC(NULL); }
~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); }
operator HDC() const { return m_hdc; }
private:
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(ScreenHDC);
};
// the same as ScreenHDC but for window DCs
class WindowHDC
{
public:
WindowHDC() : m_hwnd(NULL), m_hdc(NULL) { }
WindowHDC(HWND hwnd) { m_hdc = ::GetDC(m_hwnd = hwnd); }
~WindowHDC() { if ( m_hwnd && m_hdc ) { ::ReleaseDC(m_hwnd, m_hdc); } }
operator HDC() const { return m_hdc; }
private:
HWND m_hwnd;
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(WindowHDC);
};
// the same as ScreenHDC but for memory DCs: creates the HDC compatible with
// the given one (screen by default) in ctor and destroys it in dtor
class MemoryHDC
{
public:
MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); }
~MemoryHDC() { ::DeleteDC(m_hdc); }
operator HDC() const { return m_hdc; }
private:
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(MemoryHDC);
};
// a class which selects a GDI object into a DC in its ctor and deselects in
// dtor
class SelectInHDC
{
private:
void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); }
public:
SelectInHDC() : m_hdc(NULL), m_hgdiobj(NULL) { }
SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc) { DoInit(hgdiobj); }
void Init(HDC hdc, HGDIOBJ hgdiobj)
{
wxASSERT_MSG( !m_hdc, wxT("initializing twice?") );
m_hdc = hdc;
DoInit(hgdiobj);
}
~SelectInHDC() { if ( m_hdc ) ::SelectObject(m_hdc, m_hgdiobj); }
// return true if the object was successfully selected
operator bool() const { return m_hgdiobj != 0; }
private:
HDC m_hdc;
HGDIOBJ m_hgdiobj;
wxDECLARE_NO_COPY_CLASS(SelectInHDC);
};
// a class which cleans up any GDI object
class AutoGDIObject
{
protected:
AutoGDIObject() { m_gdiobj = NULL; }
AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { }
~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); }
void InitGdiobj(HGDIOBJ gdiobj)
{
wxASSERT_MSG( !m_gdiobj, wxT("initializing twice?") );
m_gdiobj = gdiobj;
}
HGDIOBJ GetObject() const { return m_gdiobj; }
private:
HGDIOBJ m_gdiobj;
};
// TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
// a class for temporary brushes
class AutoHBRUSH : private AutoGDIObject
{
public:
AutoHBRUSH(COLORREF col)
: AutoGDIObject(::CreateSolidBrush(col)) { }
operator HBRUSH() const { return (HBRUSH)GetObject(); }
};
// a class for temporary fonts
class AutoHFONT : private AutoGDIObject
{
private:
public:
AutoHFONT()
: AutoGDIObject() { }
AutoHFONT(const LOGFONT& lf)
: AutoGDIObject(::CreateFontIndirect(&lf)) { }
void Init(const LOGFONT& lf) { InitGdiobj(::CreateFontIndirect(&lf)); }
operator HFONT() const { return (HFONT)GetObject(); }
};
// a class for temporary pens
class AutoHPEN : private AutoGDIObject
{
public:
AutoHPEN(COLORREF col)
: AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { }
operator HPEN() const { return (HPEN)GetObject(); }
};
// classes for temporary bitmaps
class AutoHBITMAP : private AutoGDIObject
{
public:
AutoHBITMAP()
: AutoGDIObject() { }
AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
void Init(HBITMAP hbmp) { InitGdiobj(hbmp); }
operator HBITMAP() const { return (HBITMAP)GetObject(); }
};
class CompatibleBitmap : public AutoHBITMAP
{
public:
CompatibleBitmap(HDC hdc, int w, int h)
: AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h))
{
}
};
class MonoBitmap : public AutoHBITMAP
{
public:
MonoBitmap(int w, int h)
: AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0))
{
}
};
// class automatically destroys the region object
class AutoHRGN : private AutoGDIObject
{
public:
AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { }
operator HRGN() const { return (HRGN)GetObject(); }
};
// Class automatically freeing ICONINFO struct fields after retrieving it using
// GetIconInfo().
class AutoIconInfo : public ICONINFO
{
public:
AutoIconInfo() { wxZeroMemory(*this); }
bool GetFrom(HICON hIcon)
{
if ( !::GetIconInfo(hIcon, this) )
{
wxLogLastError(wxT("GetIconInfo"));
return false;
}
return true;
}
~AutoIconInfo()
{
if ( hbmColor )
::DeleteObject(hbmColor);
if ( hbmMask )
::DeleteObject(hbmMask);
}
};
// class sets the specified clipping region during its life time
class HDCClipper
{
public:
HDCClipper(HDC hdc, HRGN hrgn)
: m_hdc(hdc)
{
if ( !::SelectClipRgn(hdc, hrgn) )
{
wxLogLastError(wxT("SelectClipRgn"));
}
}
~HDCClipper()
{
::SelectClipRgn(m_hdc, NULL);
}
private:
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(HDCClipper);
};
// set the given map mode for the life time of this object
class HDCMapModeChanger
{
public:
HDCMapModeChanger(HDC hdc, int mm)
: m_hdc(hdc)
{
m_modeOld = ::SetMapMode(hdc, mm);
if ( !m_modeOld )
{
wxLogLastError(wxT("SelectClipRgn"));
}
}
~HDCMapModeChanger()
{
if ( m_modeOld )
::SetMapMode(m_hdc, m_modeOld);
}
private:
HDC m_hdc;
int m_modeOld;
wxDECLARE_NO_COPY_CLASS(HDCMapModeChanger);
};
#define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
// smart pointer using GlobalAlloc/GlobalFree()
class GlobalPtr
{
public:
// default ctor, call Init() later
GlobalPtr()
{
m_hGlobal = NULL;
}
// allocates a block of given size
void Init(size_t size, unsigned flags = GMEM_MOVEABLE)
{
m_hGlobal = ::GlobalAlloc(flags, size);
if ( !m_hGlobal )
{
wxLogLastError(wxT("GlobalAlloc"));
}
}
GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
{
Init(size, flags);
}
~GlobalPtr()
{
if ( m_hGlobal && ::GlobalFree(m_hGlobal) )
{
wxLogLastError(wxT("GlobalFree"));
}
}
// implicit conversion
operator HGLOBAL() const { return m_hGlobal; }
private:
HGLOBAL m_hGlobal;
wxDECLARE_NO_COPY_CLASS(GlobalPtr);
};
// when working with global pointers (which is unfortunately still necessary
// sometimes, e.g. for clipboard) it is important to unlock them exactly as
// many times as we lock them which just asks for using a "smart lock" class
class GlobalPtrLock
{
public:
// default ctor, use Init() later -- should only be used if the HGLOBAL can
// be NULL (in which case Init() shouldn't be called)
GlobalPtrLock()
{
m_hGlobal = NULL;
m_ptr = NULL;
}
// initialize the object, may be only called if we were created using the
// default ctor; HGLOBAL must not be NULL
void Init(HGLOBAL hGlobal)
{
m_hGlobal = hGlobal;
// NB: GlobalLock() is a macro, not a function, hence don't use the
// global scope operator with it (and neither with GlobalUnlock())
m_ptr = GlobalLock(hGlobal);
if ( !m_ptr )
{
wxLogLastError(wxT("GlobalLock"));
}
}
// initialize the object, HGLOBAL must not be NULL
GlobalPtrLock(HGLOBAL hGlobal)
{
Init(hGlobal);
}
~GlobalPtrLock()
{
if ( m_hGlobal && !GlobalUnlock(m_hGlobal) )
{
// this might happen simply because the block became unlocked
DWORD dwLastError = ::GetLastError();
if ( dwLastError != NO_ERROR )
{
wxLogApiError(wxT("GlobalUnlock"), dwLastError);
}
}
}
void *Get() const { return m_ptr; }
operator void *() const { return m_ptr; }
private:
HGLOBAL m_hGlobal;
void *m_ptr;
wxDECLARE_NO_COPY_CLASS(GlobalPtrLock);
};
// register the class when it is first needed and unregister it in dtor
class ClassRegistrar
{
public:
// ctor doesn't register the class, call Initialize() for this
ClassRegistrar() { m_registered = -1; }
// return true if the class is already registered
bool IsInitialized() const { return m_registered != -1; }
// return true if the class had been already registered
bool IsRegistered() const { return m_registered == 1; }
// try to register the class if not done yet, return true on success
bool Register(const WNDCLASS& wc)
{
// we should only be called if we hadn't been initialized yet
wxASSERT_MSG( m_registered == -1,
wxT("calling ClassRegistrar::Register() twice?") );
m_registered = ::RegisterClass(&wc) ? 1 : 0;
if ( !IsRegistered() )
{
wxLogLastError(wxT("RegisterClassEx()"));
}
else
{
m_clsname = wc.lpszClassName;
}
return m_registered == 1;
}
// get the name of the registered class (returns empty string if not
// registered)
const wxString& GetName() const { return m_clsname; }
// unregister the class if it had been registered
~ClassRegistrar()
{
if ( IsRegistered() )
{
if ( !::UnregisterClass(m_clsname.t_str(), wxGetInstance()) )
{
wxLogLastError(wxT("UnregisterClass"));
}
}
}
private:
// initial value is -1 which means that we hadn't tried registering the
// class yet, it becomes true or false (1 or 0) when Initialize() is called
int m_registered;
// the name of the class, only non empty if it had been registered
wxString m_clsname;
};
// ---------------------------------------------------------------------------
// macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
// returns Foo cast to the Windows type for ourselves, while GetFooOf() takes
// an argument which should be a pointer or reference to the object of the
// corresponding class (this depends on the macro)
// ---------------------------------------------------------------------------
#define GetHwnd() ((HWND)GetHWND())
#define GetHwndOf(win) ((HWND)((win)->GetHWND()))
// old name
#define GetWinHwnd GetHwndOf
#define GetHdc() ((HDC)GetHDC())
#define GetHdcOf(dc) ((HDC)(dc).GetHDC())
#define GetHbitmap() ((HBITMAP)GetHBITMAP())
#define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP())
#define GetHicon() ((HICON)GetHICON())
#define GetHiconOf(icon) ((HICON)(icon).GetHICON())
#define GetHaccel() ((HACCEL)GetHACCEL())
#define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL()))
#define GetHbrush() ((HBRUSH)GetResourceHandle())
#define GetHbrushOf(brush) ((HBRUSH)(brush).GetResourceHandle())
#define GetHmenu() ((HMENU)GetHMenu())
#define GetHmenuOf(menu) ((HMENU)(menu)->GetHMenu())
#define GetHcursor() ((HCURSOR)GetHCURSOR())
#define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR())
#define GetHfont() ((HFONT)GetHFONT())
#define GetHfontOf(font) ((HFONT)(font).GetHFONT())
#define GetHimagelist() ((HIMAGELIST)GetHIMAGELIST())
#define GetHimagelistOf(imgl) ((HIMAGELIST)(imgl)->GetHIMAGELIST())
#define GetHpalette() ((HPALETTE)GetHPALETTE())
#define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE())
#define GetHpen() ((HPEN)GetResourceHandle())
#define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle())
#define GetHrgn() ((HRGN)GetHRGN())
#define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN())
#endif // wxUSE_GUI
// ---------------------------------------------------------------------------
// global functions
// ---------------------------------------------------------------------------
// return the full path of the given module
inline wxString wxGetFullModuleName(HMODULE hmod)
{
wxString fullname;
if ( !::GetModuleFileName
(
hmod,
wxStringBuffer(fullname, MAX_PATH),
MAX_PATH
) )
{
wxLogLastError(wxT("GetModuleFileName"));
}
return fullname;
}
// return the full path of the program file
inline wxString wxGetFullModuleName()
{
return wxGetFullModuleName((HMODULE)wxGetInstance());
}
// return the run-time version of the OS in a format similar to
// WINVER/_WIN32_WINNT compile-time macros:
//
// 0x0501 Windows XP, 2003
// 0x0502 Windows XP SP2, 2003 SP1
// 0x0600 Windows Vista, 2008
// 0x0601 Windows 7
// 0x0602 Windows 8 (currently also returned for 8.1 if program does not have a manifest indicating 8.1 support)
// 0x0603 Windows 8.1 (currently only returned for 8.1 if program has a manifest indicating 8.1 support)
// 0x1000 Windows 10 (currently only returned for 10 if program has a manifest indicating 10 support)
//
// for the other Windows versions wxWinVersion_Unknown is currently returned.
enum wxWinVersion
{
wxWinVersion_3 = 0x0300,
wxWinVersion_NT3 = wxWinVersion_3,
wxWinVersion_4 = 0x0400,
wxWinVersion_95 = wxWinVersion_4,
wxWinVersion_NT4 = wxWinVersion_4,
wxWinVersion_98 = 0x0410,
wxWinVersion_5 = 0x0500,
wxWinVersion_ME = wxWinVersion_5,
wxWinVersion_NT5 = wxWinVersion_5,
wxWinVersion_2000 = wxWinVersion_5,
wxWinVersion_XP = 0x0501,
wxWinVersion_2003 = 0x0501,
wxWinVersion_XP_SP2 = 0x0502,
wxWinVersion_2003_SP1 = 0x0502,
wxWinVersion_6 = 0x0600,
wxWinVersion_Vista = wxWinVersion_6,
wxWinVersion_NT6 = wxWinVersion_6,
wxWinVersion_7 = 0x601,
wxWinVersion_8 = 0x602,
wxWinVersion_8_1 = 0x603,
wxWinVersion_10 = 0x1000,
// Any version we can't recognize will be later than the last currently
// known one, so give it a value greater than any in the known range.
wxWinVersion_Unknown = 0x7fff
};
WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion();
#if wxUSE_GUI && defined(__WXMSW__)
// cursor stuff
extern HCURSOR wxGetCurrentBusyCursor(); // from msw/utils.cpp
extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
// GetCursorPos can fail without populating the POINT. This falls back to GetMessagePos.
WXDLLIMPEXP_CORE void wxGetCursorPosMSW(POINT* pt);
WXDLLIMPEXP_CORE void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font);
WXDLLIMPEXP_CORE void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
WXDLLIMPEXP_CORE wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
WXDLLIMPEXP_CORE wxFontEncoding wxGetFontEncFromCharSet(int charset);
WXDLLIMPEXP_CORE void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
WXDLLIMPEXP_CORE void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
// Find maximum size of window/rectangle
extern WXDLLIMPEXP_CORE void wxFindMaxSize(WXHWND hwnd, RECT *rect);
// Safely get the window text (i.e. without using fixed size buffer)
extern WXDLLIMPEXP_CORE wxString wxGetWindowText(WXHWND hWnd);
// get the window class name
extern WXDLLIMPEXP_CORE wxString wxGetWindowClass(WXHWND hWnd);
// get the window id (should be unsigned, hence this is not wxWindowID which
// is, for mainly historical reasons, signed)
extern WXDLLIMPEXP_CORE int wxGetWindowId(WXHWND hWnd);
// check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
// different
//
// wndProc parameter is unused and only kept for compatibility
extern WXDLLIMPEXP_CORE
bool wxCheckWindowWndProc(WXHWND hWnd, WXWNDPROC wndProc = NULL);
// Does this window style specify any border?
inline bool wxStyleHasBorder(long style)
{
return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER |
wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
}
inline bool wxHasWindowExStyle(const wxWindowMSW *win, long style)
{
return (::GetWindowLong(GetHwndOf(win), GWL_EXSTYLE) & style) != 0;
}
// Common helper of wxUpdate{,Edit}LayoutDirection() below: sets or clears the
// given flag(s) depending on wxLayoutDirection and returns true if the flags
// really changed.
inline bool
wxUpdateExStyleForLayoutDirection(WXHWND hWnd,
wxLayoutDirection dir,
LONG_PTR flagsForRTL)
{
wxCHECK_MSG( hWnd, false,
wxS("Can't set layout direction for invalid window") );
const LONG_PTR styleOld = ::GetWindowLongPtr(hWnd, GWL_EXSTYLE);
LONG_PTR styleNew = styleOld;
switch ( dir )
{
case wxLayout_LeftToRight:
styleNew &= ~flagsForRTL;
break;
case wxLayout_RightToLeft:
styleNew |= flagsForRTL;
break;
case wxLayout_Default:
wxFAIL_MSG(wxS("Invalid layout direction"));
}
if ( styleNew == styleOld )
return false;
::SetWindowLongPtr(hWnd, GWL_EXSTYLE, styleNew);
return true;
}
// Update layout direction flag for a generic window.
//
// See below for the special version that must be used with EDIT controls.
//
// Returns true if the layout direction did change.
inline bool wxUpdateLayoutDirection(WXHWND hWnd, wxLayoutDirection dir)
{
return wxUpdateExStyleForLayoutDirection(hWnd, dir, WS_EX_LAYOUTRTL);
}
// Update layout direction flag for an EDIT control.
//
// Returns true if anything changed or false if the direction flag was already
// set to the desired direction (which can't be wxLayout_Default).
inline bool wxUpdateEditLayoutDirection(WXHWND hWnd, wxLayoutDirection dir)
{
return wxUpdateExStyleForLayoutDirection(hWnd, dir,
WS_EX_RIGHT |
WS_EX_RTLREADING |
WS_EX_LEFTSCROLLBAR);
}
// Companion of the above function checking if an EDIT control uses RTL.
inline wxLayoutDirection wxGetEditLayoutDirection(WXHWND hWnd)
{
wxCHECK_MSG( hWnd, wxLayout_Default, wxS("invalid window") );
// While we set 3 style bits above, we're only really interested in one of
// them here. In particularly, don't check for WS_EX_RIGHT as it can be set
// for a right-aligned control even if it doesn't use RTL. And while we
// could test WS_EX_LEFTSCROLLBAR, this doesn't really seem useful.
const LONG_PTR style = ::GetWindowLongPtr(hWnd, GWL_EXSTYLE);
return style & WS_EX_RTLREADING ? wxLayout_RightToLeft
: wxLayout_LeftToRight;
}
// ----------------------------------------------------------------------------
// functions mapping HWND to wxWindow
// ----------------------------------------------------------------------------
// this function simply checks whether the given hwnd corresponds to a wxWindow
// and returns either that window if it does or NULL otherwise
extern WXDLLIMPEXP_CORE wxWindow* wxFindWinFromHandle(HWND hwnd);
// find the window for HWND which is part of some wxWindow, i.e. unlike
// wxFindWinFromHandle() above it will also work for "sub controls" of a
// wxWindow.
//
// returns the wxWindow corresponding to the given HWND or NULL.
extern WXDLLIMPEXP_CORE wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
// Get the size of an icon
extern WXDLLIMPEXP_CORE wxSize wxGetHiconSize(HICON hicon);
WXDLLIMPEXP_CORE void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
// fill the client rect of the given window on the provided dc using this brush
inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr)
{
RECT rc;
::GetClientRect(hwnd, &rc);
::FillRect(hdc, &rc, hbr);
}
// ----------------------------------------------------------------------------
// 32/64 bit helpers
// ----------------------------------------------------------------------------
// note that the casts to LONG_PTR here are required even on 32-bit machines
// for the 64-bit warning mode of later versions of MSVC (C4311/4312)
inline WNDPROC wxGetWindowProc(HWND hwnd)
{
return (WNDPROC)(LONG_PTR)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
}
inline void *wxGetWindowUserData(HWND hwnd)
{
return (void *)(LONG_PTR)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
}
inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
{
return (WNDPROC)(LONG_PTR)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func);
}
inline void *wxSetWindowUserData(HWND hwnd, void *data)
{
return (void *)(LONG_PTR)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);
}
#endif // wxUSE_GUI && __WXMSW__
#endif // _WX_PRIVATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/accel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/accel.h
// Purpose: wxAcceleratorTable class
// Author: Julian Smart
// Modified by:
// Created: 31/7/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ACCEL_H_
#define _WX_ACCEL_H_
class WXDLLIMPEXP_FWD_CORE wxWindow;
// ----------------------------------------------------------------------------
// the accel table has all accelerators for a given window or menu
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAcceleratorTable : public wxObject
{
public:
// default ctor
wxAcceleratorTable() { }
// load from .rc resource (Windows specific)
wxAcceleratorTable(const wxString& resource);
// initialize from array
wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]);
bool Ok() const { return IsOk(); }
bool IsOk() const;
void SetHACCEL(WXHACCEL hAccel);
WXHACCEL GetHACCEL() const;
// translate the accelerator, return true if done
bool Translate(wxWindow *window, WXMSG *msg) const;
private:
wxDECLARE_DYNAMIC_CLASS(wxAcceleratorTable);
};
#endif
// _WX_ACCEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/scrolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/scrolbar.h
// Purpose: wxScrollBar class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SCROLBAR_H_
#define _WX_SCROLBAR_H_
// Scrollbar item
class WXDLLIMPEXP_CORE wxScrollBar: public wxScrollBarBase
{
public:
wxScrollBar() { m_pageSize = 0; m_viewSize = 0; m_objectSize = 0; }
virtual ~wxScrollBar();
wxScrollBar(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr);
int GetThumbPosition() const wxOVERRIDE;
int GetThumbSize() const wxOVERRIDE { return m_pageSize; }
int GetPageSize() const wxOVERRIDE { return m_viewSize; }
int GetRange() const wxOVERRIDE { return m_objectSize; }
virtual void SetThumbPosition(int viewStart) wxOVERRIDE;
virtual void SetScrollbar(int position, int thumbSize, int range, int pageSize,
bool refresh = true) wxOVERRIDE;
// needed for RTTI
void SetThumbSize( int s ) { SetScrollbar( GetThumbPosition() , s , GetRange() , GetPageSize() , true ) ; }
void SetPageSize( int s ) { SetScrollbar( GetThumbPosition() , GetThumbSize() , GetRange() , s , true ) ; }
void SetRange( int s ) { SetScrollbar( GetThumbPosition() , GetThumbSize() , s , GetPageSize() , true ) ; }
void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
// override wxControl version to not use solid background here
virtual WXHBRUSH MSWControlColor(WXHDC pDC, WXHWND hWnd) 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;
int m_pageSize;
int m_viewSize;
int m_objectSize;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxScrollBar);
};
#endif
// _WX_SCROLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dde.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dde.h
// Purpose: DDE class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DDE_H_
#define _WX_DDE_H_
#include "wx/ipcbase.h"
/*
* Mini-DDE implementation
Most transactions involve a topic name and an item name (choose these
as befits your application).
A client can:
- ask the server to execute commands (data) associated with a topic
- request data from server by topic and item
- poke data into the server
- ask the server to start an advice loop on topic/item
- ask the server to stop an advice loop
A server can:
- respond to execute, request, poke and advice start/stop
- send advise data to client
Note that this limits the server in the ways it can send data to the
client, i.e. it can't send unsolicited information.
*
*/
class WXDLLIMPEXP_FWD_BASE wxDDEServer;
class WXDLLIMPEXP_FWD_BASE wxDDEClient;
class WXDLLIMPEXP_BASE wxDDEConnection : public wxConnectionBase
{
public:
wxDDEConnection(void *buffer, size_t size); // use external buffer
wxDDEConnection(); // use internal buffer
virtual ~wxDDEConnection();
// implement base class pure virtual methods
virtual const void *Request(const wxString& item,
size_t *size = NULL,
wxIPCFormat format = wxIPC_TEXT) wxOVERRIDE;
virtual bool StartAdvise(const wxString& item) wxOVERRIDE;
virtual bool StopAdvise(const wxString& item) wxOVERRIDE;
virtual bool Disconnect() wxOVERRIDE;
protected:
virtual bool DoExecute(const void *data, size_t size, wxIPCFormat format) wxOVERRIDE;
virtual bool DoPoke(const wxString& item, const void *data, size_t size,
wxIPCFormat format) wxOVERRIDE;
virtual bool DoAdvise(const wxString& item, const void *data, size_t size,
wxIPCFormat format) wxOVERRIDE;
public:
wxString m_topicName;
wxDDEServer* m_server;
wxDDEClient* m_client;
WXHCONV m_hConv;
const void* m_sendingData;
int m_dataSize;
wxIPCFormat m_dataType;
wxDECLARE_NO_COPY_CLASS(wxDDEConnection);
wxDECLARE_DYNAMIC_CLASS(wxDDEConnection);
};
class WXDLLIMPEXP_BASE wxDDEServer : public wxServerBase
{
public:
wxDDEServer();
bool Create(const wxString& server_name) wxOVERRIDE;
virtual ~wxDDEServer();
virtual wxConnectionBase *OnAcceptConnection(const wxString& topic) wxOVERRIDE;
// Find/delete wxDDEConnection corresponding to the HCONV
wxDDEConnection *FindConnection(WXHCONV conv);
bool DeleteConnection(WXHCONV conv);
wxString& GetServiceName() const { return (wxString&) m_serviceName; }
wxDDEConnectionList& GetConnections() const
{ return (wxDDEConnectionList&) m_connections; }
protected:
int m_lastError;
wxString m_serviceName;
wxDDEConnectionList m_connections;
wxDECLARE_DYNAMIC_CLASS(wxDDEServer);
};
class WXDLLIMPEXP_BASE wxDDEClient: public wxClientBase
{
public:
wxDDEClient();
virtual ~wxDDEClient();
bool ValidHost(const wxString& host) wxOVERRIDE;
// Call this to make a connection. Returns NULL if cannot.
virtual wxConnectionBase *MakeConnection(const wxString& host,
const wxString& server,
const wxString& topic) wxOVERRIDE;
// Tailor this to return own connection.
virtual wxConnectionBase *OnMakeConnection() wxOVERRIDE;
// Find/delete wxDDEConnection corresponding to the HCONV
wxDDEConnection *FindConnection(WXHCONV conv);
bool DeleteConnection(WXHCONV conv);
wxDDEConnectionList& GetConnections() const
{ return (wxDDEConnectionList&) m_connections; }
protected:
int m_lastError;
wxDDEConnectionList m_connections;
wxDECLARE_DYNAMIC_CLASS(wxDDEClient);
};
void WXDLLIMPEXP_BASE wxDDEInitialize();
void WXDLLIMPEXP_BASE wxDDECleanUp();
#endif // _WX_DDE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dirdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dirdlg.h
// Purpose: wxDirDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIRDLG_H_
#define _WX_DIRDLG_H_
class WXDLLIMPEXP_CORE wxDirDialog : public wxDirDialogBase
{
public:
wxDirDialog(wxWindow *parent,
const wxString& message = wxDirSelectorPromptStr,
const wxString& defaultPath = wxEmptyString,
long style = wxDD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxDirDialogNameStr);
void SetPath(const wxString& path) wxOVERRIDE;
virtual int ShowModal() wxOVERRIDE;
private:
// The real implementations of ShowModal(), used for Windows versions
// before and since Vista.
int ShowSHBrowseForFolder(WXHWND owner);
int ShowIFileDialog(WXHWND owner);
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDirDialog);
};
#endif
// _WX_DIRDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/webview_missing.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/webview_missing.h
// Purpose: Definitions / classes commonly missing used by wxWebViewIE
// Author: Steven Lamerton
// Copyright: (c) 2012 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*
* Classes and definitions used by wxWebViewIE vary in their
* completeness between compilers and versions of compilers.
* We implement our own versions here which should work
* for all compilers. The definitions are taken from the
* mingw-w64 headers which are public domain.
*/
/* urlmon.h */
struct IHTMLElement;
struct IHTMLDocument2;
#ifndef REFRESH_NORMAL
#define REFRESH_NORMAL 0
#endif
#ifndef REFRESH_COMPLETELY
#define REFRESH_COMPLETELY 3
#endif
typedef enum __wxMIDL_IBindStatusCallback_0006
{
wxBSCF_FIRSTDATANOTIFICATION = 0x1,
wxBSCF_INTERMEDIATEDATANOTIFICATION = 0x2,
wxBSCF_LASTDATANOTIFICATION = 0x4,
wxBSCF_DATAFULLYAVAILABLE = 0x8,
wxBSCF_AVAILABLEDATASIZEUNKNOWN = 0x10
} wxBSCF;
EXTERN_C const IID CLSID_FileProtocol;
typedef struct _tagwxBINDINFO
{
ULONG cbSize;
LPWSTR szExtraInfo;
STGMEDIUM stgmedData;
DWORD grfBindInfoF;
DWORD dwBindVerb;
LPWSTR szCustomVerb;
DWORD cbstgmedData;
DWORD dwOptions;
DWORD dwOptionsFlags;
DWORD dwCodePage;
SECURITY_ATTRIBUTES securityAttributes;
IID iid;
IUnknown *pUnk;
DWORD dwReserved;
} wxBINDINFO;
typedef struct _tagwxPROTOCOLDATA
{
DWORD grfFlags;
DWORD dwState;
LPVOID pData;
ULONG cbData;
} wxPROTOCOLDATA;
class wxIInternetBindInfo : public IUnknown
{
public:
virtual HRESULT wxSTDCALL GetBindInfo(DWORD *grfBINDF, wxBINDINFO *pbindinfo) = 0;
virtual HRESULT wxSTDCALL GetBindString(ULONG ulStringType, LPOLESTR *ppwzStr,
ULONG cEl, ULONG *pcElFetched) = 0;
};
class wxIInternetProtocolSink : public IUnknown
{
public:
virtual HRESULT wxSTDCALL Switch(wxPROTOCOLDATA *pProtocolData) = 0;
virtual HRESULT wxSTDCALL ReportProgress(ULONG ulStatusCode,
LPCWSTR szStatusText) = 0;
virtual HRESULT wxSTDCALL ReportData(DWORD grfBSCF, ULONG ulProgress,
ULONG ulProgressMax) = 0;
virtual HRESULT wxSTDCALL ReportResult(HRESULT hrResult, DWORD dwError,
LPCWSTR szResult) = 0;
};
class wxIInternetProtocolRoot : public IUnknown
{
public:
virtual HRESULT wxSTDCALL Start(LPCWSTR szUrl, wxIInternetProtocolSink *pOIProtSink,
wxIInternetBindInfo *pOIBindInfo, DWORD grfPI,
HANDLE_PTR dwReserved) = 0;
virtual HRESULT wxSTDCALL Continue(wxPROTOCOLDATA *pProtocolData) = 0;
virtual HRESULT wxSTDCALL Abort(HRESULT hrReason, DWORD dwOptions) = 0;
virtual HRESULT wxSTDCALL Terminate(DWORD dwOptions) = 0;
virtual HRESULT wxSTDCALL Suspend(void) = 0;
virtual HRESULT wxSTDCALL Resume(void) = 0;
};
class wxIInternetProtocol : public wxIInternetProtocolRoot
{
public:
virtual HRESULT wxSTDCALL Read(void *pv, ULONG cb, ULONG *pcbRead) = 0;
virtual HRESULT wxSTDCALL Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin,
ULARGE_INTEGER *plibNewPosition) = 0;
virtual HRESULT wxSTDCALL LockRequest(DWORD dwOptions) = 0;
virtual HRESULT wxSTDCALL UnlockRequest(void) = 0;
};
class wxIInternetSession : public IUnknown
{
public:
virtual HRESULT wxSTDCALL RegisterNameSpace(IClassFactory *pCF, REFCLSID rclsid,
LPCWSTR pwzProtocol,
ULONG cPatterns,
const LPCWSTR *ppwzPatterns,
DWORD dwReserved) = 0;
virtual HRESULT wxSTDCALL UnregisterNameSpace(IClassFactory *pCF,
LPCWSTR pszProtocol) = 0;
virtual HRESULT wxSTDCALL RegisterMimeFilter(IClassFactory *pCF,
REFCLSID rclsid,
LPCWSTR pwzType) = 0;
virtual HRESULT wxSTDCALL UnregisterMimeFilter(IClassFactory *pCF,
LPCWSTR pwzType) = 0;
virtual HRESULT wxSTDCALL CreateBinding(LPBC pBC, LPCWSTR szUrl,
IUnknown *pUnkOuter, IUnknown **ppUnk,
wxIInternetProtocol **ppOInetProt,
DWORD dwOption) = 0;
virtual HRESULT wxSTDCALL SetSessionOption(DWORD dwOption, LPVOID pBuffer,
DWORD dwBufferLength,
DWORD dwReserved) = 0;
virtual HRESULT wxSTDCALL GetSessionOption(DWORD dwOption, LPVOID pBuffer,
DWORD *pdwBufferLength,
DWORD dwReserved) = 0;
};
/* end of urlmon.h */
/* mshtmhst.h */
typedef enum _tagwxDOCHOSTUIFLAG
{
DOCHOSTUIFLAG_DIALOG = 0x1,
DOCHOSTUIFLAG_DISABLE_HELP_MENU = 0x2,
DOCHOSTUIFLAG_NO3DBORDER = 0x4,
DOCHOSTUIFLAG_SCROLL_NO = 0x8,
DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE = 0x10,
DOCHOSTUIFLAG_OPENNEWWIN = 0x20,
DOCHOSTUIFLAG_DISABLE_OFFSCREEN = 0x40,
DOCHOSTUIFLAG_FLAT_SCROLLBAR = 0x80,
DOCHOSTUIFLAG_DIV_BLOCKDEFAULT = 0x100,
DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY = 0x200,
DOCHOSTUIFLAG_OVERRIDEBEHAVIORFACTORY = 0x400,
DOCHOSTUIFLAG_CODEPAGELINKEDFONTS = 0x800,
DOCHOSTUIFLAG_URL_ENCODING_DISABLE_UTF8 = 0x1000,
DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8 = 0x2000,
DOCHOSTUIFLAG_ENABLE_FORMS_AUTOCOMPLETE = 0x4000,
DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION = 0x10000,
DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION = 0x20000,
DOCHOSTUIFLAG_THEME = 0x40000,
DOCHOSTUIFLAG_NOTHEME = 0x80000,
DOCHOSTUIFLAG_NOPICS = 0x100000,
DOCHOSTUIFLAG_NO3DOUTERBORDER = 0x200000,
DOCHOSTUIFLAG_DISABLE_EDIT_NS_FIXUP = 0x400000,
DOCHOSTUIFLAG_LOCAL_MACHINE_ACCESS_CHECK = 0x800000,
DOCHOSTUIFLAG_DISABLE_UNTRUSTEDPROTOCOL = 0x1000000,
DOCHOSTUIFLAG_ENABLE_REDIRECT_NOTIFICATION = 0x4000000
} DOCHOSTUIFLAG;
typedef struct _tagwxDOCHOSTUIINFO
{
ULONG cbSize;
DWORD dwFlags;
DWORD dwDoubleClick;
OLECHAR *pchHostCss;
OLECHAR *pchHostNS;
} DOCHOSTUIINFO;
class wxIDocHostUIHandler : public IUnknown
{
public:
virtual HRESULT wxSTDCALL ShowContextMenu(DWORD dwID, POINT *ppt,
IUnknown *pcmdtReserved,
IDispatch *pdispReserved) = 0;
virtual HRESULT wxSTDCALL GetHostInfo(DOCHOSTUIINFO *pInfo) = 0;
virtual HRESULT wxSTDCALL ShowUI(DWORD dwID,
IOleInPlaceActiveObject *pActiveObject,
IOleCommandTarget *pCommandTarget,
IOleInPlaceFrame *pFrame,
IOleInPlaceUIWindow *pDoc) = 0;
virtual HRESULT wxSTDCALL HideUI(void) = 0;
virtual HRESULT wxSTDCALL UpdateUI(void) = 0;
virtual HRESULT wxSTDCALL EnableModeless(BOOL fEnable) = 0;
virtual HRESULT wxSTDCALL OnDocWindowActivate(BOOL fActivate) = 0;
virtual HRESULT wxSTDCALL OnFrameWindowActivate(BOOL fActivate) = 0;
virtual HRESULT wxSTDCALL ResizeBorder(LPCRECT prcBorder,
IOleInPlaceUIWindow *pUIWindow,
BOOL fRameWindow) = 0;
virtual HRESULT wxSTDCALL TranslateAccelerator(LPMSG lpMsg,
const GUID *pguidCmdGroup,
DWORD nCmdID) = 0;
virtual HRESULT wxSTDCALL GetOptionKeyPath(LPOLESTR *pchKey,
DWORD dw) = 0;
virtual HRESULT wxSTDCALL GetDropTarget(IDropTarget *pDropTarget,
IDropTarget **ppDropTarget) = 0;
virtual HRESULT wxSTDCALL GetExternal(IDispatch **ppDispatch) = 0;
virtual HRESULT wxSTDCALL TranslateUrl(DWORD dwTranslate,
OLECHAR *pchURLIn,
OLECHAR **ppchURLOut) = 0;
virtual HRESULT wxSTDCALL FilterDataObject(IDataObject *pDO,
IDataObject **ppDORet) = 0;
};
/* end of mshtmhst.h */
/* mshtml.h */
typedef enum _tagwxPOINTER_GRAVITY
{
wxPOINTER_GRAVITY_Left = 0,
wxPOINTER_GRAVITY_Right = 1,
wxPOINTER_GRAVITY_Max = 2147483647
} wxPOINTER_GRAVITY;
typedef enum _tagwxELEMENT_ADJACENCY
{
wxELEM_ADJ_BeforeBegin = 0,
wxELEM_ADJ_AfterBegin = 1,
wxELEM_ADJ_BeforeEnd = 2,
wxELEM_ADJ_AfterEnd = 3,
wxELEMENT_ADJACENCY_Max = 2147483647
} wxELEMENT_ADJACENCY;
typedef enum _tagwxMARKUP_CONTEXT_TYPE
{
wxCONTEXT_TYPE_None = 0,
wxCONTEXT_TYPE_Text = 1,
wxCONTEXT_TYPE_EnterScope = 2,
wxCONTEXT_TYPE_ExitScope = 3,
wxCONTEXT_TYPE_NoScope = 4,
wxMARKUP_CONTEXT_TYPE_Max = 2147483647
} wxMARKUP_CONTEXT_TYPE;
typedef enum _tagwxFINDTEXT_FLAGS
{
wxFINDTEXT_BACKWARDS = 0x1,
wxFINDTEXT_WHOLEWORD = 0x2,
wxFINDTEXT_MATCHCASE = 0x4,
wxFINDTEXT_RAW = 0x20000,
wxFINDTEXT_MATCHDIAC = 0x20000000,
wxFINDTEXT_MATCHKASHIDA = 0x40000000,
wxFINDTEXT_MATCHALEFHAMZA = 0x80000000,
wxFINDTEXT_FLAGS_Max = 2147483647
} wxFINDTEXT_FLAGS;
typedef enum _tagwxMOVEUNIT_ACTION
{
wxMOVEUNIT_PREVCHAR = 0,
wxMOVEUNIT_NEXTCHAR = 1,
wxMOVEUNIT_PREVCLUSTERBEGIN = 2,
wxMOVEUNIT_NEXTCLUSTERBEGIN = 3,
wxMOVEUNIT_PREVCLUSTEREND = 4,
wxMOVEUNIT_NEXTCLUSTEREND = 5,
wxMOVEUNIT_PREVWORDBEGIN = 6,
wxMOVEUNIT_NEXTWORDBEGIN = 7,
wxMOVEUNIT_PREVWORDEND = 8,
wxMOVEUNIT_NEXTWORDEND = 9,
wxMOVEUNIT_PREVPROOFWORD = 10,
wxMOVEUNIT_NEXTPROOFWORD = 11,
wxMOVEUNIT_NEXTURLBEGIN = 12,
wxMOVEUNIT_PREVURLBEGIN = 13,
wxMOVEUNIT_NEXTURLEND = 14,
wxMOVEUNIT_PREVURLEND = 15,
wxMOVEUNIT_PREVSENTENCE = 16,
wxMOVEUNIT_NEXTSENTENCE = 17,
wxMOVEUNIT_PREVBLOCK = 18,
wxMOVEUNIT_NEXTBLOCK = 19,
wxMOVEUNIT_ACTION_Max = 2147483647
} wxMOVEUNIT_ACTION;
typedef enum _tagwxELEMENT_TAG_ID
{
wxTAGID_NULL = 0, wxTAGID_UNKNOWN = 1, wxTAGID_A = 2, wxTAGID_ACRONYM = 3,
wxTAGID_ADDRESS = 4, wxTAGID_APPLET = 5, wxTAGID_AREA = 6, wxTAGID_B = 7,
wxTAGID_BASE = 8, wxTAGID_BASEFONT = 9, wxTAGID_BDO = 10,
wxTAGID_BGSOUND = 11, wxTAGID_BIG = 12, wxTAGID_BLINK = 13,
wxTAGID_BLOCKQUOTE = 14, wxTAGID_BODY = 15, wxTAGID_BR = 16,
wxTAGID_BUTTON = 17, wxTAGID_CAPTION = 18, wxTAGID_CENTER = 19,
wxTAGID_CITE = 20, wxTAGID_CODE = 21, wxTAGID_COL = 22,
wxTAGID_COLGROUP = 23, wxTAGID_COMMENT = 24, wxTAGID_COMMENT_RAW = 25,
wxTAGID_DD = 26, wxTAGID_DEL = 27, wxTAGID_DFN = 28, wxTAGID_DIR = 29,
wxTAGID_DIV = 30, wxTAGID_DL = 31, wxTAGID_DT = 32, wxTAGID_EM = 33,
wxTAGID_EMBED = 34, wxTAGID_FIELDSET = 35, wxTAGID_FONT = 36,
wxTAGID_FORM = 37, wxTAGID_FRAME = 38, wxTAGID_FRAMESET = 39,
wxTAGID_GENERIC = 40, wxTAGID_H1 = 41, wxTAGID_H2 = 42, wxTAGID_H3 = 43,
wxTAGID_H4 = 44, wxTAGID_H5 = 45, wxTAGID_H6 = 46, wxTAGID_HEAD = 47,
wxTAGID_HR = 48, wxTAGID_HTML = 49, wxTAGID_I = 50, wxTAGID_IFRAME = 51,
wxTAGID_IMG = 52, wxTAGID_INPUT = 53, wxTAGID_INS = 54, wxTAGID_KBD = 55,
wxTAGID_LABEL = 56, wxTAGID_LEGEND = 57, wxTAGID_LI = 58, wxTAGID_LINK = 59,
wxTAGID_LISTING = 60, wxTAGID_MAP = 61, wxTAGID_MARQUEE = 62,
wxTAGID_MENU = 63, wxTAGID_META = 64, wxTAGID_NEXTID = 65,
wxTAGID_NOBR = 66, wxTAGID_NOEMBED = 67, wxTAGID_NOFRAMES = 68,
wxTAGID_NOSCRIPT = 69, wxTAGID_OBJECT = 70, wxTAGID_OL = 71,
wxTAGID_OPTION = 72, wxTAGID_P = 73, wxTAGID_PARAM = 74,
wxTAGID_PLAINTEXT = 75, wxTAGID_PRE = 76, wxTAGID_Q = 77, wxTAGID_RP = 78,
wxTAGID_RT = 79, wxTAGID_RUBY = 80, wxTAGID_S = 81, wxTAGID_SAMP = 82,
wxTAGID_SCRIPT = 83, wxTAGID_SELECT = 84, wxTAGID_SMALL = 85,
wxTAGID_SPAN = 86, wxTAGID_STRIKE = 87, wxTAGID_STRONG = 88,
wxTAGID_STYLE = 89, wxTAGID_SUB = 90, wxTAGID_SUP = 91, wxTAGID_TABLE = 92,
wxTAGID_TBODY = 93, wxTAGID_TC = 94, wxTAGID_TD = 95, wxTAGID_TEXTAREA = 96,
wxTAGID_TFOOT = 97, wxTAGID_TH = 98, wxTAGID_THEAD = 99,
wxTAGID_TITLE = 100, wxTAGID_TR = 101, wxTAGID_TT = 102, wxTAGID_U = 103,
wxTAGID_UL = 104, wxTAGID_VAR = 105, wxTAGID_WBR = 106, wxTAGID_XMP = 107,
wxTAGID_ROOT = 108, wxTAGID_OPTGROUP = 109, wxTAGID_COUNT = 110,
wxTAGID_LAST_PREDEFINED = 10000, wxELEMENT_TAG_ID_Max = 2147483647
} wxELEMENT_TAG_ID;
struct wxIHTMLStyle : public IDispatch
{
public:
virtual HRESULT wxSTDCALL put_fontFamily(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontFamily(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontVariant(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontVariant(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontWeight(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontWeight(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontSize(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_fontSize(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_font(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_font(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_color(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_color(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_background(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_background(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_backgroundColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundImage(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundRepeat(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundRepeat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundAttachment(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundAttachment(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundPosition(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundPosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundPositionX(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionX(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundPositionY(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionY(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_wordSpacing(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_wordSpacing(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_letterSpacing(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_letterSpacing(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_textDecoration(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_textDecoration(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationNone(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationNone(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationUnderline(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationUnderline(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationOverline(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationOverline(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationLineThrough(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationLineThrough(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationBlink(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationBlink(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_verticalAlign(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_verticalAlign(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_textTransform(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_textTransform(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_textAlign(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_textAlign(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_textIndent(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_textIndent(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_lineHeight(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_lineHeight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginTop(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginRight(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginBottom(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginLeft(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_margin(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_margin(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_paddingTop(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_paddingRight(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_paddingBottom(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_paddingLeft(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_padding(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_padding(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_border(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_border(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTop(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderTop(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderRight(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderRight(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottom(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderBottom(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeft(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderLeft(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderColor(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderColor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTopColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderTopColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderRightColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderRightColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottomColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderBottomColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeftColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderLeftColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderWidth(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderWidth(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTopWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderTopWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderRightWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderRightWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottomWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderBottomWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeftWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderLeftWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTopStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderTopStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderRightStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderRightStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottomStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderBottomStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeftStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderLeftStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_width(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_width(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_height(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_height(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_styleFloat(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_styleFloat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_clear(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_clear(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_display(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_display(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_visibility(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_visibility(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStyleType(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStyleType(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStylePosition(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStylePosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStyleImage(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStyleImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_whiteSpace(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_whiteSpace(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_top(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_top(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_left(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_left(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_position(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_zIndex(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_zIndex(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_overflow(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_overflow(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_pageBreakBefore(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_pageBreakBefore(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_pageBreakAfter(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_pageBreakAfter(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_cssText(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_cssText(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_pixelTop(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelTop(long *p) = 0;
virtual HRESULT wxSTDCALL put_pixelLeft(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelLeft(long *p) = 0;
virtual HRESULT wxSTDCALL put_pixelWidth(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelWidth(long *p) = 0;
virtual HRESULT wxSTDCALL put_pixelHeight(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelHeight(long *p) = 0;
virtual HRESULT wxSTDCALL put_posTop(float v) = 0;
virtual HRESULT wxSTDCALL get_posTop(float *p) = 0;
virtual HRESULT wxSTDCALL put_posLeft(float v) = 0;
virtual HRESULT wxSTDCALL get_posLeft(float *p) = 0;
virtual HRESULT wxSTDCALL put_posWidth(float v) = 0;
virtual HRESULT wxSTDCALL get_posWidth(float *p) = 0;
virtual HRESULT wxSTDCALL put_posHeight(float v) = 0;
virtual HRESULT wxSTDCALL get_posHeight(float *p) = 0;
virtual HRESULT wxSTDCALL put_cursor(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_cursor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_clip(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_clip(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_filter(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_filter(BSTR *p) = 0;
virtual HRESULT wxSTDCALL setAttribute(BSTR strAttributeName, VARIANT AttributeValue, LONG lFlags = 1) = 0;
virtual HRESULT wxSTDCALL getAttribute(BSTR strAttributeName, LONG lFlags, VARIANT *AttributeValue) = 0;
virtual HRESULT wxSTDCALL removeAttribute(BSTR strAttributeName, LONG lFlags, VARIANT_BOOL *pfSuccess) = 0;
virtual HRESULT wxSTDCALL toString(BSTR *String) = 0;
};
struct wxIHTMLCurrentStyle : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_position(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_styleFloat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_color(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_fontFamily(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_fontStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_fontVariant(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_fontWeight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_fontSize(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionX(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionY(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundRepeat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderLeftColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderTopColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderRightColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderBottomColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderTopStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderRightStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderBottomStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderLeftStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderTopWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderRightWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderBottomWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderLeftWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_left(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_top(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_width(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_height(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_textAlign(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textDecoration(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_display(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_visibility(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_zIndex(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_letterSpacing(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_lineHeight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_textIndent(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_verticalAlign(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundAttachment(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_marginTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_marginRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_marginBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_marginLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clear(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_listStyleType(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_listStylePosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_listStyleImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_clipTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clipRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clipBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clipLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_overflow(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_pageBreakBefore(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_pageBreakAfter(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_cursor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_tableLayout(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderCollapse(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_direction(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_behavior(BSTR *p) = 0;
virtual HRESULT wxSTDCALL getAttribute(BSTR strAttributeName, LONG lFlags, VARIANT *AttributeValue) = 0;
virtual HRESULT wxSTDCALL get_unicodeBidi(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_right(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_bottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_imeMode(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_rubyAlign(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_rubyPosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_rubyOverhang(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textAutospace(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_lineBreak(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_wordBreak(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textJustify(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textJustifyTrim(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textKashida(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_blockDirection(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridChar(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridLine(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridMode(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridType(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderColor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderWidth(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_padding(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_margin(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_accelerator(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_overflowX(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_overflowY(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textTransform(BSTR *p) = 0;
};
struct wxIHTMLRect : public IDispatch
{
public:
virtual HRESULT wxSTDCALL put_left(long v) = 0;
virtual HRESULT wxSTDCALL get_left(long *p) = 0;
virtual HRESULT wxSTDCALL put_top(long v) = 0;
virtual HRESULT wxSTDCALL get_top(long *p) = 0;
virtual HRESULT wxSTDCALL put_right(long v) = 0;
virtual HRESULT wxSTDCALL get_right(long *p) = 0;
virtual HRESULT wxSTDCALL put_bottom(long v) = 0;
virtual HRESULT wxSTDCALL get_bottom(long *p) = 0;
};
struct wxIHTMLRectCollection : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_length(long *p) = 0;
virtual HRESULT wxSTDCALL get__newEnum(IUnknown **p) = 0;
virtual HRESULT wxSTDCALL item(VARIANT *pvarIndex, VARIANT *pvarResult) = 0;
};
struct wxIHTMLFiltersCollection : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_length(long *p) = 0;
virtual HRESULT wxSTDCALL get__newEnum(IUnknown **p) = 0;
virtual HRESULT wxSTDCALL item(VARIANT *pvarIndex, VARIANT *pvarResult) = 0;
};
struct wxIHTMLElementCollection : public IDispatch
{
public:
virtual HRESULT wxSTDCALL toString(BSTR *String) = 0;
virtual HRESULT wxSTDCALL put_length(long v) = 0;
virtual HRESULT wxSTDCALL get_length(long *p) = 0;
virtual HRESULT wxSTDCALL get__newEnum(IUnknown **p) = 0;
virtual HRESULT wxSTDCALL item(VARIANT name, VARIANT index, IDispatch **pdisp) = 0;
virtual HRESULT wxSTDCALL tags(VARIANT tagName, IDispatch **pdisp) = 0;
};
struct wxIHTMLElement2 : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_scopeName(BSTR *p) = 0;
virtual HRESULT wxSTDCALL setCapture(VARIANT_BOOL containerCapture = -1) = 0;
virtual HRESULT wxSTDCALL releaseCapture(void) = 0;
virtual HRESULT wxSTDCALL put_onlosecapture(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onlosecapture(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL componentFromPoint(long x, long y, BSTR *component) = 0;
virtual HRESULT wxSTDCALL doScroll(VARIANT component) = 0;
virtual HRESULT wxSTDCALL put_onscroll(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onscroll(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondrag(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondrag(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragend(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragend(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragenter(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragenter(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragover(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragover(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragleave(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragleave(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondrop(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondrop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforecut(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforecut(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_oncut(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncut(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforecopy(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforecopy(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_oncopy(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncopy(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforepaste(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforepaste(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onpaste(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onpaste(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_currentStyle(wxIHTMLCurrentStyle **p) = 0;
virtual HRESULT wxSTDCALL put_onpropertychange(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onpropertychange(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL getClientRects(wxIHTMLRectCollection **pRectCol) = 0;
virtual HRESULT wxSTDCALL getBoundingClientRect(wxIHTMLRect **pRect) = 0;
virtual HRESULT wxSTDCALL setExpression(BSTR propname, BSTR expression, BSTR language) = 0;
virtual HRESULT wxSTDCALL getExpression(BSTR propname, VARIANT *expression) = 0;
virtual HRESULT wxSTDCALL removeExpression(BSTR propname, VARIANT_BOOL *pfSuccess) = 0;
virtual HRESULT wxSTDCALL put_tabIndex(short v) = 0;
virtual HRESULT wxSTDCALL get_tabIndex(short *p) = 0;
virtual HRESULT wxSTDCALL focus(void) = 0;
virtual HRESULT wxSTDCALL put_accessKey(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_accessKey(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_onblur(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onblur(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onfocus(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onfocus(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onresize(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onresize(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL blur(void) = 0;
virtual HRESULT wxSTDCALL addFilter(IUnknown *pUnk) = 0;
virtual HRESULT wxSTDCALL removeFilter(IUnknown *pUnk) = 0;
virtual HRESULT wxSTDCALL get_clientHeight(long *p) = 0;
virtual HRESULT wxSTDCALL get_clientWidth(long *p) = 0;
virtual HRESULT wxSTDCALL get_clientTop(long *p) = 0;
virtual HRESULT wxSTDCALL get_clientLeft(long *p) = 0;
virtual HRESULT wxSTDCALL attachEvent(BSTR event, IDispatch *pDisp, VARIANT_BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL detachEvent(BSTR event, IDispatch *pDisp) = 0;
virtual HRESULT wxSTDCALL get_readyState(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onreadystatechange(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onreadystatechange(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onrowsdelete(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onrowsdelete(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onrowsinserted(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onrowsinserted(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_oncellchange(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncellchange(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_dir(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_dir(BSTR *p) = 0;
virtual HRESULT wxSTDCALL createControlRange(IDispatch **range) = 0;
virtual HRESULT wxSTDCALL get_scrollHeight(long *p) = 0;
virtual HRESULT wxSTDCALL get_scrollWidth(long *p) = 0;
virtual HRESULT wxSTDCALL put_scrollTop(long v) = 0;
virtual HRESULT wxSTDCALL get_scrollTop(long *p) = 0;
virtual HRESULT wxSTDCALL put_scrollLeft(long v) = 0;
virtual HRESULT wxSTDCALL get_scrollLeft(long *p) = 0;
virtual HRESULT wxSTDCALL clearAttributes(void) = 0;
virtual HRESULT wxSTDCALL mergeAttributes(IHTMLElement *mergeThis) = 0;
virtual HRESULT wxSTDCALL put_oncontextmenu(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncontextmenu(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL insertAdjacentElement(BSTR where, IHTMLElement *insertedElement, IHTMLElement **inserted) = 0;
virtual HRESULT wxSTDCALL applyElement(IHTMLElement *apply, BSTR where, IHTMLElement **applied) = 0;
virtual HRESULT wxSTDCALL getAdjacentText(BSTR where, BSTR *text) = 0;
virtual HRESULT wxSTDCALL replaceAdjacentText(BSTR where, BSTR newText, BSTR *oldText) = 0;
virtual HRESULT wxSTDCALL get_canHaveChildren(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL addBehavior(BSTR bstrUrl, VARIANT *pvarFactory, long *pCookie) = 0;
virtual HRESULT wxSTDCALL removeBehavior(long cookie, VARIANT_BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL get_runtimeStyle(wxIHTMLStyle **p) = 0;
virtual HRESULT wxSTDCALL get_behaviorUrns(IDispatch **p) = 0;
virtual HRESULT wxSTDCALL put_tagUrn(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_tagUrn(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforeeditfocus(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforeeditfocus(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_readyStateValue(long *p) = 0;
virtual HRESULT wxSTDCALL getElementsByTagName(BSTR v,
wxIHTMLElementCollection **pelColl) = 0;
};
struct wxIHTMLTxtRange : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_htmlText(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_text(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_text(BSTR *p) = 0;
virtual HRESULT wxSTDCALL parentElement(IHTMLElement **parent) = 0;
virtual HRESULT wxSTDCALL duplicate(wxIHTMLTxtRange **Duplicate) = 0;
virtual HRESULT wxSTDCALL inRange(wxIHTMLTxtRange *Range, VARIANT_BOOL *InRange) = 0;
virtual HRESULT wxSTDCALL isEqual(wxIHTMLTxtRange *Range, VARIANT_BOOL *IsEqual) = 0;
virtual HRESULT wxSTDCALL scrollIntoView(VARIANT_BOOL fStart = -1) = 0;
virtual HRESULT wxSTDCALL collapse(VARIANT_BOOL Start = -1) = 0;
virtual HRESULT wxSTDCALL expand(BSTR Unit, VARIANT_BOOL *Success) = 0;
virtual HRESULT wxSTDCALL move(BSTR Unit, long Count, long *ActualCount) = 0;
virtual HRESULT wxSTDCALL moveStart(BSTR Unit, long Count, long *ActualCount) = 0;
virtual HRESULT wxSTDCALL moveEnd(BSTR Unit, long Count, long *ActualCount) = 0;
virtual HRESULT wxSTDCALL select(void) = 0;
virtual HRESULT wxSTDCALL pasteHTML(BSTR html) = 0;
virtual HRESULT wxSTDCALL moveToElementText(IHTMLElement *element) = 0;
virtual HRESULT wxSTDCALL setEndPoint(BSTR how, wxIHTMLTxtRange *SourceRange) = 0;
virtual HRESULT wxSTDCALL compareEndPoints(BSTR how, wxIHTMLTxtRange *SourceRange, long *ret) = 0;
virtual HRESULT wxSTDCALL findText(BSTR String, long count, long Flags, VARIANT_BOOL *Success) = 0;
virtual HRESULT wxSTDCALL moveToPoint(long x, long y) = 0;
virtual HRESULT wxSTDCALL getBookmark(BSTR *Boolmark) = 0;
virtual HRESULT wxSTDCALL moveToBookmark(BSTR Bookmark, VARIANT_BOOL *Success) = 0;
virtual HRESULT wxSTDCALL queryCommandSupported(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandEnabled(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandState(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandIndeterm(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandText(BSTR cmdID, BSTR *pcmdText) = 0;
virtual HRESULT wxSTDCALL queryCommandValue(BSTR cmdID, VARIANT *pcmdValue) = 0;
virtual HRESULT wxSTDCALL execCommand(BSTR cmdID, VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL execCommandShowHelp(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
};
struct wxIMarkupContainer : public IUnknown
{
public:
virtual HRESULT wxSTDCALL OwningDoc(IHTMLDocument2 **ppDoc) = 0;
};
struct wxIMarkupPointer : public IUnknown
{
public:
virtual HRESULT wxSTDCALL OwningDoc(IHTMLDocument2 **ppDoc) = 0;
virtual HRESULT wxSTDCALL Gravity(wxPOINTER_GRAVITY *pGravity) = 0;
virtual HRESULT wxSTDCALL SetGravity(wxPOINTER_GRAVITY Gravity) = 0;
virtual HRESULT wxSTDCALL Cling(BOOL *pfCling) = 0;
virtual HRESULT wxSTDCALL SetCling(BOOL fCLing) = 0;
virtual HRESULT wxSTDCALL Unposition(void) = 0;
virtual HRESULT wxSTDCALL IsPositioned(BOOL *pfPositioned) = 0;
virtual HRESULT wxSTDCALL GetContainer(wxIMarkupContainer **ppContainer) = 0;
virtual HRESULT wxSTDCALL MoveAdjacentToElement(IHTMLElement *pElement, wxELEMENT_ADJACENCY eAdj) = 0;
virtual HRESULT wxSTDCALL MoveToPointer(wxIMarkupPointer *pPointer) = 0;
virtual HRESULT wxSTDCALL MoveToContainer(wxIMarkupContainer *pContainer, BOOL fAtStart) = 0;
virtual HRESULT wxSTDCALL Left(BOOL fMove, wxMARKUP_CONTEXT_TYPE *pContext, IHTMLElement **ppElement, long *pcch, OLECHAR *pchText) = 0;
virtual HRESULT wxSTDCALL Right(BOOL fMove, wxMARKUP_CONTEXT_TYPE *pContext, IHTMLElement **ppElement, long *pcch, OLECHAR *pchText) = 0;
virtual HRESULT wxSTDCALL CurrentScope(IHTMLElement **ppElemCurrent) = 0;
virtual HRESULT wxSTDCALL IsLeftOf(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsLeftOfOrEqualTo(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsRightOf(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsRightOfOrEqualTo(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsEqualTo(wxIMarkupPointer *pPointerThat, BOOL *pfAreEqual) = 0;
virtual HRESULT wxSTDCALL MoveUnit(wxMOVEUNIT_ACTION muAction) = 0;
virtual HRESULT wxSTDCALL FindText(OLECHAR *pchFindText, DWORD dwFlags, wxIMarkupPointer *pIEndMatch, wxIMarkupPointer *pIEndSearch) = 0;
};
struct wxIMarkupServices : public IUnknown
{
public:
virtual HRESULT wxSTDCALL CreateMarkupPointer(wxIMarkupPointer **ppPointer) = 0;
virtual HRESULT wxSTDCALL CreateMarkupContainer(wxIMarkupContainer **ppMarkupContainer) = 0;
virtual HRESULT wxSTDCALL CreateElement(wxELEMENT_TAG_ID tagID, OLECHAR *pchAttributes, IHTMLElement **ppElement) = 0;
virtual HRESULT wxSTDCALL CloneElement(IHTMLElement *pElemCloneThis, IHTMLElement **ppElementTheClone) = 0;
virtual HRESULT wxSTDCALL InsertElement(IHTMLElement *pElementInsert, wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL RemoveElement(IHTMLElement *pElementRemove) = 0;
virtual HRESULT wxSTDCALL Remove(wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL Copy(wxIMarkupPointer *pPointerSourceStart, wxIMarkupPointer *pPointerSourceFinish, wxIMarkupPointer *pPointerTarget) = 0;
virtual HRESULT wxSTDCALL Move(wxIMarkupPointer *pPointerSourceStart, wxIMarkupPointer *pPointerSourceFinish, wxIMarkupPointer *pPointerTarget) = 0;
virtual HRESULT wxSTDCALL InsertText(OLECHAR *pchText, long cch, wxIMarkupPointer *pPointerTarget) = 0;
virtual HRESULT wxSTDCALL ParseString(OLECHAR *pchHTML, DWORD dwFlags, wxIMarkupContainer **ppContainerResult, wxIMarkupPointer *ppPointerStart, wxIMarkupPointer *ppPointerFinish) = 0;
virtual HRESULT wxSTDCALL ParseGlobal(HGLOBAL hglobalHTML, DWORD dwFlags, wxIMarkupContainer **ppContainerResult, wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL IsScopedElement(IHTMLElement *pElement, BOOL *pfScoped) = 0;
virtual HRESULT wxSTDCALL GetElementTagId(IHTMLElement *pElement, wxELEMENT_TAG_ID *ptagId) = 0;
virtual HRESULT wxSTDCALL GetTagIDForName(BSTR bstrName, wxELEMENT_TAG_ID *ptagId) = 0;
virtual HRESULT wxSTDCALL GetNameForTagID(wxELEMENT_TAG_ID tagId, BSTR *pbstrName) = 0;
virtual HRESULT wxSTDCALL MovePointersToRange(wxIHTMLTxtRange *pIRange, wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL MoveRangeToPointers(wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish, wxIHTMLTxtRange *pIRange) = 0;
virtual HRESULT wxSTDCALL BeginUndoUnit(OLECHAR *pchTitle) = 0;
virtual HRESULT wxSTDCALL EndUndoUnit(void) = 0;
};
/* end of mshtml.h */
/* WinInet.h */
#ifndef HTTP_STATUS_BAD_REQUEST
#define HTTP_STATUS_BAD_REQUEST 400
#endif
#ifndef HTTP_STATUS_DENIED
#define HTTP_STATUS_DENIED 401
#endif
#ifndef HTTP_STATUS_PAYMENT_REQ
#define HTTP_STATUS_PAYMENT_REQ 402
#endif
#ifndef HTTP_STATUS_FORBIDDEN
#define HTTP_STATUS_FORBIDDEN 403
#endif
#ifndef HTTP_STATUS_NOT_FOUND
#define HTTP_STATUS_NOT_FOUND 404
#endif
#ifndef HTTP_STATUS_BAD_METHOD
#define HTTP_STATUS_BAD_METHOD 405
#endif
#ifndef HTTP_STATUS_NONE_ACCEPTABLE
#define HTTP_STATUS_NONE_ACCEPTABLE 406
#endif
#ifndef HTTP_STATUS_PROXY_AUTH_REQ
#define HTTP_STATUS_PROXY_AUTH_REQ 407
#endif
#ifndef HTTP_STATUS_REQUEST_TIMEOUT
#define HTTP_STATUS_REQUEST_TIMEOUT 408
#endif
#ifndef HTTP_STATUS_CONFLICT
#define HTTP_STATUS_CONFLICT 409
#endif
#ifndef HTTP_STATUS_GONE
#define HTTP_STATUS_GONE 410
#endif
#ifndef HTTP_STATUS_LENGTH_REQUIRED
#define HTTP_STATUS_LENGTH_REQUIRED 411
#endif
#ifndef HTTP_STATUS_PRECOND_FAILED
#define HTTP_STATUS_PRECOND_FAILED 412
#endif
#ifndef HTTP_STATUS_REQUEST_TOO_LARGE
#define HTTP_STATUS_REQUEST_TOO_LARGE 413
#endif
#ifndef HTTP_STATUS_URI_TOO_LONG
#define HTTP_STATUS_URI_TOO_LONG 414
#endif
#ifndef HTTP_STATUS_UNSUPPORTED_MEDIA
#define HTTP_STATUS_UNSUPPORTED_MEDIA 415
#endif
#ifndef HTTP_STATUS_RETRY_WITH
#define HTTP_STATUS_RETRY_WITH 449
#endif
#ifndef HTTP_STATUS_SERVER_ERROR
#define HTTP_STATUS_SERVER_ERROR 500
#endif
#ifndef HTTP_STATUS_NOT_SUPPORTED
#define HTTP_STATUS_NOT_SUPPORTED 501
#endif
#ifndef HTTP_STATUS_BAD_GATEWAY
#define HTTP_STATUS_BAD_GATEWAY 502
#endif
#ifndef HTTP_STATUS_SERVICE_UNAVAIL
#define HTTP_STATUS_SERVICE_UNAVAIL 503
#endif
#ifndef HTTP_STATUS_GATEWAY_TIMEOUT
#define HTTP_STATUS_GATEWAY_TIMEOUT 504
#endif
#ifndef HTTP_STATUS_VERSION_NOT_SUP
#define HTTP_STATUS_VERSION_NOT_SUP 505
#endif
/* end of WinInet.h */
/* ShObjldl_core.h */
typedef enum _wxNWMF
{
wxNWMF_UNLOADING = 0x1,
wxNWMF_USERINITED = 0x2,
wxNWMF_FIRST = 0x4,
wxNWMF_OVERRIDEKEY = 0x8,
wxNWMF_SHOWHELP = 0x10,
wxNWMF_HTMLDIALOG = 0x20,
wxNWMF_FROMDIALOGCHILD = 0x40,
wxNWMF_USERREQUESTED = 0x80,
wxNWMF_USERALLOWED = 0x100,
wxNWMF_FORCEWINDOW = 0x10000,
wxNWMF_FORCETAB = 0x20000,
wxNWMF_SUGGESTWINDOW = 0x40000,
wxNWMF_SUGGESTTAB = 0x80000,
wxNWMF_INACTIVETAB = 0x100000
} _wxNWMF;
/* end of ShObjldl_core.h */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/choice.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/choice.h
// Purpose: wxChoice class
// Author: Julian Smart
// Modified by: Vadim Zeitlin to derive from wxChoiceBase
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHOICE_H_
#define _WX_CHOICE_H_
struct tagCOMBOBOXINFO;
// ----------------------------------------------------------------------------
// Choice item
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxChoice : public wxChoiceBase
{
public:
// ctors
wxChoice() { Init(); }
virtual ~wxChoice();
wxChoice(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Init();
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxChoice(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Init();
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
virtual bool Show(bool show = true) wxOVERRIDE;
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual unsigned int GetCount() const wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual int GetCurrentSelection() const wxOVERRIDE;
virtual void SetSelection(int n) wxOVERRIDE;
virtual int FindString(const wxString& s, bool bCase = false) const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& s) wxOVERRIDE;
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// MSW only
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXHBRUSH MSWControlColor(WXHDC hDC, WXHWND hWnd) wxOVERRIDE;
virtual bool MSWShouldPreProcessMessage(WXMSG *pMsg) 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:
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// common part of all ctors
void Init()
{
m_lastAcceptedSelection =
m_pendingSelection = wxID_NONE;
m_heightOwn = wxDefaultCoord;
}
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual void DoClear() wxOVERRIDE;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
// MSW implementation
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual void DoGetSize(int *w, int *h) const wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
// Show or hide the popup part of the control.
void MSWDoPopupOrDismiss(bool show);
// update the height of the drop down list to fit the number of items we
// have (without changing the visible height)
void MSWUpdateDropDownHeight();
// set the height of the visible part of the control to m_heightOwn
void MSWUpdateVisibleHeight();
// create and initialize the control
bool CreateAndInit(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name);
// free all memory we have (used by Clear() and dtor)
void Free();
// set the height for simple combo box
int SetHeightSimpleComboBox(int nItems) const;
#if wxUSE_DEFERRED_SIZING
virtual void MSWEndDeferWindowPos() wxOVERRIDE;
#endif // wxUSE_DEFERRED_SIZING
// These variables are only used while the drop down is opened.
//
// The first one contains the item that had been originally selected before
// the drop down was opened and the second one the item we should select
// when the drop down is closed again.
int m_lastAcceptedSelection,
m_pendingSelection;
// the height of the control itself if it was set explicitly or
// wxDefaultCoord if it hadn't
int m_heightOwn;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxChoice);
};
#endif // _WX_CHOICE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/bitmap.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/bitmap.h
// Purpose: wxBitmap class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#include "wx/msw/gdiimage.h"
#include "wx/math.h"
#include "wx/palette.h"
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;
class WXDLLIMPEXP_FWD_CORE wxBitmapRefData;
class WXDLLIMPEXP_FWD_CORE wxControl;
class WXDLLIMPEXP_FWD_CORE wxCursor;
class WXDLLIMPEXP_FWD_CORE wxDC;
#if wxUSE_WXDIB
class WXDLLIMPEXP_FWD_CORE wxDIB;
#endif
class WXDLLIMPEXP_FWD_CORE wxIcon;
class WXDLLIMPEXP_FWD_CORE wxMask;
class WXDLLIMPEXP_FWD_CORE wxPalette;
class WXDLLIMPEXP_FWD_CORE wxPixelDataBase;
// What kind of transparency should a bitmap copied from an icon or cursor
// have?
enum wxBitmapTransparency
{
wxBitmapTransparency_Auto, // default: copy alpha if the source has it
wxBitmapTransparency_None, // never create alpha
wxBitmapTransparency_Always // always use alpha
};
// ----------------------------------------------------------------------------
// wxBitmap: a mono or colour bitmap
// NOTE: for wxMSW we don't use the wxBitmapBase base class declared in bitmap.h!
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmap : public wxGDIImage,
public wxBitmapHelpers
{
public:
// default ctor creates an invalid bitmap, you must Create() it later
wxBitmap() { }
// Initialize with raw data
wxBitmap(const char bits[], int width, int height, int depth = 1);
// Initialize with XPM data
wxBitmap(const char* const* data);
#ifdef wxNEEDS_CHARPP
wxBitmap(char** data)
{
*this = wxBitmap(const_cast<const char* const*>(data));
}
#endif
// Load a file or resource
wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
// New constructor for generalised creation from data
wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth = 1);
// Create a new, uninitialized bitmap of the given size and depth (if it
// is omitted, will create a bitmap compatible with the display)
//
// NB: this ctor will create a DIB for 24 and 32bpp bitmaps, use ctor
// taking a DC argument if you want to force using DDB in this case
wxBitmap(int width, int height, int depth = -1) { (void)Create(width, height, depth); }
wxBitmap(const wxSize& sz, int depth = -1) { (void)Create(sz, depth); }
// Create a bitmap compatible with the given DC
wxBitmap(int width, int height, const wxDC& dc);
#if wxUSE_IMAGE
// Convert from wxImage
wxBitmap(const wxImage& image, int depth = -1, double WXUNUSED(scale) = 1.0)
{ (void)CreateFromImage(image, depth); }
// Create a DDB compatible with the given DC from wxImage
wxBitmap(const wxImage& image, const wxDC& dc)
{ (void)CreateFromImage(image, dc); }
#endif // wxUSE_IMAGE
// we must have this, otherwise icons are silently copied into bitmaps using
// the copy ctor but the resulting bitmap is invalid!
wxBitmap(const wxIcon& icon,
wxBitmapTransparency transp = wxBitmapTransparency_Auto)
{
CopyFromIcon(icon, transp);
}
// Convert from wxCursor
explicit wxBitmap(const wxCursor& cursor)
{
(void)CopyFromCursor(cursor, wxBitmapTransparency_Auto);
}
#if wxUSE_IMAGE
wxBitmap& operator=(const wxImage& image)
{
return *this = wxBitmap(image);
}
#endif // wxUSE_IMAGE
wxBitmap& operator=(const wxIcon& icon)
{
(void)CopyFromIcon(icon);
return *this;
}
#if WXWIN_COMPATIBILITY_3_0
// This assignment operator is not portable as it is not implemented in any
// other ports.
wxDEPRECATED_MSG("Don't assign wxCursor to an existing wxBitmap, create a new wxBitmap from wxCursor instead.")
wxBitmap& operator=(const wxCursor& cursor)
{
(void)CopyFromCursor(cursor);
return *this;
}
#endif // WXWIN_COMPATIBILITY_3_0
virtual ~wxBitmap();
#if wxUSE_IMAGE
wxImage ConvertToImage() const;
wxBitmap ConvertToDisabled(unsigned char brightness = 255) const;
#endif // wxUSE_IMAGE
// get the given part of bitmap
wxBitmap GetSubBitmap( const wxRect& rect ) const;
// NB: This should not be called from user code. It is for wx internal
// use only.
wxBitmap GetSubBitmapOfHDC( const wxRect& rect, WXHDC hdc ) const;
// copies the contents and mask of the given (colour) icon to the bitmap
bool CopyFromIcon(const wxIcon& icon,
wxBitmapTransparency transp = wxBitmapTransparency_Auto);
// copies the contents and mask of the given cursor to the bitmap
bool CopyFromCursor(const wxCursor& cursor,
wxBitmapTransparency transp = wxBitmapTransparency_Auto);
#if wxUSE_WXDIB
// copies from a device independent bitmap
bool CopyFromDIB(const wxDIB& dib);
bool IsDIB() const;
bool ConvertToDIB();
#endif
virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
virtual bool Create(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH)
{ return Create(sz.GetWidth(), sz.GetHeight(), depth); }
virtual bool Create(int width, int height, const wxDC& dc);
virtual bool Create(const void* data, wxBitmapType type, int width, int height, int depth = 1);
virtual bool CreateScaled(int w, int h, int d, double logicalScale)
{ return Create(wxRound(w*logicalScale), wxRound(h*logicalScale), d); }
virtual bool LoadFile(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
virtual bool SaveFile(const wxString& name, wxBitmapType type, const wxPalette *cmap = NULL) const;
wxBitmapRefData *GetBitmapData() const
{ return (wxBitmapRefData *)m_refData; }
// raw bitmap access support functions
void *GetRawData(wxPixelDataBase& data, int bpp);
void UngetRawData(wxPixelDataBase& data);
#if wxUSE_PALETTE
wxPalette* GetPalette() const;
void SetPalette(const wxPalette& palette);
#endif // wxUSE_PALETTE
wxMask *GetMask() const;
void SetMask(wxMask *mask);
// these functions are internal and shouldn't be used, they risk to
// disappear in the future
bool HasAlpha() const;
void UseAlpha(bool use = true);
void ResetAlpha() { UseAlpha(false); }
// support for scaled bitmaps
virtual double GetScaleFactor() const { return 1.0; }
virtual double GetScaledWidth() const { return GetWidth() / GetScaleFactor(); }
virtual double GetScaledHeight() const { return GetHeight() / GetScaleFactor(); }
virtual wxSize GetScaledSize() const
{ return wxSize(wxRound(GetScaledWidth()), wxRound(GetScaledHeight())); }
// implementation only from now on
// -------------------------------
// Set alpha flag to true if this is a 32bpp bitmap which has any non-0
// values in its alpha channel.
void MSWUpdateAlpha();
public:
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_INLINE(void SetHBITMAP(WXHBITMAP bmp), SetHandle((WXHANDLE)bmp); )
#endif // WXWIN_COMPATIBILITY_3_0
WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
bool InitFromHBITMAP(WXHBITMAP bmp, int width, int height, int depth);
void ResetHBITMAP() { InitFromHBITMAP(NULL, 0, 0, 0); }
void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const;
protected:
virtual wxGDIImageRefData *CreateData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
// creates an uninitialized bitmap, called from Create()s above
bool DoCreate(int w, int h, int depth, WXHDC hdc);
#if wxUSE_IMAGE
// creates the bitmap from wxImage, supposed to be called from ctor
bool CreateFromImage(const wxImage& image, int depth);
// creates a DDB from wxImage, supposed to be called from ctor
bool CreateFromImage(const wxImage& image, const wxDC& dc);
// common part of the 2 methods above (hdc may be 0)
bool CreateFromImage(const wxImage& image, int depth, WXHDC hdc);
#endif // wxUSE_IMAGE
private:
// common part of CopyFromIcon/CopyFromCursor for Win32
bool
CopyFromIconOrCursor(const wxGDIImage& icon,
wxBitmapTransparency transp = wxBitmapTransparency_Auto);
wxDECLARE_DYNAMIC_CLASS(wxBitmap);
};
// ----------------------------------------------------------------------------
// wxMask: a mono bitmap used for drawing bitmaps transparently.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMask : public wxObject
{
public:
wxMask();
// Copy constructor
wxMask(const wxMask &mask);
// Construct a mask from a bitmap and a colour indicating the transparent
// area
wxMask(const wxBitmap& bitmap, const wxColour& colour);
// Construct a mask from a bitmap and a palette index indicating the
// transparent area
wxMask(const wxBitmap& bitmap, int paletteIndex);
// Construct a mask from a mono bitmap (copies the bitmap).
wxMask(const wxBitmap& bitmap);
// construct a mask from the givne bitmap handle
wxMask(WXHBITMAP hbmp) { m_maskBitmap = hbmp; }
virtual ~wxMask();
bool Create(const wxBitmap& bitmap, const wxColour& colour);
bool Create(const wxBitmap& bitmap, int paletteIndex);
bool Create(const wxBitmap& bitmap);
wxBitmap GetBitmap() const;
// Implementation
WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
protected:
WXHBITMAP m_maskBitmap;
wxDECLARE_DYNAMIC_CLASS(wxMask);
};
// ----------------------------------------------------------------------------
// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
// NOTE: for wxMSW we don't use the wxBitmapHandler class declared in bitmap.h!
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapHandler : public wxGDIImageHandler
{
public:
wxBitmapHandler() { }
wxBitmapHandler(const wxString& name, const wxString& ext, wxBitmapType type)
: wxGDIImageHandler(name, ext, type) { }
// implement wxGDIImageHandler's pure virtuals:
virtual bool Create(wxGDIImage *image,
const void* data,
wxBitmapType type,
int width, int height, int depth = 1) wxOVERRIDE;
virtual bool Load(wxGDIImage *image,
const wxString& name,
wxBitmapType type,
int desiredWidth, int desiredHeight) wxOVERRIDE;
virtual bool Save(const wxGDIImage *image,
const wxString& name,
wxBitmapType type) const wxOVERRIDE;
// make wxBitmapHandler compatible with the wxBitmapHandler interface
// declared in bitmap.h, even if it's derived from wxGDIImageHandler:
virtual bool Create(wxBitmap *bitmap,
const void* data,
wxBitmapType type,
int width, int height, int depth = 1);
virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name,
wxBitmapType type,
int desiredWidth, int desiredHeight);
virtual bool SaveFile(const wxBitmap *bitmap,
const wxString& name,
wxBitmapType type,
const wxPalette *palette = NULL) const;
private:
wxDECLARE_DYNAMIC_CLASS(wxBitmapHandler);
};
#endif
// _WX_BITMAP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/uxtheme.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/uxtheme.h
// Purpose: wxUxThemeEngine class: support for XP themes
// Author: John Platts, Vadim Zeitlin
// Modified by:
// Created: 2003
// Copyright: (c) 2003 John Platts, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UXTHEME_H_
#define _WX_UXTHEME_H_
#include "wx/defs.h"
#if wxUSE_UXTHEME
#include "wx/msw/private.h" // we use GetHwndOf()
#include <uxtheme.h>
#if defined(DTPB_WINDOWDC)
// DTPB_WINDOWDC has been added for Vista so it's save to assume that an SDK
// including it has vssym32.h available
#define HAVE_VSSYM32
#endif
#if defined(HAVE_VSSYM32)
#include <vssym32.h>
#else
#include <tmschema.h>
#endif
// ----------------------------------------------------------------------------
// Definitions for legacy Windows SDKs
// ----------------------------------------------------------------------------
// Some defintions introduced with Windows Vista might be missing in older SDKs
// Missing defintions are added here for compatiblity
#ifndef VSCLASS_LISTVIEW
#define LISS_NORMAL 1
#define LISS_HOT 2
#define LISS_SELECTED 3
#define LISS_DISABLED 4
#define LISS_SELECTEDNOTFOCUS 5
#define LISS_HOTSELECTED 6
#endif
#ifndef DTT_TEXTCOLOR
#define DTT_TEXTCOLOR (1UL << 0) // crText has been specified
#define DTT_STATEID (1UL << 8) // IStateId has been specified
#endif
#ifndef DSS_HIDEPREFIX
#define DSS_HIDEPREFIX 0x0200
#define DSS_PREFIXONLY 0x0400
#endif
#ifndef TMT_FONT
#define TMT_FONT 210
#endif
#ifndef HAVE_VSSYM32
enum EXPANDOBUTTONSTATES {
TDLGEBS_NORMAL = 1,
TDLGEBS_HOVER = 2,
TDLGEBS_PRESSED = 3,
TDLGEBS_EXPANDEDNORMAL = 4,
TDLGEBS_EXPANDEDHOVER = 5,
TDLGEBS_EXPANDEDPRESSED = 6,
TDLGEBS_NORMALDISABLED = 7,
TDLGEBS_EXPANDEDDISABLED = 8,
};
enum TASKDIALOGPARTS {
TDLG_PRIMARYPANEL = 1,
TDLG_MAININSTRUCTIONPANE = 2,
TDLG_MAINICON = 3,
TDLG_CONTENTPANE = 4,
TDLG_CONTENTICON = 5,
TDLG_EXPANDEDCONTENT = 6,
TDLG_COMMANDLINKPANE = 7,
TDLG_SECONDARYPANEL = 8,
TDLG_CONTROLPANE = 9,
TDLG_BUTTONSECTION = 10,
TDLG_BUTTONWRAPPER = 11,
TDLG_EXPANDOTEXT = 12,
TDLG_EXPANDOBUTTON = 13,
TDLG_VERIFICATIONTEXT = 14,
TDLG_FOOTNOTEPANE = 15,
TDLG_FOOTNOTEAREA = 16,
TDLG_FOOTNOTESEPARATOR = 17,
TDLG_EXPANDEDFOOTERAREA = 18,
TDLG_PROGRESSBAR = 19,
TDLG_IMAGEALIGNMENT = 20,
TDLG_RADIOBUTTONPANE = 21,
};
#define CP_BACKGROUND 2
#define CP_TRANSPARENTBACKGROUND 3
#define CP_BORDER 4
#define CP_READONLY 5
#define CP_DROPDOWNBUTTONRIGHT 6
#define CP_DROPDOWNBUTTONLEFT 7
#define CP_CUEBANNER 8
#define RP_BACKGROUND 6
#define RP_SPLITTER 7
#define RP_SPLITTERVERT 8
enum BORDERSTATES {
CBB_NORMAL = 1,
CBB_HOT = 2,
CBB_FOCUSED = 3,
CBB_DISABLED = 4,
};
// The MENUPARTS enum is defined in MSVS 2005 SDK, even though it doesn't have
// vssym32.h, but it doesn't define the constants we use, so still define them,
// but make the enum unnamed for compatibility.
enum /* MENUPARTS -- FIXME-VC8: uncomment this when support for it is dropped */
{
MENU_MENUITEM_TMSCHEMA = 1,
MENU_SEPARATOR_TMSCHEMA = 6,
MENU_POPUPBACKGROUND = 9,
MENU_POPUPBORDERS = 10,
MENU_POPUPCHECK = 11,
MENU_POPUPCHECKBACKGROUND = 12,
MENU_POPUPGUTTER = 13,
MENU_POPUPITEM = 14,
MENU_POPUPSEPARATOR = 15,
MENU_POPUPSUBMENU = 16,
};
enum POPUPITEMSTATES
{
MPI_NORMAL = 1,
MPI_HOT = 2,
MPI_DISABLED = 3,
MPI_DISABLEDHOT = 4,
};
enum POPUPCHECKBACKGROUNDSTATES
{
MCB_DISABLED = 1,
MCB_NORMAL = 2,
MCB_BITMAP = 3,
};
enum POPUPCHECKSTATES
{
MC_CHECKMARKNORMAL = 1,
MC_CHECKMARKDISABLED = 2,
MC_BULLETNORMAL = 3,
MC_BULLETDISABLED = 4,
};
#endif
// ----------------------------------------------------------------------------
// End definitions for legacy Windows SDKs
// ----------------------------------------------------------------------------
// Amazingly, GetThemeFont() and GetThemeSysFont() functions use LOGFONTA under
// XP but LOGFONTW (even in non-Unicode build) under later versions of Windows.
// If we declare them as taking LOGFONT below, the code would be able to
// silently pass LOGFONTA to them in ANSI build and would crash at run-time
// under Windows Vista/7 because of a buffer overrun (LOGFONTA being smaller
// than LOGFONTW expected by these functions). If we we declare them as taking
// LOGFONTW, the code wouldn't work correctly under XP. So we use a special
// wxUxThemeFont class to encapsulate this and intentionally change the LOGFONT
// output parameters of the theme functions to take it instead.
class wxUxThemeFont
{
public:
// Trivial default ctor.
wxUxThemeFont() { }
#if wxUSE_UNICODE
// In Unicode build we always use LOGFONT anyhow so this class is
// completely trivial.
LPLOGFONTW GetPtr() { return &m_lfW; }
const LOGFONTW& GetLOGFONT() { return m_lfW; }
#else // !wxUSE_UNICODE
// Return either LOGFONTA or LOGFONTW pointer as required by the current
// Windows version.
LPLOGFONTW GetPtr()
{
return UseLOGFONTW() ? &m_lfW
: reinterpret_cast<LPLOGFONTW>(&m_lfA);
}
// This method returns LOGFONT (i.e. LOGFONTA in ANSI build and LOGFONTW in
// Unicode one) which can be used with other, normal, Windows or wx
// functions. Internally it may need to transform LOGFONTW to LOGFONTA.
const LOGFONTA& GetLOGFONT()
{
if ( UseLOGFONTW() )
{
// Most of the fields are the same in LOGFONTA and LOGFONTW so just
// copy everything by default.
memcpy(&m_lfA, &m_lfW, sizeof(m_lfA));
// But the face name must be converted from Unicode.
WideCharToMultiByte(CP_ACP, 0, m_lfW.lfFaceName, -1,
m_lfA.lfFaceName, sizeof(m_lfA.lfFaceName),
NULL, NULL);
}
return m_lfA;
}
private:
static bool UseLOGFONTW()
{
return wxGetWinVersion() >= wxWinVersion_Vista;
}
LOGFONTA m_lfA;
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
private:
LOGFONTW m_lfW;
wxDECLARE_NO_COPY_CLASS(wxUxThemeFont);
};
WXDLLIMPEXP_CORE bool wxUxThemeIsActive();
// ----------------------------------------------------------------------------
// wxUxThemeHandle: encapsulates ::Open/CloseThemeData()
// ----------------------------------------------------------------------------
class wxUxThemeHandle
{
public:
wxUxThemeHandle(const wxWindow *win, const wchar_t *classes)
{
m_hTheme = (HTHEME)::OpenThemeData(GetHwndOf(win), classes);
}
operator HTHEME() const { return m_hTheme; }
~wxUxThemeHandle()
{
if ( m_hTheme )
{
::CloseThemeData(m_hTheme);
}
}
private:
HTHEME m_hTheme;
wxDECLARE_NO_COPY_CLASS(wxUxThemeHandle);
};
#else // !wxUSE_UXTHEME
inline bool wxUxThemeIsActive() { return false; }
#endif // wxUSE_UXTHEME/!wxUSE_UXTHEME
#endif // _WX_UXTHEME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/mfc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/mfc.h
// Purpose: Helpers for applications using both wxWidgets and MFC
// Author: Julian Smart, Vadim Zeitlin
// Created: 2017-12-01 (mostly extracted from samples/mfc)
// Copyright: (c) 2017 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_MFC_H_
#define _WX_MSW_MFC_H_
#ifndef __AFXWIN_H__
#error "MFC headers must be included before including this file."
#endif
#include "wx/app.h"
#include "wx/evtloop.h"
#include "wx/window.h"
#include "wx/msw/winundef.h"
// ----------------------------------------------------------------------------
// MFC window class wrapping a window created by wxWidgets
// ----------------------------------------------------------------------------
class wxMFCWnd : public CWnd
{
public:
// If default ctor is used, Attach() must be called later.
wxMFCWnd()
{
}
// Combines default ctor and Attach().
explicit wxMFCWnd(wxWindow* w)
{
Attach(w);
}
void Attach(wxWindow* w)
{
CWnd::Attach(w->GetHWND());
}
~wxMFCWnd()
{
// Prevent MFC from destroying the wxWindow.
Detach();
}
};
// ----------------------------------------------------------------------------
// MFC application class forwarding everything to wxApp
// ----------------------------------------------------------------------------
// The template parameter here is an existing class deriving from CWinApp or,
// if there is no such class, just CWinApp itself.
template <typename T>
class wxMFCApp : public T
{
public:
typedef T BaseApp;
BOOL InitInstance() wxOVERRIDE
{
if ( !BaseApp::InitInstance() )
return FALSE;
if ( !wxEntryStart(m_hInstance) )
return FALSE;
if ( !wxTheApp || !wxTheApp->CallOnInit() )
return FALSE;
if ( !InitMainWnd() )
return FALSE;
return TRUE;
}
int ExitInstance() wxOVERRIDE
{
delete m_pMainWnd;
m_pMainWnd = NULL;
if ( wxTheApp )
wxTheApp->OnExit();
wxEntryCleanup();
return BaseApp::ExitInstance();
}
// Override this to provide messages pre-processing for wxWidgets windows.
BOOL PreTranslateMessage(MSG *msg) wxOVERRIDE
{
// Use the current event loop if there is one, or just fall back to the
// standard one otherwise, but make sure we pre-process messages in any
// case as otherwise many things would break (e.g. keyboard
// accelerators).
wxGUIEventLoop*
evtLoop = static_cast<wxGUIEventLoop *>(wxEventLoop::GetActive());
wxGUIEventLoop evtLoopStd;
if ( !evtLoop )
evtLoop = &evtLoopStd;
if ( evtLoop->PreProcessMessage(msg) )
return TRUE;
return BaseApp::PreTranslateMessage(msg);
}
BOOL OnIdle(LONG lCount) wxOVERRIDE
{
BOOL moreIdle = BaseApp::OnIdle(lCount);
if ( wxTheApp )
{
wxTheApp->ProcessPendingEvents();
if ( wxTheApp->ProcessIdle() )
moreIdle = TRUE;
}
return moreIdle;
}
protected:
// This virtual method can be overridden to create the main window using
// MFC code. The default implementation relies on wxApp::OnInit() creating
// a top level window which is then wrapped in an MFC window and used as
// the main window.
virtual BOOL InitMainWnd()
{
wxWindow* const w = wxTheApp->GetTopWindow();
if ( !w )
return FALSE;
// We need to initialize the main window to let the program continue
// running.
m_pMainWnd = new wxMFCWnd(w);
// We also need to reset m_pMainWnd when this window will be destroyed
// to prevent MFC from using an invalid HWND, which is probably not
// fatal but can result in at least asserts failures.
w->Bind(wxEVT_DESTROY, &wxMFCApp::OnMainWindowDestroyed, this);
// And we need to let wxWidgets know that it should exit the
// application when this window is closed, as OnRun(), which does this
// by default, won't be called when using MFC main message loop.
wxTheApp->SetExitOnFrameDelete(true);
return TRUE;
}
private:
void OnMainWindowDestroyed(wxWindowDestroyEvent& event)
{
event.Skip();
delete m_pMainWnd;
m_pMainWnd = NULL;
}
};
typedef wxMFCApp<CWinApp> wxMFCWinApp;
// ----------------------------------------------------------------------------
// wxWidgets application class to be used in MFC applications
// ----------------------------------------------------------------------------
class wxAppWithMFC : public wxApp
{
public:
void ExitMainLoop() wxOVERRIDE
{
// There is no wxEventLoop to exit, tell MFC to stop pumping messages
// instead.
::PostQuitMessage(0);
}
void WakeUpIdle() wxOVERRIDE
{
// As above, we can't wake up any wx event loop, so try to wake up the
// MFC one instead.
CWinApp* const mfcApp = AfxGetApp();
if ( mfcApp && mfcApp->m_pMainWnd )
{
::PostMessage(mfcApp->m_pMainWnd->m_hWnd, WM_NULL, 0, 0);
}
}
};
#endif // _WX_MSW_MFC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/ctrlsub.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ctrlsub.h
// Purpose: common functionality of wxItemContainer-derived controls
// Author: Vadim Zeitlin
// Created: 2007-07-25
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CTRLSUB_H_
#define _WX_MSW_CTRLSUB_H_
// ----------------------------------------------------------------------------
// wxControlWithItems
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxControlWithItems : public wxControlWithItemsBase
{
public:
wxControlWithItems() { }
protected:
// preallocate memory for inserting the given new items into the control
// using the wm message (normally either LB_INITSTORAGE or CB_INITSTORAGE)
void MSWAllocStorage(const wxArrayStringsAdapter& items, unsigned wm);
// insert or append a string to the controls using the given message
// (one of {CB,LB}_{ADD,INSERT}STRING, pos must be 0 when appending)
int MSWInsertOrAppendItem(unsigned pos, const wxString& item, unsigned wm);
// normally the control containing the items is this window itself but if
// the derived control is composed of several windows, this method can be
// overridden to return the real list/combobox control
virtual WXHWND MSWGetItemsHWND() const { return GetHWND(); }
private:
wxDECLARE_ABSTRACT_CLASS(wxControlWithItems);
wxDECLARE_NO_COPY_CLASS(wxControlWithItems);
};
#endif // _WX_MSW_CTRLSUB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/commandlinkbutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/commandlinkbutton.h
// Purpose: wxCommandLinkButton class
// Author: Rickard Westerlund
// Created: 2010-06-11
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_COMMANDLINKBUTTON_H_
#define _WX_MSW_COMMANDLINKBUTTON_H_
// ----------------------------------------------------------------------------
// Command link button for wxMSW
// ----------------------------------------------------------------------------
// Derive from the generic version to be able to fall back to it during
// run-time if the command link buttons are not supported by the system we're
// running under.
class WXDLLIMPEXP_ADV wxCommandLinkButton : public wxGenericCommandLinkButton
{
public:
wxCommandLinkButton () : wxGenericCommandLinkButton() { }
wxCommandLinkButton(wxWindow *parent,
wxWindowID id,
const wxString& mainLabel = wxEmptyString,
const wxString& note = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
: wxGenericCommandLinkButton()
{
Create(parent, id, mainLabel, note, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& mainLabel = wxEmptyString,
const wxString& note = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
// overridden base class methods
// -----------------------------
// do the same thing as in the generic case here
virtual void SetLabel(const wxString& label) wxOVERRIDE
{
SetMainLabelAndNote(label.BeforeFirst('\n'), label.AfterFirst('\n'));
}
virtual void SetMainLabelAndNote(const wxString& mainLabel,
const wxString& note) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual bool HasNativeBitmap() const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCommandLinkButton);
};
#endif // _WX_MSW_COMMANDLINKBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dragimag.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dragimag.h
// Purpose: wxDragImage class: a kind of a cursor, that can cope
// with more sophisticated images
// Author: Julian Smart
// Modified by:
// Created: 08/04/99
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DRAGIMAG_H_
#define _WX_DRAGIMAG_H_
#if wxUSE_DRAGIMAGE
#include "wx/bitmap.h"
#include "wx/icon.h"
#include "wx/cursor.h"
#include "wx/treectrl.h"
#include "wx/listctrl.h"
// If 1, use a simple wxCursor instead of ImageList_SetDragCursorImage
#define wxUSE_SIMPLER_DRAGIMAGE 0
/*
To use this class, create a wxDragImage when you start dragging, for example:
void MyTreeCtrl::OnBeginDrag(wxTreeEvent& event)
{
#ifdef __WXMSW__
::UpdateWindow((HWND) GetHWND()); // We need to implement this in wxWidgets
#endif
CaptureMouse();
m_dragImage = new wxDragImage(* this, itemId);
m_dragImage->BeginDrag(wxPoint(0, 0), this);
m_dragImage->Move(pt, this);
m_dragImage->Show(this);
...
}
In your OnMouseMove function, hide the image, do any display updating required,
then move and show the image again:
void MyTreeCtrl::OnMouseMove(wxMouseEvent& event)
{
if (m_dragMode == MY_TREE_DRAG_NONE)
{
event.Skip();
return;
}
// Prevent screen corruption by hiding the image
if (m_dragImage)
m_dragImage->Hide(this);
// Do some updating of the window, such as highlighting the drop target
...
#ifdef __WXMSW__
if (updateWindow)
::UpdateWindow((HWND) GetHWND());
#endif
// Move and show the image again
m_dragImage->Move(event.GetPosition(), this);
m_dragImage->Show(this);
}
Eventually we end the drag and delete the drag image.
void MyTreeCtrl::OnLeftUp(wxMouseEvent& event)
{
...
// End the drag and delete the drag image
if (m_dragImage)
{
m_dragImage->EndDrag(this);
delete m_dragImage;
m_dragImage = NULL;
}
ReleaseMouse();
}
*/
/*
Notes for Unix version:
Can we simply use cursors instead, creating a cursor dynamically, setting it into the window
in BeginDrag, and restoring the old cursor in EndDrag?
For a really bog-standard implementation, we could simply use a normal dragging cursor
and ignore the image.
*/
/*
* wxDragImage
*/
class WXDLLIMPEXP_CORE wxDragImage: public wxObject
{
public:
// Ctors & dtor
////////////////////////////////////////////////////////////////////////////
wxDragImage();
wxDragImage(const wxBitmap& image, const wxCursor& cursor = wxNullCursor)
{
Init();
Create(image, cursor);
}
wxDragImage(const wxIcon& image, const wxCursor& cursor = wxNullCursor)
{
Init();
Create(image, cursor);
}
wxDragImage(const wxString& str, const wxCursor& cursor = wxNullCursor)
{
Init();
Create(str, cursor);
}
#if wxUSE_TREECTRL
wxDragImage(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)
{
Init();
Create(treeCtrl, id);
}
#endif
#if wxUSE_LISTCTRL
wxDragImage(const wxListCtrl& listCtrl, long id)
{
Init();
Create(listCtrl, id);
}
#endif
virtual ~wxDragImage();
// Attributes
////////////////////////////////////////////////////////////////////////////
// Operations
////////////////////////////////////////////////////////////////////////////
// Create a drag image from a bitmap and optional cursor
bool Create(const wxBitmap& image, const wxCursor& cursor = wxNullCursor);
// Create a drag image from an icon and optional cursor
bool Create(const wxIcon& image, const wxCursor& cursor = wxNullCursor);
// Create a drag image from a string and optional cursor
bool Create(const wxString& str, const wxCursor& cursor = wxNullCursor);
#if wxUSE_TREECTRL
// Create a drag image for the given tree control item
bool Create(const wxTreeCtrl& treeCtrl, wxTreeItemId& id);
#endif
#if wxUSE_LISTCTRL
// Create a drag image for the given list control item
bool Create(const wxListCtrl& listCtrl, long id);
#endif
// Begin drag. hotspot is the location of the drag position relative to the upper-left
// corner of the image.
bool BeginDrag(const wxPoint& hotspot, wxWindow* window, bool fullScreen = false, wxRect* rect = NULL);
// Begin drag. hotspot is the location of the drag position relative to the upper-left
// corner of the image. This is full screen only. fullScreenRect gives the
// position of the window on the screen, to restrict the drag to.
bool BeginDrag(const wxPoint& hotspot, wxWindow* window, wxWindow* fullScreenRect);
// End drag
bool EndDrag();
// Move the image: call from OnMouseMove. Pt is in window client coordinates if window
// is non-NULL, or in screen coordinates if NULL.
bool Move(const wxPoint& pt);
// Show the image
bool Show();
// Hide the image
bool Hide();
// Implementation
////////////////////////////////////////////////////////////////////////////
// Initialize variables
void Init();
// Returns the native image list handle
WXHIMAGELIST GetHIMAGELIST() const { return m_hImageList; }
#if !wxUSE_SIMPLER_DRAGIMAGE
// Returns the native image list handle for the cursor
WXHIMAGELIST GetCursorHIMAGELIST() const { return m_hCursorImageList; }
#endif
// don't use in new code, use versions without hot spot parameter
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR( wxDragImage(const wxBitmap& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED_CONSTRUCTOR( wxDragImage(const wxString& str, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED_CONSTRUCTOR( wxDragImage(const wxIcon& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED( bool Create(const wxBitmap& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED( bool Create(const wxIcon& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED( bool Create(const wxString& str, const wxCursor& cursor, const wxPoint& cursorHotspot) );
#endif // WXWIN_COMPATIBILITY_2_8
protected:
WXHIMAGELIST m_hImageList;
#if wxUSE_SIMPLER_DRAGIMAGE
wxCursor m_oldCursor;
#else
WXHIMAGELIST m_hCursorImageList;
#endif
wxCursor m_cursor;
// wxPoint m_cursorHotspot; // Obsolete
wxPoint m_position;
wxWindow* m_window;
wxRect m_boundingRect;
bool m_fullScreen;
private:
wxDECLARE_DYNAMIC_CLASS(wxDragImage);
wxDECLARE_NO_COPY_CLASS(wxDragImage);
};
#endif // wxUSE_DRAGIMAGE
#endif
// _WX_DRAGIMAG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/taskbar.h | /////////////////////////////////////////////////////////////////////////
// File: wx/msw/taskbar.h
// Purpose: Defines wxTaskBarIcon class for manipulating icons on the
// Windows task bar.
// Author: Julian Smart
// Modified by: Vaclav Slavik
// Created: 24/3/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////
#ifndef _WX_TASKBAR_H_
#define _WX_TASKBAR_H_
#include "wx/icon.h"
// private helper class:
class WXDLLIMPEXP_FWD_CORE wxTaskBarIconWindow;
class WXDLLIMPEXP_CORE wxTaskBarIcon : public wxTaskBarIconBase
{
public:
wxTaskBarIcon(wxTaskBarIconType iconType = wxTBI_DEFAULT_TYPE);
virtual ~wxTaskBarIcon();
// Accessors
bool IsOk() const { return true; }
bool IsIconInstalled() const { return m_iconAdded; }
// Operations
bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxEmptyString) wxOVERRIDE;
bool RemoveIcon(void) wxOVERRIDE;
bool PopupMenu(wxMenu *menu) wxOVERRIDE;
// MSW-specific class methods
#if wxUSE_TASKBARICON_BALLOONS
// show a balloon notification (the icon must have been already initialized
// using SetIcon)
//
// title and text are limited to 63 and 255 characters respectively, msec
// is the timeout, in milliseconds, before the balloon disappears (will be
// clamped down to the allowed 10-30s range by Windows if it's outside it)
// and flags can include wxICON_ERROR/INFO/WARNING to show a corresponding
// icon
//
// return true if balloon was shown, false on error (incorrect parameters
// or function unsupported by OS)
bool ShowBalloon(const wxString& title,
const wxString& text,
unsigned msec = 0,
int flags = 0,
const wxIcon& icon = wxNullIcon);
#endif // wxUSE_TASKBARICON_BALLOONS
protected:
friend class wxTaskBarIconWindow;
long WindowProc(unsigned int msg, unsigned int wParam, long lParam);
void RegisterWindowMessages();
wxTaskBarIconWindow *m_win;
bool m_iconAdded;
wxIcon m_icon;
wxString m_strTooltip;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTaskBarIcon);
};
#endif // _WX_TASKBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/minifram.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/minifram.h
// Purpose: wxMiniFrame class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MINIFRAM_H_
#define _WX_MINIFRAM_H_
#include "wx/frame.h"
class WXDLLIMPEXP_CORE wxMiniFrame : public wxFrame
{
public:
wxMiniFrame() { }
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAPTION | wxCLIP_CHILDREN | wxRESIZE_BORDER,
const wxString& name = wxFrameNameStr)
{
return wxFrame::Create(parent, id, title, pos, size,
style |
wxFRAME_TOOL_WINDOW |
(parent ? wxFRAME_FLOAT_ON_PARENT : 0), name);
}
wxMiniFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAPTION | wxCLIP_CHILDREN | wxRESIZE_BORDER,
const wxString& name = wxFrameNameStr)
{
Create(parent, id, title, pos, size, style, name);
}
protected:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMiniFrame);
};
#endif
// _WX_MINIFRAM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/pen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/pen.h
// Purpose: wxPen class
// Author: Julian Smart
// Modified by: Vadim Zeitlin: fixed operator=(), ==(), !=()
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PEN_H_
#define _WX_PEN_H_
#include "wx/gdiobj.h"
#include "wx/gdicmn.h"
// ----------------------------------------------------------------------------
// Pen
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPen : public wxPenBase
{
public:
wxPen() { }
wxPen(const wxColour& col, int width = 1, wxPenStyle style = wxPENSTYLE_SOLID);
wxPen(const wxBitmap& stipple, int width);
wxPen(const wxPenInfo& info);
virtual ~wxPen() { }
bool operator==(const wxPen& pen) const;
bool operator!=(const wxPen& pen) const { return !(*this == pen); }
// Override in order to recreate the pen
void SetColour(const wxColour& col) wxOVERRIDE;
void SetColour(unsigned char r, unsigned char g, unsigned char b) wxOVERRIDE;
void SetWidth(int width) wxOVERRIDE;
void SetStyle(wxPenStyle style) wxOVERRIDE;
void SetStipple(const wxBitmap& stipple) wxOVERRIDE;
void SetDashes(int nb_dashes, const wxDash *dash) wxOVERRIDE;
void SetJoin(wxPenJoin join) wxOVERRIDE;
void SetCap(wxPenCap cap) wxOVERRIDE;
wxColour GetColour() const wxOVERRIDE;
int GetWidth() const wxOVERRIDE;
wxPenStyle GetStyle() const wxOVERRIDE;
wxPenJoin GetJoin() const wxOVERRIDE;
wxPenCap GetCap() const wxOVERRIDE;
int GetDashes(wxDash** ptr) const wxOVERRIDE;
wxDash* GetDash() const;
int GetDashCount() const;
wxBitmap* GetStipple() const wxOVERRIDE;
wxDEPRECATED_MSG("use wxPENSTYLE_XXX constants")
wxPen(const wxColour& col, int width, int style);
wxDEPRECATED_MSG("use wxPENSTYLE_XXX constants")
void SetStyle(int style) { SetStyle((wxPenStyle)style); }
// internal: wxGDIObject methods
virtual bool RealizeResource() wxOVERRIDE;
virtual bool FreeResource(bool force = false) wxOVERRIDE;
virtual WXHANDLE GetResourceHandle() const wxOVERRIDE;
virtual bool IsFree() const wxOVERRIDE;
protected:
virtual wxGDIRefData* CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData* CloneGDIRefData(const wxGDIRefData* data) const wxOVERRIDE;
// same as FreeResource() + RealizeResource()
bool Recreate();
wxDECLARE_DYNAMIC_CLASS(wxPen);
};
#endif // _WX_PEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dialog.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dialog.h
// Purpose: wxDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIALOG_H_
#define _WX_DIALOG_H_
#include "wx/panel.h"
extern WXDLLIMPEXP_DATA_CORE(const char) wxDialogNameStr[];
class WXDLLIMPEXP_FWD_CORE wxDialogModalData;
// Dialog boxes
class WXDLLIMPEXP_CORE wxDialog : public wxDialogBase
{
public:
wxDialog() { Init(); }
// full ctor
wxDialog(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxDialogNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE,
const wxString& name = wxDialogNameStr);
virtual ~wxDialog();
// return true if we're showing the dialog modally
virtual bool IsModal() const wxOVERRIDE { return m_modalData != NULL; }
// show the dialog modally and return the value passed to EndModal()
virtual int ShowModal() wxOVERRIDE;
// may be called to terminate the dialog with the given return code
virtual void EndModal(int retCode) wxOVERRIDE;
// implementation only from now on
// -------------------------------
// override some base class virtuals
virtual bool Show(bool show = true) wxOVERRIDE;
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
// Windows callbacks
WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
private:
// these functions deal with the gripper window shown in the corner of
// resizable dialogs
void CreateGripper();
void DestroyGripper();
void ShowGripper(bool show);
void ResizeGripper();
// this function is used to adjust Z-order of new children relative to the
// gripper if we have one
void OnWindowCreate(wxWindowCreateEvent& event);
// gripper window for a resizable dialog, NULL if we're not resizable
WXHWND m_hGripper;
// this pointer is non-NULL only while the modal event loop is running
wxDialogModalData *m_modalData;
wxDECLARE_DYNAMIC_CLASS(wxDialog);
wxDECLARE_NO_COPY_CLASS(wxDialog);
};
#endif
// _WX_DIALOG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/icon.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/icon.h
// Purpose: wxIcon class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ICON_H_
#define _WX_ICON_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/msw/gdiimage.h"
// ---------------------------------------------------------------------------
// icon data
// ---------------------------------------------------------------------------
// notice that although wxIconRefData inherits from wxBitmapRefData, it is not
// a valid wxBitmapRefData
class WXDLLIMPEXP_CORE wxIconRefData : public wxGDIImageRefData
{
public:
wxIconRefData() { }
virtual ~wxIconRefData() { Free(); }
virtual void Free() wxOVERRIDE;
};
// ---------------------------------------------------------------------------
// Icon
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxIcon : public wxGDIImage
{
public:
// ctors
// default
wxIcon() { }
// from raw data
wxIcon(const char bits[], int width, int height);
// from XPM data
wxIcon(const char* const* data) { CreateIconFromXpm(data); }
#ifdef wxNEEDS_CHARPP
wxIcon(char **data) { CreateIconFromXpm(const_cast<const char* const*>(data)); }
#endif
// from resource/file
wxIcon(const wxString& name,
wxBitmapType type = wxICON_DEFAULT_TYPE,
int desiredWidth = -1, int desiredHeight = -1);
wxIcon(const wxIconLocation& loc);
virtual ~wxIcon();
virtual bool LoadFile(const wxString& name,
wxBitmapType type = wxICON_DEFAULT_TYPE,
int desiredWidth = -1, int desiredHeight = -1);
bool CreateFromHICON(WXHICON icon);
// implementation only from now on
wxIconRefData *GetIconData() const { return (wxIconRefData *)m_refData; }
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_INLINE(void SetHICON(WXHICON icon), SetHandle((WXHANDLE)icon); )
#endif // WXWIN_COMPATIBILITY_3_0
WXHICON GetHICON() const { return (WXHICON)GetHandle(); }
bool InitFromHICON(WXHICON icon, int width, int height);
// create from bitmap (which should have a mask unless it's monochrome):
// there shouldn't be any implicit bitmap -> icon conversion (i.e. no
// ctors, assignment operators...), but it's ok to have such function
void CopyFromBitmap(const wxBitmap& bmp);
protected:
virtual wxGDIImageRefData *CreateData() const wxOVERRIDE
{
return new wxIconRefData;
}
virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const wxOVERRIDE;
// create from XPM data
void CreateIconFromXpm(const char* const* data);
private:
wxDECLARE_DYNAMIC_CLASS(wxIcon);
};
#endif
// _WX_ICON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/cursor.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/cursor.h
// Purpose: wxCursor class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CURSOR_H_
#define _WX_CURSOR_H_
class WXDLLIMPEXP_FWD_CORE wxImage;
// Cursor
class WXDLLIMPEXP_CORE wxCursor : public wxCursorBase
{
public:
// constructors
wxCursor();
wxCursor(const wxImage& image);
wxCursor(const wxString& name,
wxBitmapType type = wxCURSOR_DEFAULT_TYPE,
int hotSpotX = 0, int hotSpotY = 0);
wxCursor(wxStockCursor id) { InitFromStock(id); }
#if WXWIN_COMPATIBILITY_2_8
wxCursor(int id) { InitFromStock((wxStockCursor)id); }
#endif
virtual wxPoint GetHotSpot() const wxOVERRIDE;
virtual ~wxCursor();
// implementation only
void SetHCURSOR(WXHCURSOR cursor) { SetHandle((WXHANDLE)cursor); }
WXHCURSOR GetHCURSOR() const { return (WXHCURSOR)GetHandle(); }
protected:
void InitFromStock(wxStockCursor);
virtual wxGDIImageRefData *CreateData() const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxCursor);
};
#endif
// _WX_CURSOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/winundef.h | /////////////////////////////////////////////////////////////////////////////
// Name: winundef.h
// Purpose: undefine the common symbols #define'd by <windows.h>
// Author: Vadim Zeitlin
// Modified by:
// Created: 16.05.99
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/* THIS SHOULD NOT BE USED since you might include it once e.g. in window.h,
* then again _AFTER_ you've included windows.h, in which case it won't work
* a 2nd time -- JACS
#ifndef _WX_WINUNDEF_H_
#define _WX_WINUNDEF_H_
*/
#ifndef wxUSE_UNICODE_WINDOWS_H
#ifdef _UNICODE
#define wxUSE_UNICODE_WINDOWS_H 1
#else
#define wxUSE_UNICODE_WINDOWS_H 0
#endif
#endif
// ----------------------------------------------------------------------------
// windows.h #defines the following identifiers which are also used in wxWin so
// we replace these symbols with the corresponding inline functions and
// undefine the macro.
//
// This looks quite ugly here but allows us to write clear (and correct!) code
// elsewhere because the functions, unlike the macros, respect the scope.
// ----------------------------------------------------------------------------
// CreateDialog
#if defined(CreateDialog)
#undef CreateDialog
inline HWND CreateDialog(HINSTANCE hInstance,
LPCTSTR pTemplate,
HWND hwndParent,
DLGPROC pDlgProc)
{
#if wxUSE_UNICODE_WINDOWS_H
return CreateDialogW(hInstance, pTemplate, hwndParent, pDlgProc);
#else
return CreateDialogA(hInstance, pTemplate, hwndParent, pDlgProc);
#endif
}
#endif
// CreateFont
#ifdef CreateFont
#undef CreateFont
inline HFONT CreateFont(int height,
int width,
int escapement,
int orientation,
int weight,
DWORD italic,
DWORD underline,
DWORD strikeout,
DWORD charset,
DWORD outprecision,
DWORD clipprecision,
DWORD quality,
DWORD family,
LPCTSTR facename)
{
#if wxUSE_UNICODE_WINDOWS_H
return CreateFontW(height, width, escapement, orientation,
weight, italic, underline, strikeout, charset,
outprecision, clipprecision, quality,
family, facename);
#else
return CreateFontA(height, width, escapement, orientation,
weight, italic, underline, strikeout, charset,
outprecision, clipprecision, quality,
family, facename);
#endif
}
#endif // CreateFont
// CreateWindow
#if defined(CreateWindow)
#undef CreateWindow
inline HWND CreateWindow(LPCTSTR lpClassName,
LPCTSTR lpWndClass,
DWORD dwStyle,
int x, int y, int w, int h,
HWND hWndParent,
HMENU hMenu,
HINSTANCE hInstance,
LPVOID lpParam)
{
#if wxUSE_UNICODE_WINDOWS_H
return CreateWindowW(lpClassName, lpWndClass, dwStyle, x, y, w, h,
hWndParent, hMenu, hInstance, lpParam);
#else
return CreateWindowA(lpClassName, lpWndClass, dwStyle, x, y, w, h,
hWndParent, hMenu, hInstance, lpParam);
#endif
}
#endif
// LoadMenu
#ifdef LoadMenu
#undef LoadMenu
inline HMENU LoadMenu(HINSTANCE instance, LPCTSTR name)
{
#if wxUSE_UNICODE_WINDOWS_H
return LoadMenuW(instance, name);
#else
return LoadMenuA(instance, name);
#endif
}
#endif
// FindText
#ifdef FindText
#undef FindText
inline HWND APIENTRY FindText(LPFINDREPLACE lpfindreplace)
{
#if wxUSE_UNICODE_WINDOWS_H
return FindTextW(lpfindreplace);
#else
return FindTextA(lpfindreplace);
#endif
}
#endif
// GetCharWidth
#ifdef GetCharWidth
#undef GetCharWidth
inline BOOL GetCharWidth(HDC dc, UINT first, UINT last, LPINT buffer)
{
#if wxUSE_UNICODE_WINDOWS_H
return GetCharWidthW(dc, first, last, buffer);
#else
return GetCharWidthA(dc, first, last, buffer);
#endif
}
#endif
// FindWindow
#ifdef FindWindow
#undef FindWindow
#if wxUSE_UNICODE_WINDOWS_H
inline HWND FindWindow(LPCWSTR classname, LPCWSTR windowname)
{
return FindWindowW(classname, windowname);
}
#else
inline HWND FindWindow(LPCSTR classname, LPCSTR windowname)
{
return FindWindowA(classname, windowname);
}
#endif
#endif
// PlaySound
#ifdef PlaySound
#undef PlaySound
#if wxUSE_UNICODE_WINDOWS_H
inline BOOL PlaySound(LPCWSTR pszSound, HMODULE hMod, DWORD fdwSound)
{
return PlaySoundW(pszSound, hMod, fdwSound);
}
#else
inline BOOL PlaySound(LPCSTR pszSound, HMODULE hMod, DWORD fdwSound)
{
return PlaySoundA(pszSound, hMod, fdwSound);
}
#endif
#endif
// GetClassName
#ifdef GetClassName
#undef GetClassName
#if wxUSE_UNICODE_WINDOWS_H
inline int GetClassName(HWND h, LPWSTR classname, int maxcount)
{
return GetClassNameW(h, classname, maxcount);
}
#else
inline int GetClassName(HWND h, LPSTR classname, int maxcount)
{
return GetClassNameA(h, classname, maxcount);
}
#endif
#endif
// GetClassInfo
#ifdef GetClassInfo
#undef GetClassInfo
#if wxUSE_UNICODE_WINDOWS_H
inline BOOL GetClassInfo(HINSTANCE h, LPCWSTR name, LPWNDCLASSW winclass)
{
return GetClassInfoW(h, name, winclass);
}
#else
inline BOOL GetClassInfo(HINSTANCE h, LPCSTR name, LPWNDCLASSA winclass)
{
return GetClassInfoA(h, name, winclass);
}
#endif
#endif
// LoadAccelerators
#ifdef LoadAccelerators
#undef LoadAccelerators
#if wxUSE_UNICODE_WINDOWS_H
inline HACCEL LoadAccelerators(HINSTANCE h, LPCWSTR name)
{
return LoadAcceleratorsW(h, name);
}
#else
inline HACCEL LoadAccelerators(HINSTANCE h, LPCSTR name)
{
return LoadAcceleratorsA(h, name);
}
#endif
#endif
// DrawText
#ifdef DrawText
#undef DrawText
#if wxUSE_UNICODE_WINDOWS_H
inline int DrawText(HDC h, LPCWSTR str, int count, LPRECT rect, UINT format)
{
return DrawTextW(h, str, count, rect, format);
}
#else
inline int DrawText(HDC h, LPCSTR str, int count, LPRECT rect, UINT format)
{
return DrawTextA(h, str, count, rect, format);
}
#endif
#endif
// StartDoc
#ifdef StartDoc
#undef StartDoc
#if wxUSE_UNICODE_WINDOWS_H
inline int StartDoc(HDC h, CONST DOCINFOW* info)
{
return StartDocW(h, (DOCINFOW*) info);
}
#else
inline int StartDoc(HDC h, CONST DOCINFOA* info)
{
return StartDocA(h, (DOCINFOA*) info);
}
#endif
#endif
// GetObject
#ifdef GetObject
#undef GetObject
inline int GetObject(HGDIOBJ h, int i, LPVOID buffer)
{
#if wxUSE_UNICODE_WINDOWS_H
return GetObjectW(h, i, buffer);
#else
return GetObjectA(h, i, buffer);
#endif
}
#endif
// GetMessage
#ifdef GetMessage
#undef GetMessage
inline int GetMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)
{
#if wxUSE_UNICODE_WINDOWS_H
return GetMessageW(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
#else
return GetMessageA(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
#endif
}
#endif
// LoadIcon
#ifdef LoadIcon
#undef LoadIcon
inline HICON LoadIcon(HINSTANCE hInstance, LPCTSTR lpIconName)
{
#if wxUSE_UNICODE_WINDOWS_H
return LoadIconW(hInstance, lpIconName);
#else // ANSI
return LoadIconA(hInstance, lpIconName);
#endif // Unicode/ANSI
}
#endif // LoadIcon
// LoadBitmap
#ifdef LoadBitmap
#undef LoadBitmap
inline HBITMAP LoadBitmap(HINSTANCE hInstance, LPCTSTR lpBitmapName)
{
#if wxUSE_UNICODE_WINDOWS_H
return LoadBitmapW(hInstance, lpBitmapName);
#else // ANSI
return LoadBitmapA(hInstance, lpBitmapName);
#endif // Unicode/ANSI
}
#endif // LoadBitmap
// LoadLibrary
#ifdef LoadLibrary
#undef LoadLibrary
#if wxUSE_UNICODE_WINDOWS_H
inline HINSTANCE LoadLibrary(LPCWSTR lpLibFileName)
{
return LoadLibraryW(lpLibFileName);
}
#else
inline HINSTANCE LoadLibrary(LPCSTR lpLibFileName)
{
return LoadLibraryA(lpLibFileName);
}
#endif
#endif
// FindResource
#ifdef FindResource
#undef FindResource
#if wxUSE_UNICODE_WINDOWS_H
inline HRSRC FindResource(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType)
{
return FindResourceW(hModule, lpName, lpType);
}
#else
inline HRSRC FindResource(HMODULE hModule, LPCSTR lpName, LPCSTR lpType)
{
return FindResourceA(hModule, lpName, lpType);
}
#endif
#endif
// IsMaximized
#ifdef IsMaximized
#undef IsMaximized
inline BOOL IsMaximized(HWND hwnd)
{
return IsZoomed(hwnd);
}
#endif
// GetFirstChild
#ifdef GetFirstChild
#undef GetFirstChild
inline HWND GetFirstChild(HWND hwnd)
{
return GetTopWindow(hwnd);
}
#endif
// GetFirstSibling
#ifdef GetFirstSibling
#undef GetFirstSibling
inline HWND GetFirstSibling(HWND hwnd)
{
return GetWindow(hwnd,GW_HWNDFIRST);
}
#endif
// GetLastSibling
#ifdef GetLastSibling
#undef GetLastSibling
inline HWND GetLastSibling(HWND hwnd)
{
return GetWindow(hwnd,GW_HWNDLAST);
}
#endif
// GetPrevSibling
#ifdef GetPrevSibling
#undef GetPrevSibling
inline HWND GetPrevSibling(HWND hwnd)
{
return GetWindow(hwnd,GW_HWNDPREV);
}
#endif
// GetNextSibling
#ifdef GetNextSibling
#undef GetNextSibling
inline HWND GetNextSibling(HWND hwnd)
{
return GetWindow(hwnd,GW_HWNDNEXT);
}
#endif
// For WINE
#if defined(GetWindowStyle)
#undef GetWindowStyle
#endif
// For ming and cygwin
#ifdef Yield
#undef Yield
#endif
// GetWindowProc
//ifdef GetWindowProc
// #undef GetWindowProc
//endif
//ifdef GetNextChild
// #undef GetNextChild
//endif
// #endif // _WX_WINUNDEF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/popupwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/popupwin.h
// Purpose: wxPopupWindow class for wxMSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 06.01.01
// Copyright: (c) 2001 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_POPUPWIN_H_
#define _WX_MSW_POPUPWIN_H_
// ----------------------------------------------------------------------------
// wxPopupWindow
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPopupWindow : public wxPopupWindowBase
{
public:
wxPopupWindow() { m_owner = NULL; }
wxPopupWindow(wxWindow *parent, int flags = wxBORDER_NONE)
{ (void)Create(parent, flags); }
bool Create(wxWindow *parent, int flags = wxBORDER_NONE);
virtual bool Show(bool show = true) wxOVERRIDE;
// return the style to be used for the popup windows
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle) const wxOVERRIDE;
// Implementation only from now on.
// Return the top level window parent of this popup or null.
wxWindow* MSWGetOwner() const { return m_owner; }
private:
wxWindow* m_owner;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxPopupWindow);
};
#endif // _WX_MSW_POPUPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/caret.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/caret.h
// Purpose: wxCaret class - the MSW implementation of wxCaret
// Author: Vadim Zeitlin
// Modified by:
// Created: 23.05.99
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CARET_H_
#define _WX_CARET_H_
class WXDLLIMPEXP_CORE wxCaret : public wxCaretBase
{
public:
wxCaret() { Init(); }
// create the caret of given (in pixels) width and height and associate
// with the given window
wxCaret(wxWindow *window, int width, int height)
{
Init();
(void)Create(window, width, height);
}
// same as above
wxCaret(wxWindowBase *window, const wxSize& size)
{
Init();
(void)Create(window, size);
}
// process wxWindow notifications
virtual void OnSetFocus() wxOVERRIDE;
virtual void OnKillFocus() wxOVERRIDE;
protected:
void Init()
{
wxCaretBase::Init();
m_hasCaret = false;
}
// override base class virtuals
virtual void DoMove() wxOVERRIDE;
virtual void DoShow() wxOVERRIDE;
virtual void DoHide() wxOVERRIDE;
virtual void DoSize() wxOVERRIDE;
// helper function which creates the system caret
bool MSWCreateCaret();
private:
bool m_hasCaret;
wxDECLARE_NO_COPY_CLASS(wxCaret);
};
#endif // _WX_CARET_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/joystick.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/joystick.h
// Purpose: wxJoystick class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_JOYSTICK_H_
#define _WX_JOYSTICK_H_
#include "wx/event.h"
class wxJoystickThread;
class WXDLLIMPEXP_ADV wxJoystick: public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxJoystick);
public:
/*
* Public interface
*/
wxJoystick(int joystick = wxJOYSTICK1);
virtual ~wxJoystick();
// Attributes
////////////////////////////////////////////////////////////////////////////
wxPoint GetPosition(void) const;
int GetPosition(unsigned axis) const;
bool GetButtonState(unsigned button) const;
int GetZPosition(void) const;
int GetButtonState(void) const;
int GetPOVPosition(void) const;
int GetPOVCTSPosition(void) const;
int GetRudderPosition(void) const;
int GetUPosition(void) const;
int GetVPosition(void) const;
int GetMovementThreshold(void) const;
void SetMovementThreshold(int threshold) ;
// Capabilities
////////////////////////////////////////////////////////////////////////////
static int GetNumberJoysticks(void);
bool IsOk(void) const; // Checks that the joystick is functioning
int GetManufacturerId(void) const ;
int GetProductId(void) const ;
wxString GetProductName(void) const ;
int GetXMin(void) const;
int GetYMin(void) const;
int GetZMin(void) const;
int GetXMax(void) const;
int GetYMax(void) const;
int GetZMax(void) const;
int GetNumberButtons(void) const;
int GetNumberAxes(void) const;
int GetMaxButtons(void) const;
int GetMaxAxes(void) const;
int GetPollingMin(void) const;
int GetPollingMax(void) const;
int GetRudderMin(void) const;
int GetRudderMax(void) const;
int GetUMin(void) const;
int GetUMax(void) const;
int GetVMin(void) const;
int GetVMax(void) const;
bool HasRudder(void) const;
bool HasZ(void) const;
bool HasU(void) const;
bool HasV(void) const;
bool HasPOV(void) const;
bool HasPOV4Dir(void) const;
bool HasPOVCTS(void) const;
// Operations
////////////////////////////////////////////////////////////////////////////
// pollingFreq = 0 means that movement events are sent when above the threshold.
// If pollingFreq > 0, events are received every this many milliseconds.
bool SetCapture(wxWindow* win, int pollingFreq = 0);
bool ReleaseCapture(void);
protected:
int m_joystick;
wxJoystickThread* m_thread;
};
#endif
// _WX_JOYSTICK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dib.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dib.h
// Purpose: wxDIB class representing Win32 device independent bitmaps
// Author: Vadim Zeitlin
// Modified by:
// Created: 03.03.03 (replaces the old file with the same name)
// Copyright: (c) 1997-2003 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DIB_H_
#define _WX_MSW_DIB_H_
class WXDLLIMPEXP_FWD_CORE wxPalette;
#include "wx/msw/private.h"
#if wxUSE_WXDIB
#ifdef __WXMSW__
#include "wx/bitmap.h"
#endif // __WXMSW__
// ----------------------------------------------------------------------------
// wxDIB: represents a DIB section
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDIB
{
public:
// ctors and such
// --------------
// create an uninitialized DIB with the given width, height and depth (only
// 24 and 32 bpp DIBs are currently supported)
//
// after using this ctor, GetData() and GetHandle() may be used if IsOk()
// returns true
wxDIB(int width, int height, int depth)
{ Init(); (void)Create(width, height, depth); }
#ifdef __WXMSW__
// create a DIB from the DDB
wxDIB(const wxBitmap& bmp)
{ Init(); (void)Create(bmp); }
#endif // __WXMSW__
// create a DIB from the Windows DDB
wxDIB(HBITMAP hbmp)
{ Init(); (void)Create(hbmp); }
// load a DIB from file (any depth is supoprted here unlike above)
//
// as above, use IsOk() to see if the bitmap was loaded successfully
wxDIB(const wxString& filename)
{ Init(); (void)Load(filename); }
// same as the corresponding ctors but with return value
bool Create(int width, int height, int depth);
#ifdef __WXMSW__
bool Create(const wxBitmap& bmp) { return Create(GetHbitmapOf(bmp)); }
#endif
bool Create(HBITMAP hbmp);
bool Load(const wxString& filename);
// dtor is not virtual, this class is not meant to be used polymorphically
~wxDIB();
// operations
// ----------
// create a bitmap compatible with the given HDC (or screen by default) and
// return its handle, the caller is responsible for freeing it (using
// DeleteObject())
HBITMAP CreateDDB(HDC hdc = 0) const;
// get the handle from the DIB and reset it, i.e. this object won't destroy
// the DIB after this (but the caller should do it)
HBITMAP Detach() { HBITMAP hbmp = m_handle; m_handle = 0; return hbmp; }
#if defined(__WXMSW__) && wxUSE_PALETTE
// create a palette for this DIB (always a trivial/default one for 24bpp)
wxPalette *CreatePalette() const;
#endif // defined(__WXMSW__) && wxUSE_PALETTE
// save the DIB as a .BMP file to the file with the given name
bool Save(const wxString& filename);
// accessors
// ---------
// return true if DIB was successfully created, false otherwise
bool IsOk() const { return m_handle != 0; }
// get the bitmap size
wxSize GetSize() const { DoGetObject(); return wxSize(m_width, m_height); }
int GetWidth() const { DoGetObject(); return m_width; }
int GetHeight() const { DoGetObject(); return m_height; }
// get the number of bits per pixel, or depth
int GetDepth() const { DoGetObject(); return m_depth; }
// get the DIB handle
HBITMAP GetHandle() const { return m_handle; }
// get raw pointer to bitmap bits, you should know what you do if you
// decide to use it
unsigned char *GetData() const
{ DoGetObject(); return (unsigned char *)m_data; }
// HBITMAP conversion
// ------------------
// these functions are only used by wxWidgets internally right now, please
// don't use them directly if possible as they're subject to change
// creates a DDB compatible with the given (or screen) DC from either
// a plain DIB or a DIB section (in which case the last parameter must be
// non NULL)
static HBITMAP ConvertToBitmap(const BITMAPINFO *pbi,
HDC hdc = 0,
void *bits = NULL);
// create a plain DIB (not a DIB section) from a DDB, the caller is
// responsable for freeing it using ::GlobalFree()
static HGLOBAL ConvertFromBitmap(HBITMAP hbmp);
// creates a DIB from the given DDB or calculates the space needed by it:
// if pbi is NULL, only the space is calculated, otherwise pbi is supposed
// to point at BITMAPINFO of the correct size which is filled by this
// function (this overload is needed for wxBitmapDataObject code in
// src/msw/ole/dataobj.cpp)
static size_t ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp);
// wxImage conversion
// ------------------
#if wxUSE_IMAGE
// Possible formats for DIBs created by the functions below.
enum PixelFormat
{
PixelFormat_PreMultiplied = 0,
PixelFormat_NotPreMultiplied = 1
};
// Create a DIB from the given image, the DIB will be either 24 or 32 (if
// the image has alpha channel) bpp.
//
// By default the DIB stores pixel data in pre-multiplied format so that it
// can be used with ::AlphaBlend() but it is also possible to disable
// pre-multiplication for the DIB to be usable with ImageList_Draw() which
// does pre-multiplication internally.
wxDIB(const wxImage& image, PixelFormat pf = PixelFormat_PreMultiplied)
{
Init();
(void)Create(image, pf);
}
// same as the above ctor but with the return code
bool Create(const wxImage& image, PixelFormat pf = PixelFormat_PreMultiplied);
// create wxImage having the same data as this DIB
// Possible options of conversion to wxImage
enum ConversionFlags
{
// Determine whether 32bpp DIB contains real alpha channel
// and return wxImage with or without alpha channel values.
Convert_AlphaAuto,
// Assume that 32bpp DIB contains valid alpha channel and always
// return wxImage with alpha channel values in this case.
Convert_AlphaAlwaysIf32bpp
};
wxImage ConvertToImage(ConversionFlags flags = Convert_AlphaAuto) const;
#endif // wxUSE_IMAGE
// helper functions
// ----------------
// return the size of one line in a DIB with given width and depth: the
// point here is that as the scan lines need to be DWORD aligned so we may
// need to add some padding
static unsigned long GetLineSize(int width, int depth)
{
return ((width*depth + 31) & ~31) >> 3;
}
private:
// common part of all ctors
void Init();
// free resources
void Free();
// initialize the contents from the provided DDB (Create() must have been
// already called)
bool CopyFromDDB(HBITMAP hbmp);
// the DIB section handle, 0 if invalid
HBITMAP m_handle;
// NB: we could store only m_handle and not any of the other fields as
// we may always retrieve them from it using ::GetObject(), but we
// decide to still store them for efficiency concerns -- however if we
// don't have them from the very beginning (e.g. DIB constructed from a
// bitmap), we only retrieve them when necessary and so these fields
// should *never* be accessed directly, even from inside wxDIB code
// function which must be called before accessing any members and which
// gets their values from m_handle, if not done yet
void DoGetObject() const;
// pointer to DIB bits, may be NULL
void *m_data;
// size and depth of the image
int m_width,
m_height,
m_depth;
// in some cases we could be using a handle which we didn't create and in
// this case we shouldn't free it neither -- this flag tell us if this is
// the case
bool m_ownsHandle;
// DIBs can't be copied
wxDIB(const wxDIB&);
wxDIB& operator=(const wxDIB&);
};
// ----------------------------------------------------------------------------
// inline functions implementation
// ----------------------------------------------------------------------------
inline
void wxDIB::Init()
{
m_handle = 0;
m_ownsHandle = true;
m_data = NULL;
m_width =
m_height =
m_depth = 0;
}
inline
void wxDIB::Free()
{
if ( m_handle && m_ownsHandle )
{
if ( !::DeleteObject(m_handle) )
{
wxLogLastError(wxT("DeleteObject(hDIB)"));
}
Init();
}
}
inline wxDIB::~wxDIB()
{
Free();
}
#endif
// wxUSE_WXDIB
#endif // _WX_MSW_DIB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/brush.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/brush.h
// Purpose: wxBrush class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BRUSH_H_
#define _WX_BRUSH_H_
class WXDLLIMPEXP_FWD_CORE wxBrush;
class WXDLLIMPEXP_FWD_CORE wxColour;
class WXDLLIMPEXP_FWD_CORE wxBitmap;
// ----------------------------------------------------------------------------
// wxBrush
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBrush : public wxBrushBase
{
public:
wxBrush();
wxBrush(const wxColour& col, wxBrushStyle style = wxBRUSHSTYLE_SOLID);
wxBrush(const wxBitmap& stipple);
virtual ~wxBrush();
virtual void SetColour(const wxColour& col) wxOVERRIDE;
virtual void SetColour(unsigned char r, unsigned char g, unsigned char b) wxOVERRIDE;
virtual void SetStyle(wxBrushStyle style) wxOVERRIDE;
virtual void SetStipple(const wxBitmap& stipple) wxOVERRIDE;
bool operator==(const wxBrush& brush) const;
bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
wxColour GetColour() const wxOVERRIDE;
wxBrushStyle GetStyle() const wxOVERRIDE;
wxBitmap *GetStipple() const wxOVERRIDE;
wxDEPRECATED_MSG("use wxBRUSHSTYLE_XXX constants")
wxBrush(const wxColour& col, int style);
wxDEPRECATED_MSG("use wxBRUSHSTYLE_XXX constants")
void SetStyle(int style) { SetStyle((wxBrushStyle)style); }
// return the HBRUSH for this brush
virtual WXHANDLE GetResourceHandle() const wxOVERRIDE;
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxBrush);
};
#endif // _WX_BRUSH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/wrapgdip.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapgdip.h
// Purpose: wrapper around <gdiplus.h> header
// Author: Vadim Zeitlin
// Created: 2007-03-15
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WRAPGDIP_H_
#define _WX_MSW_WRAPGDIP_H_
#include "wx/msw/wrapwin.h"
// min and max must be available for gdiplus.h but we cannot define them as
// macros because they conflict with std::numeric_limits<T>::min and max when
// compiling with mingw-w64 and -std=c++17. This happens because with c++17,
// math.h includes bessel_function which requires std::numeric_limits.
#include <cmath>
using std::min;
using std::max;
// There are many clashes between the names of the member fields and parameters
// in the standard gdiplus.h header and each of them results in C4458 with
// VC14, so disable this warning for this file as there is no other way to
// avoid it.
#ifdef __VISUALC__
#pragma warning(push)
#pragma warning(disable:4458) // declaration of 'xxx' hides class member
#endif
#include <gdiplus.h>
using namespace Gdiplus;
#ifdef __VISUALC__
#pragma warning(pop)
#endif
#endif // _WX_MSW_WRAPGDIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/clipbrd.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/clipbrd.h
// Purpose: wxClipboad class and clipboard functions for MSW
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CLIPBRD_H_
#define _WX_CLIPBRD_H_
#if wxUSE_CLIPBOARD
// These functions superceded by wxClipboard, but retained in order to
// implement wxClipboard, and for compatibility.
// open/close the clipboard
WXDLLIMPEXP_CORE bool wxOpenClipboard();
WXDLLIMPEXP_CORE bool wxIsClipboardOpened();
#define wxClipboardOpen wxIsClipboardOpened
WXDLLIMPEXP_CORE bool wxCloseClipboard();
// get/set data
WXDLLIMPEXP_CORE bool wxEmptyClipboard();
#if !wxUSE_OLE
WXDLLIMPEXP_CORE bool wxSetClipboardData(wxDataFormat dataFormat,
const void *data,
int width = 0, int height = 0);
#endif // !wxUSE_OLE
// clipboard formats
WXDLLIMPEXP_CORE bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat);
WXDLLIMPEXP_CORE wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat);
WXDLLIMPEXP_CORE int wxRegisterClipboardFormat(wxChar *formatName);
WXDLLIMPEXP_CORE bool wxGetClipboardFormatName(wxDataFormat dataFormat,
wxChar *formatName,
int maxCount);
//-----------------------------------------------------------------------------
// wxClipboard
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClipboard : public wxClipboardBase
{
public:
wxClipboard();
virtual ~wxClipboard();
// open the clipboard before SetData() and GetData()
virtual bool Open() wxOVERRIDE;
// close the clipboard after SetData() and GetData()
virtual void Close() wxOVERRIDE;
// query whether the clipboard is opened
virtual bool IsOpened() const wxOVERRIDE;
// set the clipboard data. all other formats will be deleted.
virtual bool SetData( wxDataObject *data ) wxOVERRIDE;
// add to the clipboard data.
virtual bool AddData( wxDataObject *data ) wxOVERRIDE;
// ask if data in correct format is available
virtual bool IsSupported( const wxDataFormat& format ) wxOVERRIDE;
// fill data with data on the clipboard (if available)
virtual bool GetData( wxDataObject& data ) wxOVERRIDE;
// clears wxTheClipboard and the system's clipboard if possible
virtual void Clear() wxOVERRIDE;
// flushes the clipboard: this means that the data which is currently on
// clipboard will stay available even after the application exits (possibly
// eating memory), otherwise the clipboard will be emptied on exit
virtual bool Flush() wxOVERRIDE;
private:
IDataObject *m_lastDataObject;
bool m_isOpened;
wxDECLARE_DYNAMIC_CLASS(wxClipboard);
};
#endif // wxUSE_CLIPBOARD
#endif // _WX_CLIPBRD_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/printwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/printwin.h
// Purpose: wxWindowsPrinter, wxWindowsPrintPreview classes
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRINTWIN_H_
#define _WX_PRINTWIN_H_
#include "wx/prntbase.h"
// ---------------------------------------------------------------------------
// Represents the printer: manages printing a wxPrintout object
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowsPrinter : public wxPrinterBase
{
wxDECLARE_DYNAMIC_CLASS(wxWindowsPrinter);
public:
wxWindowsPrinter(wxPrintDialogData *data = NULL);
virtual bool Print(wxWindow *parent,
wxPrintout *printout,
bool prompt = true) wxOVERRIDE;
virtual wxDC *PrintDialog(wxWindow *parent) wxOVERRIDE;
virtual bool Setup(wxWindow *parent) wxOVERRIDE;
private:
wxDECLARE_NO_COPY_CLASS(wxWindowsPrinter);
};
// ---------------------------------------------------------------------------
// wxPrintPreview: programmer creates an object of this class to preview a
// wxPrintout.
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowsPrintPreview : public wxPrintPreviewBase
{
public:
wxWindowsPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting = NULL,
wxPrintDialogData *data = NULL);
wxWindowsPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting,
wxPrintData *data);
virtual ~wxWindowsPrintPreview();
virtual bool Print(bool interactive) wxOVERRIDE;
virtual void DetermineScaling() wxOVERRIDE;
protected:
#if wxUSE_ENH_METAFILE
virtual bool RenderPageIntoBitmap(wxBitmap& bmp, int pageNum) wxOVERRIDE;
#endif
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxWindowsPrintPreview);
};
#endif
// _WX_PRINTWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/timectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/timectrl.h
// Purpose: wxTimePickerCtrl for Windows.
// Author: Vadim Zeitlin
// Created: 2011-09-22
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TIMECTRL_H_
#define _WX_MSW_TIMECTRL_H_
// ----------------------------------------------------------------------------
// wxTimePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxTimePickerCtrl : public wxTimePickerCtrlBase
{
public:
// ctors
wxTimePickerCtrl() { }
wxTimePickerCtrl(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTP_DEFAULT,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTimePickerCtrlNameStr)
{
Create(parent, id, dt, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTP_DEFAULT,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTimePickerCtrlNameStr)
{
return MSWCreateDateTimePicker(parent, id, dt,
pos, size, style,
validator, name);
}
// Override MSW-specific functions used during control creation.
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
#if wxUSE_INTL
virtual wxLocaleInfo MSWGetFormat() const wxOVERRIDE;
#endif // wxUSE_INTL
virtual bool MSWAllowsNone() const wxOVERRIDE { return false; }
virtual bool MSWOnDateTimeChange(const tagNMDATETIMECHANGE& dtch) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTimePickerCtrl);
};
#endif // _WX_MSW_TIMECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/tglbtn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/tglbtn.h
// Purpose: Declaration of the wxToggleButton class, which implements a
// toggle button under wxMSW.
// Author: John Norris, minor changes by Axel Schlueter
// Modified by:
// Created: 08.02.01
// Copyright: (c) 2000 Johnny C. Norris II
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOGGLEBUTTON_H_
#define _WX_TOGGLEBUTTON_H_
#include "wx/bitmap.h"
// Checkbox item (single checkbox)
class WXDLLIMPEXP_CORE wxToggleButton : public wxToggleButtonBase
{
public:
wxToggleButton() { Init(); }
wxToggleButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
virtual void SetValue(bool value) wxOVERRIDE;
virtual bool GetValue() const wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
virtual bool MSWIsPushed() const wxOVERRIDE;
void Init();
// current state of the button (when owner-drawn)
bool m_state;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxToggleButton);
};
//-----------------------------------------------------------------------------
// wxBitmapToggleButton
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapToggleButton: public wxToggleButton
{
public:
// construction/destruction
wxBitmapToggleButton() {}
wxBitmapToggleButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
// Create the control
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
// deprecated synonym for SetBitmapLabel()
wxDEPRECATED_INLINE( void SetLabel(const wxBitmap& bitmap),
SetBitmapLabel(bitmap); )
// prevent virtual function hiding
virtual void SetLabel(const wxString& label) wxOVERRIDE { wxToggleButton::SetLabel(label); }
private:
wxDECLARE_DYNAMIC_CLASS(wxBitmapToggleButton);
};
#endif // _WX_TOGGLEBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dcscreen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dcscreen.h
// Purpose: wxScreenDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DCSCREEN_H_
#define _WX_MSW_DCSCREEN_H_
#include "wx/dcscreen.h"
#include "wx/msw/dc.h"
class WXDLLIMPEXP_CORE wxScreenDCImpl : public wxMSWDCImpl
{
public:
// Create a DC representing the whole virtual screen (all monitors)
wxScreenDCImpl( wxScreenDC *owner );
// Return the size of the whole virtual screen (all monitors)
virtual void DoGetSize(int *w, int *h) const wxOVERRIDE;
wxDECLARE_CLASS(wxScreenDCImpl);
wxDECLARE_NO_COPY_CLASS(wxScreenDCImpl);
};
#endif // _WX_MSW_DCSCREEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/rcdefs.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/rcdefs.h
// Purpose: Fallback for the generated rcdefs.h under the lib directory
// Author: Mike Wetherell
// Copyright: (c) 2005 Mike Wetherell
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RCDEFS_H
#define _WX_RCDEFS_H
#ifdef __GNUC__
// We must be using windres which uses gcc as its preprocessor. We do need
// to generate the manifest then as gcc doesn't do it automatically and we
// can define the architecture macro on our own as all the usual symbols
// are available (unlike with Microsoft RC.EXE which doesn't predefine
// anything useful at all).
#ifndef wxUSE_RC_MANIFEST
#define wxUSE_RC_MANIFEST 1
#endif
#if defined __i386__
#ifndef WX_CPU_X86
#define WX_CPU_X86
#endif
#elif defined __x86_64__
#ifndef WX_CPU_AMD64
#define WX_CPU_AMD64
#endif
#elif defined __ia64__
#ifndef WX_CPU_IA64
#define WX_CPU_IA64
#endif
#endif
#endif
// Don't do anything here for the other compilers, in particular don't define
// WX_CPU_X86 here as we used to do. If people define wxUSE_RC_MANIFEST, they
// must also define the architecture constant correctly.
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/missing.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/missing.h
// Purpose: Declarations for parts of the Win32 SDK that are missing in
// the versions that come with some compilers
// Created: 2002/04/23
// Copyright: (c) 2002 Mattia Barbon
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MISSING_H_
#define _WX_MISSING_H_
#ifndef WM_CHANGEUISTATE
#define WM_CHANGEUISTATE 0x0127
#endif
#ifndef WM_UPDATEUISTATE
#define WM_UPDATEUISTATE 0x0128
#endif
#ifndef WM_QUERYUISTATE
#define WM_QUERYUISTATE 0x0129
#endif
#ifndef WM_PRINTCLIENT
#define WM_PRINTCLIENT 0x318
#endif
#ifndef DT_HIDEPREFIX
#define DT_HIDEPREFIX 0x00100000
#endif
#ifndef DSS_HIDEPREFIX
#define DSS_HIDEPREFIX 0x0200
#endif
// Needed by toplevel.cpp
#ifndef UIS_SET
#define UIS_SET 1
#define UIS_CLEAR 2
#define UIS_INITIALIZE 3
#endif
#ifndef UISF_HIDEFOCUS
#define UISF_HIDEFOCUS 1
#endif
#ifndef UISF_HIDEACCEL
#define UISF_HIDEACCEL 2
#endif
#ifndef OFN_EXPLORER
#define OFN_EXPLORER 0x00080000
#endif
#ifndef OFN_ENABLESIZING
#define OFN_ENABLESIZING 0x00800000
#endif
// Needed by window.cpp
#if wxUSE_MOUSEWHEEL
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x020A
#endif
#ifndef WM_MOUSEHWHEEL
#define WM_MOUSEHWHEEL 0x020E
#endif
#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120
#endif
#ifndef SPI_GETWHEELSCROLLLINES
#define SPI_GETWHEELSCROLLLINES 104
#endif
#ifndef SPI_GETWHEELSCROLLCHARS
#define SPI_GETWHEELSCROLLCHARS 108
#endif
#endif // wxUSE_MOUSEWHEEL
// Needed by window.cpp
#ifndef VK_OEM_1
#define VK_OEM_1 0xBA
#define VK_OEM_2 0xBF
#define VK_OEM_3 0xC0
#define VK_OEM_4 0xDB
#define VK_OEM_5 0xDC
#define VK_OEM_6 0xDD
#define VK_OEM_7 0xDE
#define VK_OEM_102 0xE2
#endif
#ifndef VK_OEM_COMMA
#define VK_OEM_PLUS 0xBB
#define VK_OEM_COMMA 0xBC
#define VK_OEM_MINUS 0xBD
#define VK_OEM_PERIOD 0xBE
#endif
#ifndef SM_TABLETPC
#define SM_TABLETPC 86
#endif
#ifndef INKEDIT_CLASS
# define INKEDIT_CLASSW L"INKEDIT"
# ifdef UNICODE
# define INKEDIT_CLASS INKEDIT_CLASSW
# else
# define INKEDIT_CLASS "INKEDIT"
# endif
#endif
#ifndef EM_SETINKINSERTMODE
# define EM_SETINKINSERTMODE (WM_USER + 0x0204)
#endif
#ifndef EM_SETUSEMOUSEFORINPUT
#define EM_SETUSEMOUSEFORINPUT (WM_USER + 0x224)
#endif
#ifndef TPM_RECURSE
#define TPM_RECURSE 1
#endif
#ifndef WS_EX_LAYOUTRTL
#define WS_EX_LAYOUTRTL 0x00400000
#endif
#ifndef WS_EX_COMPOSITED
#define WS_EX_COMPOSITED 0x02000000L
#endif
#ifndef WS_EX_LAYERED
#define WS_EX_LAYERED 0x00080000
#endif
#ifndef LWA_ALPHA
#define LWA_ALPHA 2
#endif
#ifndef QS_ALLPOSTMESSAGE
#define QS_ALLPOSTMESSAGE 0
#endif
// Missing from MinGW 4.8 SDK headers.
#ifndef BS_TYPEMASK
#define BS_TYPEMASK 0xf
#endif
// ----------------------------------------------------------------------------
// menu stuff
// ----------------------------------------------------------------------------
#ifndef MIIM_BITMAP
#define MIIM_STRING 0x00000040
#define MIIM_BITMAP 0x00000080
#define MIIM_FTYPE 0x00000100
#define HBMMENU_CALLBACK ((HBITMAP) -1)
typedef struct tagMENUINFO
{
DWORD cbSize;
DWORD fMask;
DWORD dwStyle;
UINT cyMax;
HBRUSH hbrBack;
DWORD dwContextHelpID;
DWORD dwMenuData;
} MENUINFO, FAR *LPMENUINFO;
#endif // MIIM_BITMAP &c
// ----------------------------------------------------------------------------
// definitions related to ListView and Header common controls, needed by
// msw/listctrl.cpp and msw/headerctrl.cpp
// ----------------------------------------------------------------------------
#ifndef I_IMAGENONE
#define I_IMAGENONE (-2)
#endif
#ifndef LVS_EX_FULLROWSELECT
#define LVS_EX_FULLROWSELECT 0x00000020
#endif
#if !defined(LVS_EX_LABELTIP)
#define LVS_EX_LABELTIP 0x00004000
#endif
#ifndef LVS_EX_SUBITEMIMAGES
#define LVS_EX_SUBITEMIMAGES 0x00000002
#endif
#ifndef LVS_EX_DOUBLEBUFFER
#define LVS_EX_DOUBLEBUFFER 0x00010000
#endif
#ifndef HDN_GETDISPINFOW
#define HDN_GETDISPINFOW (HDN_FIRST-29)
#endif
#ifndef HDS_HOTTRACK
#define HDS_HOTTRACK 4
#endif
#ifndef HDS_FLAT
#define HDS_FLAT 0x0200
#endif
#ifndef HDS_NOSIZING
#define HDS_NOSIZING 0x0800
#endif
#ifndef HDF_SORTUP
#define HDF_SORTUP 0x0400
#define HDF_SORTDOWN 0x0200
#endif
/*
* In addition to the above, the following are required for several compilers.
*/
#if !defined(CCS_VERT)
#define CCS_VERT 0x00000080L
#endif
#if !defined(CCS_RIGHT)
#define CCS_RIGHT (CCS_VERT|CCS_BOTTOM)
#endif
#if !defined(TB_SETDISABLEDIMAGELIST)
#define TB_SETDISABLEDIMAGELIST (WM_USER + 54)
#endif // !defined(TB_SETDISABLEDIMAGELIST)
#ifndef HANGUL_CHARSET
#define HANGUL_CHARSET 129
#endif
#ifndef CCM_SETUNICODEFORMAT
#define CCM_SETUNICODEFORMAT 8197
#endif
// ----------------------------------------------------------------------------
// Tree control
// ----------------------------------------------------------------------------
#ifndef TV_FIRST
#define TV_FIRST 0x1100
#endif
#ifndef TVS_EX_DOUBLEBUFFER
#define TVS_EX_DOUBLEBUFFER 0x0004
#endif
#ifndef TVS_FULLROWSELECT
#define TVS_FULLROWSELECT 0x1000
#endif
#ifndef TVM_SETBKCOLOR
#define TVM_SETBKCOLOR (TV_FIRST + 29)
#define TVM_SETTEXTCOLOR (TV_FIRST + 30)
#endif
#ifndef TVM_SETEXTENDEDSTYLE
#define TVM_SETEXTENDEDSTYLE (TV_FIRST + 44)
#define TVM_GETEXTENDEDSTYLE (TV_FIRST + 45)
#endif
// Various defines used by the webview library that are needed by mingw
#ifndef DISPID_COMMANDSTATECHANGE
#define DISPID_COMMANDSTATECHANGE 105
#endif
#ifndef DISPID_NAVIGATECOMPLETE2
#define DISPID_NAVIGATECOMPLETE2 252
#endif
#ifndef DISPID_NAVIGATEERROR
#define DISPID_NAVIGATEERROR 271
#endif
#ifndef DISPID_NEWWINDOW3
#define DISPID_NEWWINDOW3 273
#endif
#ifndef INET_E_ERROR_FIRST
#define INET_E_ERROR_FIRST 0x800C0002L
#endif
#ifndef INET_E_INVALID_URL
#define INET_E_INVALID_URL 0x800C0002L
#endif
#ifndef INET_E_NO_SESSION
#define INET_E_NO_SESSION 0x800C0003L
#endif
#ifndef INET_E_CANNOT_CONNECT
#define INET_E_CANNOT_CONNECT 0x800C0004L
#endif
#ifndef INET_E_RESOURCE_NOT_FOUND
#define INET_E_RESOURCE_NOT_FOUND 0x800C0005L
#endif
#ifndef INET_E_OBJECT_NOT_FOUND
#define INET_E_OBJECT_NOT_FOUND 0x800C0006L
#endif
#ifndef INET_E_DATA_NOT_AVAILABLE
#define INET_E_DATA_NOT_AVAILABLE 0x800C0007L
#endif
#ifndef INET_E_DOWNLOAD_FAILURE
#define INET_E_DOWNLOAD_FAILURE 0x800C0008L
#endif
#ifndef INET_E_AUTHENTICATION_REQUIRED
#define INET_E_AUTHENTICATION_REQUIRED 0x800C0009L
#endif
#ifndef INET_E_NO_VALID_MEDIA
#define INET_E_NO_VALID_MEDIA 0x800C000AL
#endif
#ifndef INET_E_CONNECTION_TIMEOUT
#define INET_E_CONNECTION_TIMEOUT 0x800C000BL
#endif
#ifndef INET_E_INVALID_REQUEST
#define INET_E_INVALID_REQUEST 0x800C000CL
#endif
#ifndef INET_E_UNKNOWN_PROTOCOL
#define INET_E_UNKNOWN_PROTOCOL 0x800C000DL
#endif
#ifndef INET_E_SECURITY_PROBLEM
#define INET_E_SECURITY_PROBLEM 0x800C000EL
#endif
#ifndef INET_E_CANNOT_LOAD_DATA
#define INET_E_CANNOT_LOAD_DATA 0x800C000FL
#endif
#ifndef INET_E_CANNOT_INSTANTIATE_OBJECT
#define INET_E_CANNOT_INSTANTIATE_OBJECT 0x800C0010L
#endif
#ifndef INET_E_QUERYOPTION_UNKNOWN
#define INET_E_QUERYOPTION_UNKNOWN 0x800C0013L
#endif
#ifndef INET_E_REDIRECT_FAILED
#define INET_E_REDIRECT_FAILED 0x800C0014L
#endif
#ifndef INET_E_REDIRECT_TO_DIR
#define INET_E_REDIRECT_TO_DIR 0x800C0015L
#endif
#ifndef INET_E_CANNOT_LOCK_REQUEST
#define INET_E_CANNOT_LOCK_REQUEST 0x800C0016L
#endif
#ifndef INET_E_USE_EXTEND_BINDING
#define INET_E_USE_EXTEND_BINDING 0x800C0017L
#endif
#ifndef INET_E_TERMINATED_BIND
#define INET_E_TERMINATED_BIND 0x800C0018L
#endif
#ifndef INET_E_INVALID_CERTIFICATE
#define INET_E_INVALID_CERTIFICATE 0x800C0019L
#endif
#ifndef INET_E_CODE_DOWNLOAD_DECLINED
#define INET_E_CODE_DOWNLOAD_DECLINED 0x800C0100L
#endif
#ifndef INET_E_RESULT_DISPATCHED
#define INET_E_RESULT_DISPATCHED 0x800C0200L
#endif
#ifndef INET_E_CANNOT_REPLACE_SFP_FILE
#define INET_E_CANNOT_REPLACE_SFP_FILE 0x800C0300L
#endif
#ifndef INET_E_CODE_INSTALL_BLOCKED_BY_HASH_POLICY
#define INET_E_CODE_INSTALL_BLOCKED_BY_HASH_POLICY 0x800C0500L
#endif
#ifndef INET_E_CODE_INSTALL_SUPPRESSED
#define INET_E_CODE_INSTALL_SUPPRESSED 0x800C0400L
#endif
#ifndef MUI_LANGUAGE_NAME
#define MUI_LANGUAGE_NAME 0x8
#endif
/*
* The following are specifically required for Wine
*/
#ifdef __WINE__
#ifndef ENUM_CURRENT_SETTINGS
#define ENUM_CURRENT_SETTINGS ((DWORD)-1)
#endif
#ifndef BROADCAST_QUERY_DENY
#define BROADCAST_QUERY_DENY 1112363332
#endif
#endif // defined __WINE__
#ifndef INVALID_FILE_ATTRIBUTES
#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
#endif
#endif
// _WX_MISSING_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/combobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/combobox.h
// Purpose: wxComboBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COMBOBOX_H_
#define _WX_COMBOBOX_H_
#include "wx/choice.h"
#include "wx/textentry.h"
#if wxUSE_COMBOBOX
// ----------------------------------------------------------------------------
// Combobox control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxComboBox : public wxChoice,
public wxTextEntry
{
public:
wxComboBox() { Init(); }
wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
Init();
Create(parent, id, value, pos, size, n, choices, style, validator, name);
}
wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
Init();
Create(parent, id, value, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0,
const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
// See wxComboBoxBase discussion of IsEmpty().
bool IsListEmpty() const { return wxItemContainer::IsEmpty(); }
bool IsTextEmpty() const { return wxTextEntry::IsEmpty(); }
// resolve ambiguities among virtual functions inherited from both base
// classes
virtual void Clear() wxOVERRIDE;
virtual wxString GetValue() const wxOVERRIDE;
virtual void SetValue(const wxString& value) wxOVERRIDE;
virtual wxString GetStringSelection() const wxOVERRIDE
{ return wxChoice::GetStringSelection(); }
virtual void Popup() { MSWDoPopupOrDismiss(true); }
virtual void Dismiss() { MSWDoPopupOrDismiss(false); }
virtual void SetSelection(int n) wxOVERRIDE { wxChoice::SetSelection(n); }
virtual void SetSelection(long from, long to) wxOVERRIDE
{ wxTextEntry::SetSelection(from, to); }
virtual int GetSelection() const wxOVERRIDE { return wxChoice::GetSelection(); }
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE;
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
// implementation only from now on
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
bool MSWProcessEditMsg(WXUINT msg, WXWPARAM wParam, WXLPARAM lParam);
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
bool MSWShouldPreProcessMessage(WXMSG *pMsg) wxOVERRIDE;
// Standard event handling
void OnCut(wxCommandEvent& event);
void OnCopy(wxCommandEvent& event);
void OnPaste(wxCommandEvent& event);
void OnUndo(wxCommandEvent& event);
void OnRedo(wxCommandEvent& event);
void OnDelete(wxCommandEvent& event);
void OnSelectAll(wxCommandEvent& event);
void OnUpdateCut(wxUpdateUIEvent& event);
void OnUpdateCopy(wxUpdateUIEvent& event);
void OnUpdatePaste(wxUpdateUIEvent& event);
void OnUpdateUndo(wxUpdateUIEvent& event);
void OnUpdateRedo(wxUpdateUIEvent& event);
void OnUpdateDelete(wxUpdateUIEvent& event);
void OnUpdateSelectAll(wxUpdateUIEvent& event);
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
#if wxUSE_UXTHEME
// override wxTextEntry method to work around Windows bug
virtual bool SetHint(const wxString& hint) wxOVERRIDE;
#endif // wxUSE_UXTHEME
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
protected:
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip(wxToolTip *tip) wxOVERRIDE;
#endif
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
// Override this one to avoid eating events from our popup listbox.
virtual wxWindow *MSWFindItem(long id, WXHWND hWnd) const wxOVERRIDE;
// this is the implementation of GetEditHWND() which can also be used when
// we don't have the edit control, it simply returns NULL then
//
// try not to use this function unless absolutely necessary (as in the
// message handling code where the edit control might not be created yet
// for the messages we receive during the control creation) as normally
// just testing for IsEditable() and using GetEditHWND() should be enough
WXHWND GetEditHWNDIfAvailable() const;
virtual void EnableTextChangedEvents(bool enable) wxOVERRIDE
{
m_allowTextEvents = enable;
}
private:
// there are the overridden wxTextEntry methods which should only be called
// when we do have an edit control so they assert if this is not the case
virtual wxWindow *GetEditableWindow() wxOVERRIDE;
virtual WXHWND GetEditHWND() const wxOVERRIDE;
// Common part of MSWProcessEditMsg() and MSWProcessSpecialKey(), return
// true if the key was processed.
bool MSWProcessEditSpecialKey(WXWPARAM vkey);
#if wxUSE_OLE
virtual void MSWProcessSpecialKey(wxKeyEvent& event) wxOVERRIDE;
#endif // wxUSE_OLE
// common part of all ctors
void Init()
{
m_allowTextEvents = true;
}
// normally true, false if text events are currently disabled
bool m_allowTextEvents;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxComboBox);
wxDECLARE_EVENT_TABLE();
};
#endif // wxUSE_COMBOBOX
#endif // _WX_COMBOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/setup_inc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/setup_inc.h
// Purpose: MSW-specific setup.h options
// Author: Vadim Zeitlin
// Created: 2007-07-21 (extracted from wx/msw/setup0.h)
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// 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
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/headerctrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/headerctrl.h
// Purpose: wxMSW native wxHeaderCtrl
// Author: Vadim Zeitlin
// Created: 2008-12-01
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_HEADERCTRL_H_
#define _WX_MSW_HEADERCTRL_H_
class WXDLLIMPEXP_FWD_CORE wxImageList;
class wxMSWHeaderCtrlCustomDraw;
// ----------------------------------------------------------------------------
// wxHeaderCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxHeaderCtrl : public wxHeaderCtrlBase
{
public:
wxHeaderCtrl()
{
Init();
}
wxHeaderCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHD_DEFAULT_STYLE,
const wxString& name = wxHeaderCtrlNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHD_DEFAULT_STYLE,
const wxString& name = wxHeaderCtrlNameStr);
virtual ~wxHeaderCtrl();
// Override to implement colours support via custom drawing.
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
protected:
// override wxWindow methods which must be implemented by a new control
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
private:
// implement base class pure virtuals
virtual void DoSetCount(unsigned int count) wxOVERRIDE;
virtual unsigned int DoGetCount() const wxOVERRIDE;
virtual void DoUpdate(unsigned int idx) wxOVERRIDE;
virtual void DoScrollHorz(int dx) wxOVERRIDE;
virtual void DoSetColumnsOrder(const wxArrayInt& order) wxOVERRIDE;
virtual wxArrayInt DoGetColumnsOrder() const wxOVERRIDE;
// override MSW-specific methods needed for new control
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
// common part of all ctors
void Init();
// wrapper around Header_InsertItem(): insert the item using information
// from the given column at the given index
void DoInsertItem(const wxHeaderColumn& col, unsigned int idx);
// get the number of currently visible items: this is also the total number
// of items contained in the native control
int GetShownColumnsCount() const;
// due to the discrepancy for the hidden columns which we know about but
// the native control does not, there can be a difference between the
// column indices we use and the ones used by the native control; these
// functions translate between them
//
// notice that MSWToNativeIdx() shouldn't be called for hidden columns and
// MSWFromNativeIdx() always returns an index of a visible column
int MSWToNativeIdx(int idx);
int MSWFromNativeIdx(int item);
// this is the same as above but for order, not index
int MSWToNativeOrder(int order);
int MSWFromNativeOrder(int order);
// get the event type corresponding to a click or double click event
// (depending on dblclk value) with the specified (using MSW convention)
// mouse button
wxEventType GetClickEventType(bool dblclk, int button);
// allocate m_customDraw if we need it or free it if it no longer is,
// return the pointer which can be used to update it if it's non-null
wxMSWHeaderCtrlCustomDraw* GetCustomDraw();
// the number of columns in the control, including the hidden ones (not
// taken into account by the native control, see comment in DoGetCount())
unsigned int m_numColumns;
// this is a lookup table allowing us to check whether the column with the
// given index is currently shown in the native control, in which case the
// value of this array element with this index is 0, or hidden
//
// notice that this may be different from GetColumn(idx).IsHidden() and in
// fact we need this array precisely because it will be different from it
// in DoUpdate() when the column hidden flag gets toggled and we need it to
// handle this transition correctly
wxArrayInt m_isHidden;
// the order of our columns: this array contains the index of the column
// shown at the position n as the n-th element
//
// this is necessary only to handle the hidden columns: the native control
// doesn't know about them and so we can't use Header_GetOrderArray()
wxArrayInt m_colIndices;
// the image list: initially NULL, created on demand
wxImageList *m_imageList;
// the offset of the window used to emulate scrolling it
int m_scrollOffset;
// actual column we are dragging or -1 if not dragging anything
int m_colBeingDragged;
// a column is currently being resized
bool m_isColBeingResized;
// the custom draw helper: initially NULL, created on demand, use
// GetCustomDraw() to do it
wxMSWHeaderCtrlCustomDraw *m_customDraw;
wxDECLARE_NO_COPY_CLASS(wxHeaderCtrl);
};
#endif // _WX_MSW_HEADERCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/debughlp.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/debughlp.h
// Purpose: wraps dbghelp.h standard file
// Author: Vadim Zeitlin, Suzumizaki-kimitaka
// Created: 2005-01-08 (extracted from msw/crashrpt.cpp)
// Copyright: (c) 2003-2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DEBUGHLPH_H_
#define _WX_MSW_DEBUGHLPH_H_
#include "wx/defs.h"
#if wxUSE_DBGHELP
#include "wx/dynlib.h"
#include "wx/msw/wrapwin.h"
#ifdef __VISUALC__
// Disable a warning that we can do nothing about: we get it at least for
// imagehlp.h from 8.1 Windows kit when using VC14.
#pragma warning(push)
// 'typedef ': ignored on left of '' when no variable is declared
#pragma warning(disable:4091)
#endif
#include <imagehlp.h>
#ifdef __VISUALC__
#pragma warning(pop)
#endif
#include "wx/msw/private.h"
/*
The table below shows which functions are exported by dbghelp.dll.
On 64 bit Windows, there seems to be no difference between 32bit dll and 64bit
one. Vista-64 and Win8-64 look the same, but "Ex" and "ExW" versions exist only
in Windows 8.
Note that SymGetLineFromAddrW and EnumerateLoadedModulesW DON'T exist at all.
function | Windows | XP-32 Vista-64 Win8-64
SymEnumSymbolsW n/a v v
SymFromAddrW n/a v v
SymInitializeW n/a v v
SymEnumSymbols v v v
SymFromAddr v v v
SymInitialize v v v
SymGetLineFromAddrW64 n/a v v
SymGetLineFromAddr64 v v v
SymGetLineFromAddrW n/a n/a n/a
SymGetLineFromAddr v v v
EnumerateLoadedModulesW64 n/a v v
EnumerateLoadedModules64 v v v
EnumerateLoadedModulesW n/a n/a n/a
EnumerateLoadedModules v v v
*/
// It's not really clear whether API v10 is used by anything as VC8 still used
// v9, just as MSVC7.1, while VC9 already used v11, but provide support for it
// just in case.
#if API_VERSION_NUMBER < 10/*{{{*/
typedef BOOL
(CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PWSTR ModuleName,
DWORD64 ModuleBase,
ULONG ModuleSize,
PVOID UserContext);
typedef struct _IMAGEHLP_LINEW64
{
DWORD SizeOfStruct;
PVOID Key;
DWORD LineNumber;
PWSTR FileName;
DWORD64 Address;
} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
typedef struct _SYMBOL_INFOW
{
ULONG SizeOfStruct;
ULONG TypeIndex;
ULONG64 Reserved[2];
ULONG Index;
ULONG Size;
ULONG64 ModBase;
ULONG Flags;
ULONG64 Value;
ULONG64 Address;
ULONG Register;
ULONG Scope;
ULONG Tag;
ULONG NameLen;
ULONG MaxNameLen;
WCHAR Name[1];
} SYMBOL_INFOW, *PSYMBOL_INFOW;
typedef BOOL
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW pSymInfo,
ULONG SymbolSize,
PVOID UserContext);
typedef BOOL
(CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,
ULONG SymbolSize,
PVOID UserContext);
#endif // API_VERSION_NUMBER < 10/*}}}*/
// wx-prefixed types map to either the ANSI or Unicode ("W") version depending
// on the build of wx itself.
#ifdef UNICODE
#define wxPSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACKW
#else // !UNICODE
#define wxPSYM_ENUMERATESYMBOLS_CALLBACK PSYM_ENUMERATESYMBOLS_CALLBACK
#endif // UNICODE/!UNICODE
// This one could be already defined by wx/msw/stackwalk.h
#ifndef wxSYMBOL_INFO
#ifdef UNICODE
#define wxSYMBOL_INFO SYMBOL_INFOW
#else // !UNICODE
#define wxSYMBOL_INFO SYMBOL_INFO
#endif // UNICODE/!UNICODE
#endif // !defined(wxSYMBOL_INFO)
typedef wxSYMBOL_INFO* wxPSYMBOL_INFO;
// This differs from PENUMLOADED_MODULES_CALLBACK[W]64 in that it always uses
// "const" for its first argument when the SDK used to pass a non-const string
// here until API_VERSION_NUMBER==11, so we can't just define it as an existing
// typedef.
typedef BOOL
(CALLBACK *wxPENUMLOADED_MODULES_CALLBACK)(const wxChar* moduleName,
DWORD64 moduleBase,
ULONG moduleSize,
void *userContext);
// ----------------------------------------------------------------------------
// wxDbgHelpDLL: dynamically load dbghelp.dll functions
// ----------------------------------------------------------------------------
// wrapper for some functions from dbghelp.dll
//
// MT note: this class is not MT safe and should be only used from a single
// thread at a time (this is so because dbghelp.dll is not MT-safe
// itself anyhow)
class wxDbgHelpDLL
{
public:
// some useful constants not present in debughlp.h (stolen from DIA SDK)
enum BasicType
{
BASICTYPE_NOTYPE = 0,
BASICTYPE_VOID = 1,
BASICTYPE_CHAR = 2,
BASICTYPE_WCHAR = 3,
BASICTYPE_INT = 6,
BASICTYPE_UINT = 7,
BASICTYPE_FLOAT = 8,
BASICTYPE_BCD = 9,
BASICTYPE_BOOL = 10,
BASICTYPE_LONG = 13,
BASICTYPE_ULONG = 14,
BASICTYPE_CURRENCY = 25,
BASICTYPE_DATE = 26,
BASICTYPE_VARIANT = 27,
BASICTYPE_COMPLEX = 28,
BASICTYPE_BIT = 29,
BASICTYPE_BSTR = 30,
BASICTYPE_HRESULT = 31,
BASICTYPE_MAX
};
enum SymbolTag
{
SYMBOL_TAG_NULL,
SYMBOL_TAG_EXE,
SYMBOL_TAG_COMPILAND,
SYMBOL_TAG_COMPILAND_DETAILS,
SYMBOL_TAG_COMPILAND_ENV,
SYMBOL_TAG_FUNCTION,
SYMBOL_TAG_BLOCK,
SYMBOL_TAG_DATA,
SYMBOL_TAG_ANNOTATION,
SYMBOL_TAG_LABEL,
SYMBOL_TAG_PUBLIC_SYMBOL,
SYMBOL_TAG_UDT,
SYMBOL_TAG_ENUM,
SYMBOL_TAG_FUNCTION_TYPE,
SYMBOL_TAG_POINTER_TYPE,
SYMBOL_TAG_ARRAY_TYPE,
SYMBOL_TAG_BASE_TYPE,
SYMBOL_TAG_TYPEDEF,
SYMBOL_TAG_BASE_CLASS,
SYMBOL_TAG_FRIEND,
SYMBOL_TAG_FUNCTION_ARG_TYPE,
SYMBOL_TAG_FUNC_DEBUG_START,
SYMBOL_TAG_FUNC_DEBUG_END,
SYMBOL_TAG_USING_NAMESPACE,
SYMBOL_TAG_VTABLE_SHAPE,
SYMBOL_TAG_VTABLE,
SYMBOL_TAG_CUSTOM,
SYMBOL_TAG_THUNK,
SYMBOL_TAG_CUSTOM_TYPE,
SYMBOL_TAG_MANAGED_TYPE,
SYMBOL_TAG_DIMENSION,
SYMBOL_TAG_MAX
};
enum DataKind
{
DATA_UNKNOWN,
DATA_LOCAL,
DATA_STATIC_LOCAL,
DATA_PARAM,
DATA_OBJECT_PTR, // "this" pointer
DATA_FILE_STATIC,
DATA_GLOBAL,
DATA_MEMBER,
DATA_STATIC_MEMBER,
DATA_CONSTANT,
DATA_MAX
};
enum UdtKind
{
UDT_STRUCT,
UDT_CLASS,
UDT_UNION,
UDT_MAX
};
// function types
typedef DWORD (WINAPI *SymGetOptions_t)();
typedef DWORD (WINAPI *SymSetOptions_t)(DWORD);
typedef BOOL (WINAPI *SymInitialize_t)(HANDLE, LPCSTR, BOOL);
typedef BOOL (WINAPI *SymInitializeW_t)(HANDLE, LPCWSTR, BOOL);
typedef BOOL (WINAPI *StackWalk_t)(DWORD, HANDLE, HANDLE, LPSTACKFRAME,
LPVOID, PREAD_PROCESS_MEMORY_ROUTINE,
PFUNCTION_TABLE_ACCESS_ROUTINE,
PGET_MODULE_BASE_ROUTINE,
PTRANSLATE_ADDRESS_ROUTINE);
typedef BOOL (WINAPI *SymFromAddr_t)(HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO);
typedef BOOL (WINAPI *SymFromAddrW_t)(HANDLE, DWORD64, PDWORD64, PSYMBOL_INFOW);
typedef LPVOID (WINAPI *SymFunctionTableAccess_t)(HANDLE, DWORD_PTR);
typedef DWORD_PTR (WINAPI *SymGetModuleBase_t)(HANDLE, DWORD_PTR);
typedef BOOL (WINAPI *SymGetLineFromAddr_t)(HANDLE, DWORD,
PDWORD, PIMAGEHLP_LINE);
typedef BOOL (WINAPI *SymGetLineFromAddr64_t)(HANDLE, DWORD64,
PDWORD, PIMAGEHLP_LINE64);
typedef BOOL (WINAPI *SymGetLineFromAddrW64_t)(HANDLE, DWORD64,
PDWORD, PIMAGEHLP_LINEW64);
typedef BOOL (WINAPI *SymSetContext_t)(HANDLE, PIMAGEHLP_STACK_FRAME,
PIMAGEHLP_CONTEXT);
typedef BOOL (WINAPI *SymEnumSymbols_t)(HANDLE, ULONG64, PCSTR,
PSYM_ENUMERATESYMBOLS_CALLBACK,
const PVOID);
typedef BOOL (WINAPI *SymEnumSymbolsW_t)(HANDLE, ULONG64, PCWSTR,
PSYM_ENUMERATESYMBOLS_CALLBACKW,
const PVOID);
typedef BOOL (WINAPI *SymGetTypeInfo_t)(HANDLE, DWORD64, ULONG,
IMAGEHLP_SYMBOL_TYPE_INFO, PVOID);
typedef BOOL (WINAPI *SymCleanup_t)(HANDLE);
typedef BOOL (WINAPI *EnumerateLoadedModules_t)(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID);
typedef BOOL (WINAPI *EnumerateLoadedModules64_t)(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID);
typedef BOOL (WINAPI *EnumerateLoadedModulesW64_t)(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID);
typedef BOOL (WINAPI *MiniDumpWriteDump_t)(HANDLE, DWORD, HANDLE,
MINIDUMP_TYPE,
CONST PMINIDUMP_EXCEPTION_INFORMATION,
CONST PMINIDUMP_USER_STREAM_INFORMATION,
CONST PMINIDUMP_CALLBACK_INFORMATION);
// Higher level functions selecting the right debug help library function
// to call: for CallFoo(), it can be Foo(), Foo64(), FooW() or FooW64()
// depending on the build options and function availability.
//
// They also provide more convenient to use wx-specific API, e.g. work with
// wxString instead of char/wchar_t pointers and omit the arguments we
// don't need.
static BOOL CallSymInitialize(HANDLE, BOOL);
static BOOL CallEnumerateLoadedModules(HANDLE, wxPENUMLOADED_MODULES_CALLBACK, PVOID);
static BOOL CallSymFromAddr(HANDLE, DWORD64,
size_t* offset, wxString* name);
static BOOL CallSymGetLineFromAddr(HANDLE, DWORD64,
wxString* fileName, size_t* line);
static BOOL CallSymEnumSymbols(HANDLE hProcess,
ULONG64 baseOfDll,
wxPSYM_ENUMERATESYMBOLS_CALLBACK callback,
const PVOID callbackParam);
// The macro called by wxDO_FOR_ALL_SYM_FUNCS() below takes 2 arguments:
// the name of the function in the program code, which never has "64"
// suffix, and the name of the function in the DLL which can have "64"
// suffix in some cases. These 2 helper macros call the macro with the
// correct arguments in both cases.
#define wxSYM_CALL(what, name) what(name, name)
#if defined(_M_AMD64) || defined(_M_ARM64)
#define wxSYM_CALL_64(what, name) what(name, name ## 64)
// Also undo all the "helpful" definitions done by imagehlp.h that map 32
// bit functions to 64 bit ones, we don't need this as we do it ourselves.
#undef StackWalk
#undef SymFunctionTableAccess
#undef SymGetModuleBase
#undef SymGetLineFromAddr
#undef EnumerateLoadedModules
#else
#define wxSYM_CALL_64(what, name) what(name, name)
#endif
#define wxSYM_CALL_ALWAYS_W(what, name) what(name ## W, name ## W)
#define wxSYM_CALL_ALTERNATIVES(what, name) \
what(name, name); \
what(name ## 64, name ## 64); \
what(name ## W64, name ## W64)
#define wxDO_FOR_ALL_SYM_FUNCS_REQUIRED_PUBLIC(what) \
wxSYM_CALL_64(what, StackWalk); \
wxSYM_CALL_64(what, SymFunctionTableAccess); \
wxSYM_CALL_64(what, SymGetModuleBase); \
\
wxSYM_CALL(what, SymGetOptions); \
wxSYM_CALL(what, SymSetOptions); \
wxSYM_CALL(what, SymSetContext); \
wxSYM_CALL(what, SymGetTypeInfo); \
wxSYM_CALL(what, SymCleanup); \
wxSYM_CALL(what, MiniDumpWriteDump)
#define wxDO_FOR_ALL_SYM_FUNCS_REQUIRED_PRIVATE(what) \
wxSYM_CALL(what, SymInitialize); \
wxSYM_CALL(what, SymFromAddr); \
wxSYM_CALL(what, SymEnumSymbols)
#define wxDO_FOR_ALL_SYM_FUNCS_REQUIRED(what) \
wxDO_FOR_ALL_SYM_FUNCS_REQUIRED_PRIVATE(what); \
wxDO_FOR_ALL_SYM_FUNCS_REQUIRED_PUBLIC(what)
// Alternation will work when the following functions are not found,
// therefore they are not included in REQUIRED version.
#define wxDO_FOR_ALL_SYM_FUNCS_OPTIONAL(what) \
wxSYM_CALL_ALTERNATIVES(what, SymGetLineFromAddr); \
wxSYM_CALL_ALTERNATIVES(what, EnumerateLoadedModules); \
wxSYM_CALL_ALWAYS_W(what, SymInitialize); \
wxSYM_CALL_ALWAYS_W(what, SymFromAddr); \
wxSYM_CALL_ALWAYS_W(what, SymEnumSymbols)
#define wxDO_FOR_ALL_SYM_FUNCS(what) \
wxDO_FOR_ALL_SYM_FUNCS_REQUIRED(what); \
wxDO_FOR_ALL_SYM_FUNCS_OPTIONAL(what)
#define wxDECLARE_SYM_FUNCTION(func, name) static func ## _t func
wxDO_FOR_ALL_SYM_FUNCS_REQUIRED_PUBLIC(wxDECLARE_SYM_FUNCTION);
private:
wxDO_FOR_ALL_SYM_FUNCS_REQUIRED_PRIVATE(wxDECLARE_SYM_FUNCTION);
wxDO_FOR_ALL_SYM_FUNCS_OPTIONAL(wxDECLARE_SYM_FUNCTION);
public:
#undef wxDECLARE_SYM_FUNCTION
// load all functions from DLL, return true if ok
static bool Init();
// return the string with the error message explaining why Init() failed
static const wxString& GetErrorMessage();
// log error returned by the given function to debug output
static void LogError(const wxChar *func);
// return textual representation of the value of given symbol
static wxString DumpSymbol(wxPSYMBOL_INFO pSymInfo, void *pVariable);
// return the name of the symbol with given type index
static wxString GetSymbolName(wxPSYMBOL_INFO pSymInfo);
private:
// dereference the given symbol, i.e. return symbol which is not a
// pointer/reference any more
//
// if ppData != NULL, dereference the pointer as many times as we
// dereferenced the symbol
//
// return the tag of the dereferenced symbol
static SymbolTag DereferenceSymbol(wxPSYMBOL_INFO pSymInfo, void **ppData);
static wxString DumpField(wxPSYMBOL_INFO pSymInfo,
void *pVariable,
unsigned level);
static wxString DumpBaseType(BasicType bt, DWORD64 length, void *pVariable);
static wxString DumpUDT(wxPSYMBOL_INFO pSymInfo,
void *pVariable,
unsigned level = 0);
static bool BindDbgHelpFunctions(const wxDynamicLibrary& dllDbgHelp);
static bool DoInit();
};
#endif // wxUSE_DBGHELP
#endif // _WX_MSW_DEBUGHLPH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/glcanvas.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/glcanvas.h
// Purpose: wxGLCanvas, for using OpenGL with wxWidgets under Windows
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GLCANVAS_H_
#define _WX_GLCANVAS_H_
#include "wx/palette.h"
#include "wx/msw/wrapwin.h"
#include <GL/gl.h>
// ----------------------------------------------------------------------------
// wxGLContext: OpenGL rendering context
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLContext : public wxGLContextBase
{
public:
wxGLContext(wxGLCanvas *win,
const wxGLContext *other = NULL,
const wxGLContextAttrs *ctxAttrs = NULL);
virtual ~wxGLContext();
virtual bool SetCurrent(const wxGLCanvas& win) const wxOVERRIDE;
HGLRC GetGLRC() const { return m_glContext; }
protected:
HGLRC m_glContext;
private:
wxDECLARE_CLASS(wxGLContext);
};
// ----------------------------------------------------------------------------
// wxGLCanvas: OpenGL output window
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasBase
{
public:
explicit // avoid implicitly converting a wxWindow* to wxGLCanvas
wxGLCanvas(wxWindow *parent,
const wxGLAttributes& dispAttrs,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const wxPalette& palette = wxNullPalette);
explicit
wxGLCanvas(wxWindow *parent,
wxWindowID id = wxID_ANY,
const int *attribList = NULL,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const wxPalette& palette = wxNullPalette);
bool Create(wxWindow *parent,
const wxGLAttributes& dispAttrs,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const wxPalette& palette = wxNullPalette);
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette);
virtual ~wxGLCanvas();
// implement wxGLCanvasBase methods
virtual bool SwapBuffers() wxOVERRIDE;
// MSW-specific helpers
// --------------------
// get the HDC used for OpenGL rendering
HDC GetHDC() const { return m_hDC; }
// Try to find pixel format matching the given attributes list for the
// specified HDC, return 0 on error, otherwise ppfd is filled in with the
// information from dispAttrs
static int FindMatchingPixelFormat(const wxGLAttributes& dispAttrs,
PIXELFORMATDESCRIPTOR* ppfd = NULL);
// Same as FindMatchingPixelFormat
static int ChooseMatchingPixelFormat(HDC hdc, const int *attribList,
PIXELFORMATDESCRIPTOR *pfd = NULL);
#if wxUSE_PALETTE
// palette stuff
bool SetupPalette(const wxPalette& palette);
virtual wxPalette CreateDefaultPalette() wxOVERRIDE;
void OnQueryNewPalette(wxQueryNewPaletteEvent& event);
void OnPaletteChanged(wxPaletteChangedEvent& event);
#endif // wxUSE_PALETTE
// deprecated methods using the implicit wxGLContext, associate the context
// explicitly with the window instead
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED(
wxGLCanvas(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette)
);
wxDEPRECATED(
wxGLCanvas(wxWindow *parent,
const wxGLContext *shared,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette)
);
wxDEPRECATED(
wxGLCanvas(wxWindow *parent,
const wxGLCanvas *shared,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName,
const int *attribList = NULL,
const wxPalette& palette = wxNullPalette)
);
#endif // WXWIN_COMPATIBILITY_2_8
protected:
// common part of all ctors
void Init();
// the real window creation function, Create() may reuse it twice as we may
// need to create an OpenGL window to query the available extensions and
// then potentially delete and recreate it with another pixel format
bool CreateWindow(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxGLCanvasName);
// set up the pixel format using the given attributes and palette
int DoSetup(PIXELFORMATDESCRIPTOR &pfd, const int *attribList);
// HDC for this window, we keep it all the time
HDC m_hDC;
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_CLASS(wxGLCanvas);
};
#endif // _WX_GLCANVAS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/window.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/window.h
// Purpose: wxWindowMSW class
// Author: Julian Smart
// Modified by: Vadim Zeitlin on 13.05.99: complete refont of message handling,
// elimination of Default(), ...
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WINDOW_H_
#define _WX_WINDOW_H_
#include "wx/settings.h" // solely for wxSystemColour
class WXDLLIMPEXP_FWD_CORE wxButton;
// if this is set to 1, we use deferred window sizing to reduce flicker when
// resizing complicated window hierarchies, but this can in theory result in
// different behaviour than the old code so we keep the possibility to use it
// by setting this to 0 (in the future this should be removed completely)
#define wxUSE_DEFERRED_SIZING 1
// ---------------------------------------------------------------------------
// wxWindow declaration for MSW
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowMSW : public wxWindowBase
{
friend class wxSpinCtrl;
friend class wxSlider;
friend class wxRadioBox;
public:
wxWindowMSW() { Init(); }
wxWindowMSW(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
virtual ~wxWindowMSW();
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr)
{
return CreateUsingMSWClass(GetMSWClassName(style),
parent, id, pos, size, style, name);
}
// Non-portable, MSW-specific Create() variant allowing to create the
// window with a custom Windows class name. This can be useful to assign a
// custom Windows class, that can be recognized from the outside of the
// application, for windows of specific type.
bool CreateUsingMSWClass(const wxChar* classname,
wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr);
// implement base class pure virtuals
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual wxString GetLabel() const wxOVERRIDE;
virtual void Raise() wxOVERRIDE;
virtual void Lower() wxOVERRIDE;
#if wxUSE_DEFERRED_SIZING
virtual bool BeginRepositioningChildren() wxOVERRIDE;
virtual void EndRepositioningChildren() wxOVERRIDE;
#endif // wxUSE_DEFERRED_SIZING
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool ShowWithEffect(wxShowEffect effect,
unsigned timeout = 0) wxOVERRIDE
{
return MSWShowWithEffect(true, effect, timeout);
}
virtual bool HideWithEffect(wxShowEffect effect,
unsigned timeout = 0) wxOVERRIDE
{
return MSWShowWithEffect(false, effect, timeout);
}
virtual void SetFocus() wxOVERRIDE;
virtual void SetFocusFromKbd() wxOVERRIDE;
virtual bool Reparent(wxWindowBase *newParent) wxOVERRIDE;
virtual void WarpPointer(int x, int y) wxOVERRIDE;
virtual bool EnableTouchEvents(int eventsMask) wxOVERRIDE;
virtual void Refresh( bool eraseBackground = true,
const wxRect *rect = (const wxRect *) NULL ) wxOVERRIDE;
virtual void Update() wxOVERRIDE;
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
virtual void SetExtraStyle(long exStyle) wxOVERRIDE;
virtual bool SetCursor( const wxCursor &cursor ) wxOVERRIDE;
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
virtual int GetCharHeight() const wxOVERRIDE;
virtual int GetCharWidth() const wxOVERRIDE;
virtual void SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh = true ) wxOVERRIDE;
virtual void SetScrollPos( int orient, int pos, bool refresh = true ) wxOVERRIDE;
virtual int GetScrollPos( int orient ) const wxOVERRIDE;
virtual int GetScrollThumb( int orient ) const wxOVERRIDE;
virtual int GetScrollRange( int orient ) const wxOVERRIDE;
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = NULL ) wxOVERRIDE;
virtual bool ScrollLines(int lines) wxOVERRIDE;
virtual bool ScrollPages(int pages) wxOVERRIDE;
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
virtual wxLayoutDirection GetLayoutDirection() const wxOVERRIDE;
virtual wxCoord AdjustForLayoutDirection(wxCoord x,
wxCoord width,
wxCoord widthTotal) const wxOVERRIDE;
virtual void SetId(wxWindowID winid) wxOVERRIDE;
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget ) wxOVERRIDE;
// Accept files for dragging
virtual void DragAcceptFiles(bool accept) wxOVERRIDE;
#endif // wxUSE_DRAG_AND_DROP
#ifndef __WXUNIVERSAL__
// Native resource loading (implemented in src/msw/nativdlg.cpp)
// FIXME: should they really be all virtual?
virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID id);
virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
wxWindow* GetWindowChild1(wxWindowID id);
wxWindow* GetWindowChild(wxWindowID id);
#endif // __WXUNIVERSAL__
#if wxUSE_HOTKEY
// install and deinstall a system wide hotkey
virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode) wxOVERRIDE;
virtual bool UnregisterHotKey(int hotkeyId) wxOVERRIDE;
#endif // wxUSE_HOTKEY
// window handle stuff
// -------------------
WXHWND GetHWND() const { return m_hWnd; }
void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
virtual WXWidget GetHandle() const wxOVERRIDE { return GetHWND(); }
void AssociateHandle(WXWidget handle) wxOVERRIDE;
void DissociateHandle() wxOVERRIDE;
// does this window have deferred position and/or size?
bool IsSizeDeferred() const;
// these functions allow to register a global handler for the given Windows
// message: it will be called from MSWWindowProc() of any window which gets
// this event if it's not processed before (i.e. unlike a hook procedure it
// does not override the normal processing)
//
// notice that if you want to process a message for a given window only you
// should override its MSWWindowProc() instead
// type of the handler: it is called with the message parameters (except
// that the window object is passed instead of window handle) and should
// return true if it handled the message or false if it should be passed to
// DefWindowProc()
typedef bool (*MSWMessageHandler)(wxWindowMSW *win,
WXUINT nMsg,
WXWPARAM wParam,
WXLPARAM lParam);
// install a handler, shouldn't be called more than one for the same message
static bool MSWRegisterMessageHandler(int msg, MSWMessageHandler handler);
// unregister a previously registered handler
static void MSWUnregisterMessageHandler(int msg, MSWMessageHandler handler);
// implementation from now on
// ==========================
// event handlers
// --------------
void OnPaint(wxPaintEvent& event);
public:
// Windows subclassing
void SubclassWin(WXHWND hWnd);
void UnsubclassWin();
WXWNDPROC MSWGetOldWndProc() const { return m_oldWndProc; }
void MSWSetOldWndProc(WXWNDPROC proc) { m_oldWndProc = proc; }
// return true if the window is of a standard (i.e. not wxWidgets') class
//
// to understand why does it work, look at SubclassWin() code and comments
bool IsOfStandardClass() const { return m_oldWndProc != NULL; }
wxWindow *FindItem(long id, WXHWND hWnd = NULL) const;
wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = false) const;
// MSW only: true if this control is part of the main control
virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return false; }
#if wxUSE_TOOLTIPS
// MSW only: true if this window or any of its children have a tooltip
virtual bool HasToolTips() const { return GetToolTip() != NULL; }
#endif // wxUSE_TOOLTIPS
// translate wxWidgets style flags for this control into the Windows style
// and optional extended style for the corresponding native control
//
// this is the function that should be overridden in the derived classes,
// but you will mostly use MSWGetCreateWindowFlags() below
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const ;
// get the MSW window flags corresponding to wxWidgets ones
//
// the functions returns the flags (WS_XXX) directly and puts the ext
// (WS_EX_XXX) flags into the provided pointer if not NULL
WXDWORD MSWGetCreateWindowFlags(WXDWORD *exflags = NULL) const
{ return MSWGetStyle(GetWindowStyle(), exflags); }
// update the real underlying window style flags to correspond to the
// current wxWindow object style (safe to call even if window isn't fully
// created yet)
void MSWUpdateStyle(long flagsOld, long exflagsOld);
// get the HWND to be used as parent of this window with CreateWindow()
virtual WXHWND MSWGetParent() const;
// Return the name of the Win32 class that should be used by this wxWindow
// object, taking into account wxFULL_REPAINT_ON_RESIZE style (if it's not
// specified, the wxApp::GetNoRedrawClassSuffix()-suffixed version of the
// class is used).
static const wxChar *GetMSWClassName(long style);
// creates the window of specified Windows class with given style, extended
// style, title and geometry (default values
//
// returns true if the window has been created, false if creation failed
bool MSWCreate(const wxChar *wclass,
const wxChar *title = NULL,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
WXDWORD style = 0,
WXDWORD exendedStyle = 0);
virtual bool MSWCommand(WXUINT param, WXWORD id);
#ifndef __WXUNIVERSAL__
// Create an appropriate wxWindow from a HWND
virtual wxWindow* CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd);
// Make sure the window style reflects the HWND style (roughly)
virtual void AdoptAttributesFromHWND();
#endif // __WXUNIVERSAL__
// Setup background and foreground colours correctly
virtual void SetupColours();
// ------------------------------------------------------------------------
// helpers for message handlers: these perform the same function as the
// message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
// the correct parameters
// ------------------------------------------------------------------------
void UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *id, WXHWND *hwnd, WXWORD *cmd);
void UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *state, WXWORD *minimized, WXHWND *hwnd);
void UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *code, WXWORD *pos, WXHWND *hwnd);
void UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
WXHDC *hdc, WXHWND *hwnd);
void UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
WXWORD *item, WXWORD *flags, WXHMENU *hmenu);
// ------------------------------------------------------------------------
// internal handlers for MSW messages: all handlers return a boolean value:
// true means that the handler processed the event and false that it didn't
// ------------------------------------------------------------------------
// there are several cases where we have virtual functions for Windows
// message processing: this is because these messages often require to be
// processed in a different manner in the derived classes. For all other
// messages, however, we do *not* have corresponding MSWOnXXX() function
// and if the derived class wants to process them, it should override
// MSWWindowProc() directly.
// scroll event (both horizontal and vertical)
virtual bool MSWOnScroll(int orientation, WXWORD nSBCode,
WXWORD pos, WXHWND control);
// child control notifications
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
// owner-drawn controls need to process these messages
virtual bool MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *item);
virtual bool MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *item);
// the rest are not virtual
bool HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate);
bool HandleInitDialog(WXHWND hWndFocus);
bool HandleDestroy();
bool HandlePaint();
bool HandlePrintClient(WXHDC hDC);
bool HandleEraseBkgnd(WXHDC hDC);
bool HandleMinimize();
bool HandleMaximize();
bool HandleSize(int x, int y, WXUINT flag);
bool HandleSizing(wxRect& rect);
bool HandleGetMinMaxInfo(void *mmInfo);
bool HandleEnterSizeMove();
bool HandleExitSizeMove();
bool HandleShow(bool show, int status);
bool HandleActivate(int flag, bool minimized, WXHWND activate);
bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);
bool HandleCtlColor(WXHBRUSH *hBrush, WXHDC hdc, WXHWND hWnd);
bool HandlePaletteChanged(WXHWND hWndPalChange);
bool HandleQueryNewPalette();
bool HandleSysColorChange();
bool HandleDisplayChange();
bool HandleCaptureChanged(WXHWND gainedCapture);
virtual bool HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam);
bool HandleQueryEndSession(long logOff, bool *mayEnd);
bool HandleEndSession(bool endSession, long logOff);
bool HandleSetFocus(WXHWND wnd);
bool HandleKillFocus(WXHWND wnd);
bool HandleDropFiles(WXWPARAM wParam);
bool HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags);
bool HandleMouseMove(int x, int y, WXUINT flags);
bool HandleMouseWheel(wxMouseWheelAxis axis,
WXWPARAM wParam, WXLPARAM lParam);
// Common gesture event initialization, returns true if it is the initial
// event (GF_BEGIN set in flags), false otherwise.
bool InitGestureEvent(wxGestureEvent& event, const wxPoint& pt, WXDWORD flags);
bool HandlePanGesture(const wxPoint& pt, WXDWORD flags);
bool HandleZoomGesture(const wxPoint& pt, WXDWORD fingerDistance, WXDWORD flags);
bool HandleRotateGesture(const wxPoint& pt, WXDWORD angleArgument, WXDWORD flags);
bool HandleTwoFingerTap(const wxPoint& pt, WXDWORD flags);
bool HandlePressAndTap(const wxPoint& pt, WXDWORD flags);
bool HandleChar(WXWPARAM wParam, WXLPARAM lParam);
bool HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam);
bool HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam);
#if wxUSE_HOTKEY
bool HandleHotKey(WXWPARAM wParam, WXLPARAM lParam);
#endif
int HandleMenuChar(int chAccel, WXLPARAM lParam);
// Create and process a clipboard event specified by type.
bool HandleClipboardEvent( WXUINT nMsg );
bool HandleQueryDragIcon(WXHICON *hIcon);
bool HandleSetCursor(WXHWND hWnd, short nHitTest, int mouseMsg);
bool HandlePower(WXWPARAM wParam, WXLPARAM lParam, bool *vetoed);
// The main body of common window proc for all wxWindow objects. It tries
// to handle the given message and returns true if it was handled (the
// appropriate return value is then put in result, which must be non-NULL)
// or false if it wasn't.
//
// This function should be overridden in any new code instead of
// MSWWindowProc() even if currently most of the code overrides
// MSWWindowProc() as it had been written before this function was added.
virtual bool MSWHandleMessage(WXLRESULT *result,
WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam);
// Common Window procedure for all wxWindow objects: forwards to
// MSWHandleMessage() and MSWDefWindowProc() if the message wasn't handled.
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
// Calls an appropriate default window procedure
virtual WXLRESULT MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
// message processing helpers
// return false if the message shouldn't be translated/preprocessed but
// dispatched normally
virtual bool MSWShouldPreProcessMessage(WXMSG* pMsg);
// return true if the message was preprocessed and shouldn't be dispatched
virtual bool MSWProcessMessage(WXMSG* pMsg);
// return true if the message was translated and shouldn't be dispatched
virtual bool MSWTranslateMessage(WXMSG* pMsg);
// called when the window is about to be destroyed
virtual void MSWDestroyWindow();
// Functions dealing with painting the window background. The derived
// classes should normally only need to reimplement MSWGetBgBrush() if they
// need to use a non-solid brush for erasing their background. This
// function is called by MSWGetBgBrushForChild() which only exists for the
// weird wxToolBar case and MSWGetBgBrushForChild() itself is used by
// MSWGetBgBrush() to actually find the right brush to use.
// Adjust the origin for the brush returned by MSWGetBgBrushForChild().
//
// This needs to be overridden for scrolled windows to ensure that the
// scrolling of their associated DC is taken into account.
//
// Both parameters must be non-NULL.
virtual void MSWAdjustBrushOrg(int* WXUNUSED(xOrg),
int* WXUNUSED(yOrg)) const
{
}
// The brush returned from here must remain valid at least until the next
// event loop iteration. Returning 0, as is done by default, indicates
// there is no custom background brush.
virtual WXHBRUSH MSWGetCustomBgBrush() { return 0; }
// this function should return the brush to paint the children controls
// background or 0 if this window doesn't impose any particular background
// on its children
//
// the hDC parameter is the DC background will be drawn on, it can be used
// to call SetBrushOrgEx() on it if the returned brush is a bitmap one
//
// child parameter is never NULL, it can be this window itself or one of
// its (grand)children
//
// the base class version returns a solid brush if we have a non default
// background colour or 0 otherwise
virtual WXHBRUSH MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child);
// return the background brush to use for painting the given window by
// querying the parent windows via MSWGetBgBrushForChild() recursively
WXHBRUSH MSWGetBgBrush(WXHDC hDC);
enum MSWThemeColour
{
ThemeColourText = 0,
ThemeColourBackground,
ThemeColourBorder
};
// returns a specific theme colour, or if that is not possible then
// wxSystemSettings::GetColour(fallback)
wxColour MSWGetThemeColour(const wchar_t *themeName,
int themePart,
int themeState,
MSWThemeColour themeColour,
wxSystemColour fallback) const;
// gives the parent the possibility to draw its children background, e.g.
// this is used by wxNotebook to do it using DrawThemeBackground()
//
// return true if background was drawn, false otherwise
virtual bool MSWPrintChild(WXHDC WXUNUSED(hDC), wxWindow * WXUNUSED(child))
{
return false;
}
// some controls (e.g. wxListBox) need to set the return value themselves
//
// return true to let parent handle it if we don't, false otherwise
virtual bool MSWShouldPropagatePrintChild()
{
return true;
}
// This should be overridden to return true for the controls which have
// themed background that should through their children. Currently only
// wxNotebook uses this.
//
// The base class version already returns true if we have a solid
// background colour that should be propagated to our children.
virtual bool MSWHasInheritableBackground() const
{
return InheritsBackgroundColour();
}
#if !defined(__WXUNIVERSAL__)
#define wxHAS_MSW_BACKGROUND_ERASE_HOOK
#endif
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
// allows the child to hook into its parent WM_ERASEBKGND processing: call
// MSWSetEraseBgHook() with a non-NULL window to make parent call
// MSWEraseBgHook() on this window (don't forget to reset it to NULL
// afterwards)
//
// this hack is used by wxToolBar, see comments there
void MSWSetEraseBgHook(wxWindow *child);
// return true if WM_ERASEBKGND is currently hooked
bool MSWHasEraseBgHook() const;
// called when the window on which MSWSetEraseBgHook() had been called
// receives WM_ERASEBKGND
virtual bool MSWEraseBgHook(WXHDC WXUNUSED(hDC)) { return false; }
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
// common part of Show/HideWithEffect()
bool MSWShowWithEffect(bool show,
wxShowEffect effect,
unsigned timeout);
// Responds to colour changes: passes event on to children.
void OnSysColourChanged(wxSysColourChangedEvent& event);
// initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX)
void InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags);
// check if mouse is in the window
bool IsMouseInWindow() const;
virtual void SetDoubleBuffered(bool on) wxOVERRIDE;
virtual bool IsDoubleBuffered() const wxOVERRIDE;
// synthesize a wxEVT_LEAVE_WINDOW event and set m_mouseInWindow to false
void GenerateMouseLeave();
// virtual function for implementing internal idle
// behaviour
virtual void OnInternalIdle() wxOVERRIDE;
#if wxUSE_MENUS && !defined(__WXUNIVERSAL__)
virtual bool HandleMenuSelect(WXWORD nItem, WXWORD nFlags, WXHMENU hMenu);
// handle WM_(UN)INITMENUPOPUP message to generate wxEVT_MENU_OPEN/CLOSE
bool HandleMenuPopup(wxEventType evtType, WXHMENU hMenu);
// Command part of HandleMenuPopup() and HandleExitMenuLoop().
virtual bool DoSendMenuOpenCloseEvent(wxEventType evtType, wxMenu* menu);
// Find the menu corresponding to the given handle.
virtual wxMenu* MSWFindMenuFromHMENU(WXHMENU hMenu);
#endif // wxUSE_MENUS && !__WXUNIVERSAL__
// Return the default button for the TLW containing this window or NULL if
// none.
static wxButton* MSWGetDefaultButtonFor(wxWindow* win);
// Simulate a click on the given button if it is non-null, enabled and
// shown.
//
// Return true if the button was clicked, false otherwise.
static bool MSWClickButtonIfPossible(wxButton* btn);
protected:
// this allows you to implement standard control borders without
// repeating the code in different classes that are not derived from
// wxControl
virtual wxBorder GetDefaultBorderForControl() const wxOVERRIDE;
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE;
// Translate wxBORDER_THEME (and other border styles if necessary to the value
// that makes most sense for this Windows environment
virtual wxBorder TranslateBorder(wxBorder border) const;
#if wxUSE_MENUS_NATIVE
virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) wxOVERRIDE;
#endif // wxUSE_MENUS_NATIVE
// the window handle
WXHWND m_hWnd;
// the old window proc (we subclass all windows)
WXWNDPROC m_oldWndProc;
// additional (MSW specific) flags
bool m_mouseInWindow:1;
bool m_lastKeydownProcessed:1;
// the size of one page for scrolling
int m_xThumbSize;
int m_yThumbSize;
// implement the base class pure virtuals
virtual void DoGetTextExtent(const wxString& string,
int *x, int *y,
int *descent = NULL,
int *externalLeading = NULL,
const wxFont *font = NULL) const wxOVERRIDE;
virtual void DoClientToScreen( int *x, int *y ) const wxOVERRIDE;
virtual void DoScreenToClient( int *x, int *y ) const wxOVERRIDE;
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 DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
virtual wxSize DoGetBorderSize() const wxOVERRIDE;
virtual void DoCaptureMouse() wxOVERRIDE;
virtual void DoReleaseMouse() wxOVERRIDE;
virtual void DoEnable(bool enable) wxOVERRIDE;
virtual void DoFreeze() wxOVERRIDE;
virtual void DoThaw() wxOVERRIDE;
// this simply moves/resizes the given HWND which is supposed to be our
// sibling (this is useful for controls which are composite at MSW level
// and for which DoMoveWindow() is not enough)
//
// returns true if the window move was deferred, false if it was moved
// immediately (no error return)
bool DoMoveSibling(WXHWND hwnd, int x, int y, int width, int height);
// move the window to the specified location and resize it: this is called
// from both DoSetSize() and DoSetClientSize() and would usually just call
// ::MoveWindow() except for composite controls which will want to arrange
// themselves inside the given rectangle
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE;
// process TTN_NEEDTEXT message properly (i.e. fixing the bugs in
// comctl32.dll in our code -- see the function body for more info)
bool HandleTooltipNotify(WXUINT code,
WXLPARAM lParam,
const wxString& ttip);
#endif // wxUSE_TOOLTIPS
// This is used by CreateKeyEvent() and also for wxEVT_CHAR[_HOOK] event
// creation. Notice that this method doesn't initialize wxKeyEvent
// m_keyCode and m_uniChar fields.
void InitAnyKeyEvent(wxKeyEvent& event,
WXWPARAM wParam,
WXLPARAM lParam) const;
// Helper functions used by HandleKeyXXX() methods and some derived
// classes, wParam and lParam have the same meaning as in WM_KEY{DOWN,UP}.
//
// NB: evType here must be wxEVT_KEY_{DOWN,UP} as wParam here contains the
// virtual key code, not character!
wxKeyEvent CreateKeyEvent(wxEventType evType,
WXWPARAM wParam,
WXLPARAM lParam = 0) const;
// Another helper for creating wxKeyEvent for wxEVT_CHAR and related types.
//
// The wParam and lParam here must come from WM_CHAR event parameters, i.e.
// wParam must be a character and not a virtual code.
wxKeyEvent CreateCharEvent(wxEventType evType,
WXWPARAM wParam,
WXLPARAM lParam) const;
// default OnEraseBackground() implementation, return true if we did erase
// the background, false otherwise (i.e. the system should erase it)
bool DoEraseBackground(WXHDC hDC);
// generate WM_CHANGEUISTATE if it's needed for the OS we're running under
//
// action should be one of the UIS_XXX constants
// state should be one or more of the UISF_XXX constants
// if action == UIS_INITIALIZE then it doesn't seem to matter what we use
// for state as the system will decide for us what needs to be set
void MSWUpdateUIState(int action, int state = 0);
// translate wxWidgets coords into Windows ones suitable to be passed to
// ::CreateWindow(), called from MSWCreate()
virtual void MSWGetCreateWindowCoords(const wxPoint& pos,
const wxSize& size,
int& x, int& y,
int& w, int& h) const;
bool MSWEnableHWND(WXHWND hWnd, bool enable);
// Return the pointer to this window or one of its sub-controls if this ID
// and HWND combination belongs to one of them.
//
// This is used by FindItem() and is overridden in wxControl, see there.
virtual wxWindow* MSWFindItem(long WXUNUSED(id), WXHWND WXUNUSED(hWnd)) const
{
return NULL;
}
private:
// common part of all ctors
void Init();
// the (non-virtual) handlers for the events
bool HandleMove(int x, int y);
bool HandleMoving(wxRect& rect);
bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags);
bool HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
#ifndef __WXUNIVERSAL__
// Call ::IsDialogMessage() if it is safe to do it (i.e. if it's not going
// to hang or do something else stupid) with the given message, return true
// if the message was handled by it.
bool MSWSafeIsDialogMessage(WXMSG* msg);
#endif // __WXUNIVERSAL__
static inline bool MSWIsPositionDirectlySupported(int x, int y)
{
// The supported coordinate intervals for various functions are:
// - MoveWindow, DeferWindowPos: [-32768, 32767] a.k.a. [SHRT_MIN, SHRT_MAX];
// - CreateWindow, CreateWindowEx: [-32768, 32554].
// CreateXXX will _sometimes_ manage to create the window at higher coordinates
// like 32580, 32684, 32710, but that was not consistent and the lowest common
// limit was 32554 (so far at least).
return (x >= SHRT_MIN && x <= 32554 && y >= SHRT_MIN && y <= 32554);
}
protected:
WXHWND MSWCreateWindowAtAnyPosition(WXDWORD exStyle, const wxChar* clName,
const wxChar* title, WXDWORD style,
int x, int y, int width, int height,
WXHWND parent, wxWindowID id);
void MSWMoveWindowToAnyPosition(WXHWND hwnd, int x, int y,
int width, int height, bool bRepaint);
#if wxUSE_DEFERRED_SIZING
// this function is called after the window was resized to its new size
virtual void MSWEndDeferWindowPos()
{
m_pendingPosition = wxDefaultPosition;
m_pendingSize = wxDefaultSize;
}
// current defer window position operation handle (may be NULL)
WXHANDLE m_hDWP;
// When deferred positioning is done these hold the pending changes, and
// are used for the default values if another size/pos changes is done on
// this window before the group of deferred changes is completed.
wxPoint m_pendingPosition;
wxSize m_pendingSize;
#endif // wxUSE_DEFERRED_SIZING
private:
wxDECLARE_DYNAMIC_CLASS(wxWindowMSW);
wxDECLARE_NO_COPY_CLASS(wxWindowMSW);
wxDECLARE_EVENT_TABLE();
};
// window creation helper class: before creating a new HWND, instantiate an
// object of this class on stack - this allows to process the messages sent to
// the window even before CreateWindow() returns
class wxWindowCreationHook
{
public:
wxWindowCreationHook(wxWindowMSW *winBeingCreated);
~wxWindowCreationHook();
};
#endif // _WX_WINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/appprogress.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/appprogress.h
// Purpose: wxAppProgressIndicator interface.
// Author: Chaobin Zhang <[email protected]>
// Created: 2014-09-05
// Copyright: (c) 2014 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_APPPROG_H_
#define _WX_MSW_APPPROG_H_
#include "wx/vector.h"
class WXDLLIMPEXP_FWD_CORE wxTaskBarButton;
class WXDLLIMPEXP_CORE wxAppProgressIndicator
: public wxAppProgressIndicatorBase
{
public:
wxAppProgressIndicator(wxWindow* parent = NULL, int maxValue = 100);
virtual ~wxAppProgressIndicator();
virtual bool IsAvailable() const wxOVERRIDE;
virtual void SetValue(int value) wxOVERRIDE;
virtual void SetRange(int range) wxOVERRIDE;
virtual void Pulse() wxOVERRIDE;
virtual void Reset() wxOVERRIDE;
private:
int m_maxValue;
wxVector<wxTaskBarButton*> m_taskBarButtons;
wxDECLARE_NO_COPY_CLASS(wxAppProgressIndicator);
};
#endif // _WX_MSW_APPPROG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/apptbase.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/apptbase.h
// Purpose: declaration of wxAppTraits for MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 22.06.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_APPTBASE_H_
#define _WX_MSW_APPTBASE_H_
// ----------------------------------------------------------------------------
// wxAppTraits: the MSW version adds extra hooks needed by MSW-only code
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxAppTraits : public wxAppTraitsBase
{
public:
// wxExecute() support methods
// ---------------------------
// called before starting to wait for the child termination, may return
// some opaque data which will be passed later to AfterChildWaitLoop()
virtual void *BeforeChildWaitLoop() = 0;
// called after starting to wait for the child termination, the parameter
// is the return value of BeforeChildWaitLoop()
virtual void AfterChildWaitLoop(void *data) = 0;
#if wxUSE_THREADS
// wxThread helpers
// ----------------
// process a message while waiting for a(nother) thread, should return
// false if and only if we have to exit the application
virtual bool DoMessageFromThreadWait() = 0;
// wait for the handle to be signaled, return WAIT_OBJECT_0 if it is or, in
// the GUI code, WAIT_OBJECT_0 + 1 if a Windows message arrived
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags) = 0;
#endif // wxUSE_THREADS
// console helpers
// ---------------
// this method can be overridden by a derived class to always return true
// or false to force [not] using the console for output to stderr
//
// by default console applications always return true from here while the
// GUI ones only return true if they're being run from console and there is
// no other activity happening in this console
virtual bool CanUseStderr() = 0;
// write text to the console, return true if ok or false on error
virtual bool WriteToStderr(const wxString& text) = 0;
protected:
#if wxUSE_THREADS
// implementation of WaitForThread() for the console applications which is
// also used by the GUI code if it doesn't [yet|already] dispatch events
WXDWORD DoSimpleWaitForThread(WXHANDLE hThread);
#endif // wxUSE_THREADS
};
#endif // _WX_MSW_APPTBASE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/dc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dc.h
// Purpose: wxDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DC_H_
#define _WX_MSW_DC_H_
#include "wx/defs.h"
#include "wx/dc.h"
// ---------------------------------------------------------------------------
// macros
// ---------------------------------------------------------------------------
#if wxUSE_DC_CACHEING
/*
* Cached blitting, maintaining a cache
* of bitmaps required for transparent blitting
* instead of constant creation/deletion
*/
class wxDCCacheEntry: public wxObject
{
public:
wxDCCacheEntry(WXHBITMAP hBitmap, int w, int h, int depth);
wxDCCacheEntry(WXHDC hDC, int depth);
virtual ~wxDCCacheEntry();
WXHBITMAP m_bitmap;
WXHDC m_dc;
int m_width;
int m_height;
int m_depth;
};
#endif
// this is an ABC: use one of the derived classes to create a DC associated
// with a window, screen, printer and so on
class WXDLLIMPEXP_CORE wxMSWDCImpl: public wxDCImpl
{
public:
wxMSWDCImpl(wxDC *owner, WXHDC hDC);
virtual ~wxMSWDCImpl();
// implement base class pure virtuals
// ----------------------------------
virtual void Clear() wxOVERRIDE;
virtual bool StartDoc(const wxString& message) wxOVERRIDE;
virtual void EndDoc() wxOVERRIDE;
virtual void StartPage() wxOVERRIDE;
virtual void EndPage() 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 SetBackgroundMode(int mode) wxOVERRIDE;
#if wxUSE_PALETTE
virtual void SetPalette(const wxPalette& palette) wxOVERRIDE;
#endif // wxUSE_PALETTE
virtual void DestroyClippingRegion() wxOVERRIDE;
virtual wxCoord GetCharHeight() const wxOVERRIDE;
virtual wxCoord GetCharWidth() const wxOVERRIDE;
virtual bool CanDrawBitmap() const wxOVERRIDE;
virtual bool CanGetTextExtent() const wxOVERRIDE;
virtual int GetDepth() const wxOVERRIDE;
virtual wxSize GetPPI() const wxOVERRIDE;
virtual void SetMapMode(wxMappingMode mode) wxOVERRIDE;
virtual void SetUserScale(double x, double y) wxOVERRIDE;
virtual void SetLogicalScale(double x, double y) wxOVERRIDE;
virtual void SetLogicalOrigin(wxCoord x, wxCoord y) wxOVERRIDE;
virtual void SetDeviceOrigin(wxCoord x, wxCoord y) wxOVERRIDE;
virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp) wxOVERRIDE;
#if wxUSE_DC_TRANSFORM_MATRIX
virtual bool CanUseTransformMatrix() const wxOVERRIDE;
virtual bool SetTransformMatrix(const wxAffineMatrix2D& matrix) wxOVERRIDE;
virtual wxAffineMatrix2D GetTransformMatrix() const wxOVERRIDE;
virtual void ResetTransformMatrix() wxOVERRIDE;
#endif // wxUSE_DC_TRANSFORM_MATRIX
virtual void SetLogicalFunction(wxRasterOperationMode function) wxOVERRIDE;
// implementation from now on
// --------------------------
virtual void SetRop(WXHDC cdc);
virtual void SelectOldObjects(WXHDC dc);
void SetWindow(wxWindow *win)
{
m_window = win;
#if wxUSE_PALETTE
// if we have palettes use the correct one for this window
InitializePalette();
#endif // wxUSE_PALETTE
}
WXHDC GetHDC() const { return m_hDC; }
void SetHDC(WXHDC dc, bool bOwnsDC = false)
{
m_hDC = dc;
m_bOwnsDC = bOwnsDC;
// we might have a pre existing clipping region, make sure that we
// return it if asked -- but avoid calling ::GetClipBox() right now as
// it could be unnecessary wasteful
m_clipping = true;
m_isClipBoxValid = false;
}
void* GetHandle() const wxOVERRIDE { return (void*)GetHDC(); }
const wxBitmap& GetSelectedBitmap() const wxOVERRIDE { return m_selectedBitmap; }
wxBitmap& GetSelectedBitmap() wxOVERRIDE { return m_selectedBitmap; }
// update the internal clip box variables
void UpdateClipBox();
#if wxUSE_DC_CACHEING
static wxDCCacheEntry* FindBitmapInCache(WXHDC hDC, int w, int h);
static wxDCCacheEntry* FindDCInCache(wxDCCacheEntry* notThis, WXHDC hDC);
static void AddToBitmapCache(wxDCCacheEntry* entry);
static void AddToDCCache(wxDCCacheEntry* entry);
static void ClearCache();
#endif
// RTL related functions
// ---------------------
// get or change the layout direction (LTR or RTL) for this dc,
// wxLayout_Default is returned if layout direction is not supported
virtual wxLayoutDirection GetLayoutDirection() const wxOVERRIDE;
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
protected:
void Init()
{
m_bOwnsDC = false;
m_hDC = NULL;
m_oldBitmap = NULL;
m_oldPen = NULL;
m_oldBrush = NULL;
m_oldFont = NULL;
#if wxUSE_PALETTE
m_oldPalette = NULL;
#endif // wxUSE_PALETTE
m_isClipBoxValid = false;
}
// create an uninitialized DC: this should be only used by the derived
// classes
wxMSWDCImpl( wxDC *owner ) : wxDCImpl( owner ) { Init(); }
void RealizeScaleAndOrigin();
public:
virtual void DoGetFontMetrics(int *height,
int *ascent,
int *descent,
int *internalLeading,
int *externalLeading,
int *averageWidth) const wxOVERRIDE;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *x, wxCoord *y,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
const wxFont *theFont = NULL) const wxOVERRIDE;
virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const wxOVERRIDE;
virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
wxFloodFillStyle style = wxFLOOD_SURFACE) wxOVERRIDE;
virtual void DoGradientFillLinear(const wxRect& rect,
const wxColour& initialColour,
const wxColour& destColour,
wxDirection nDirection = wxEAST) wxOVERRIDE;
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const wxOVERRIDE;
virtual void DoDrawPoint(wxCoord x, wxCoord y) wxOVERRIDE;
virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) wxOVERRIDE;
virtual void DoDrawArc(wxCoord x1, wxCoord y1,
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc) wxOVERRIDE;
virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
wxCoord width, wxCoord height) wxOVERRIDE;
virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
double sa, double ea) 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) wxOVERRIDE;
virtual void DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height) wxOVERRIDE;
#if wxUSE_SPLINES
virtual void DoDrawSpline(const wxPointList *points) wxOVERRIDE;
#endif
virtual void DoCrossHair(wxCoord x, wxCoord y) wxOVERRIDE;
virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) wxOVERRIDE;
virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask = false) 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 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 bool DoStretchBlit(wxCoord xdest, wxCoord ydest,
wxCoord dstWidth, wxCoord dstHeight,
wxDC *source,
wxCoord xsrc, wxCoord ysrc,
wxCoord srcWidth, wxCoord srcHeight,
wxRasterOperationMode rop = wxCOPY, bool useMask = false,
wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) wxOVERRIDE;
virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
wxCoord width, wxCoord height) wxOVERRIDE;
virtual void DoSetDeviceClippingRegion(const wxRegion& region) wxOVERRIDE;
virtual bool DoGetClippingRect(wxRect& rect) const wxOVERRIDE;
virtual void DoGetSizeMM(int* width, int* height) const 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 DoDrawPolyPolygon(int n, const int count[], const wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
wxPolygonFillMode fillStyle = wxODDEVEN_RULE) wxOVERRIDE;
virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const wxOVERRIDE
{
return subrect == NULL ? GetSelectedBitmap()
: GetSelectedBitmap().GetSubBitmap(*subrect);
}
#if wxUSE_PALETTE
// MSW specific, select a logical palette into the HDC
// (tell windows to translate pixel from other palettes to our custom one
// and vice versa)
// Realize tells it to also reset the system palette to this one.
void DoSelectPalette(bool realize = false);
// Find out what palette our parent window has, then select it into the dc
void InitializePalette();
#endif // wxUSE_PALETTE
protected:
// common part of DoDrawText() and DoDrawRotatedText()
void DrawAnyText(const wxString& text, wxCoord x, wxCoord y);
// common part of DoSetClippingRegion() and DoSetDeviceClippingRegion()
void SetClippingHrgn(WXHRGN hrgn);
// implementation of DoGetSize() for wxScreen/PrinterDC: this simply
// returns the size of the entire device this DC is associated with
//
// notice that we intentionally put it in a separate function instead of
// DoGetSize() itself because we want it to remain pure virtual both
// because each derived class should take care to define it as needed (this
// implementation is not at all always appropriate) and because we want
// wxDC to be an ABC to prevent it from being created directly
void GetDeviceSize(int *width, int *height) const;
// MSW-specific member variables
// -----------------------------
// the window associated with this DC (may be NULL)
wxWindow *m_canvas;
wxBitmap m_selectedBitmap;
// TRUE => DeleteDC() in dtor, FALSE => only ReleaseDC() it
bool m_bOwnsDC:1;
// our HDC
WXHDC m_hDC;
// Store all old GDI objects when do a SelectObject, so we can select them
// back in (this unselecting user's objects) so we can safely delete the
// DC.
WXHBITMAP m_oldBitmap;
WXHPEN m_oldPen;
WXHBRUSH m_oldBrush;
WXHFONT m_oldFont;
#if wxUSE_PALETTE
WXHPALETTE m_oldPalette;
#endif // wxUSE_PALETTE
#if wxUSE_DC_CACHEING
static wxObjectList sm_bitmapCache;
static wxObjectList sm_dcCache;
#endif
bool m_isClipBoxValid;
wxDECLARE_CLASS(wxMSWDCImpl);
wxDECLARE_NO_COPY_CLASS(wxMSWDCImpl);
};
// ----------------------------------------------------------------------------
// wxDCTemp: a wxDC which doesn't free the given HDC (used by wxWidgets
// only/mainly)
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDCTempImpl : public wxMSWDCImpl
{
public:
// construct a temporary DC with the specified HDC and size (it should be
// specified whenever we know it for this HDC)
wxDCTempImpl(wxDC *owner, WXHDC hdc, const wxSize& size )
: wxMSWDCImpl( owner, hdc ),
m_size(size)
{
}
virtual ~wxDCTempImpl()
{
// prevent base class dtor from freeing it
SetHDC((WXHDC)NULL);
}
virtual void DoGetSize(int *w, int *h) const wxOVERRIDE
{
wxASSERT_MSG( m_size.IsFullySpecified(),
wxT("size of this DC hadn't been set and is unknown") );
if ( w )
*w = m_size.x;
if ( h )
*h = m_size.y;
}
private:
// size of this DC must be explicitly set by SetSize() as we have no way to
// find it ourselves
const wxSize m_size;
wxDECLARE_NO_COPY_CLASS(wxDCTempImpl);
};
class WXDLLIMPEXP_CORE wxDCTemp : public wxDC
{
public:
wxDCTemp(WXHDC hdc, const wxSize& size = wxDefaultSize)
: wxDC(new wxDCTempImpl(this, hdc, size))
{
}
};
#endif // _WX_MSW_DC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/msgdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/msgdlg.h
// Purpose: wxMessageDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSGBOXDLG_H_
#define _WX_MSGBOXDLG_H_
class WXDLLIMPEXP_CORE wxMessageDialog : public wxMessageDialogBase
{
public:
wxMessageDialog(wxWindow *parent,
const wxString& message,
const wxString& caption = wxMessageBoxCaptionStr,
long style = wxOK|wxCENTRE,
const wxPoint& WXUNUSED(pos) = wxDefaultPosition)
: wxMessageDialogBase(parent, message, caption, style)
{
m_hook = NULL;
}
virtual int ShowModal() wxOVERRIDE;
virtual long GetEffectiveIcon() const wxOVERRIDE;
// implementation-specific
// return the font used for the text in the message box
static wxFont GetMessageFont();
protected:
// Override this as task dialogs are always centered on parent.
virtual void DoCentre(int dir) wxOVERRIDE;
private:
// hook procedure used to adjust the message box beyond what the standard
// MessageBox() function can do for us
static WXLRESULT wxCALLBACK HookFunction(int code, WXWPARAM, WXLPARAM);
static const struct ButtonAccessors
{
int id;
wxString (wxMessageDialog::*getter)() const;
} ms_buttons[];
// replace the static text control with a text control in order to show
// scrollbar (and also, incidentally, allow text selection)
void ReplaceStaticWithEdit();
// adjust the button labels
//
// this is called from HookFunction() and our HWND is valid at this moment
void AdjustButtonLabels();
// offset all buttons starting from the first one given by dx to the right
void OffsetButtonsStartingFrom(int first, int dx);
// used by ShowModal() to display a message box when task dialogs
// aren't available.
int ShowMessageBox();
WXHANDLE m_hook; // HHOOK used to position the message box
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMessageDialog);
};
#endif // _WX_MSGBOXDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/tls.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/tls.h
// Purpose: Win32 implementation of wxTlsValue<>
// Author: Vadim Zeitlin
// Created: 2008-08-08
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TLS_H_
#define _WX_MSW_TLS_H_
#include "wx/msw/wrapwin.h"
#include "wx/thread.h"
#include "wx/vector.h"
// ----------------------------------------------------------------------------
// wxTlsKey is a helper class encapsulating a TLS slot
// ----------------------------------------------------------------------------
class wxTlsKey
{
public:
// ctor allocates a new key
wxTlsKey(wxTlsDestructorFunction destructor)
{
m_destructor = destructor;
m_slot = ::TlsAlloc();
}
// return true if the key was successfully allocated
bool IsOk() const { return m_slot != TLS_OUT_OF_INDEXES; }
// get the key value, there is no error return
void *Get() const
{
// Exceptionally, TlsGetValue() calls SetLastError() even on success
// which means it overwrites the previous value. This is undesirable
// here, so explicitly preserve the last error here.
const DWORD dwLastError = ::GetLastError();
void* const value = ::TlsGetValue(m_slot);
if ( dwLastError )
::SetLastError(dwLastError);
return value;
}
// change the key value, return true if ok
bool Set(void *value)
{
void *old = Get();
if ( ::TlsSetValue(m_slot, value) == 0 )
return false;
if ( old )
m_destructor(old);
// update m_allValues list of all values - remove old, add new
wxCriticalSectionLocker lock(m_csAllValues);
if ( old )
{
for ( wxVector<void*>::iterator i = m_allValues.begin();
i != m_allValues.end();
++i )
{
if ( *i == old )
{
if ( value )
*i = value;
else
m_allValues.erase(i);
return true;
}
}
wxFAIL_MSG( "previous wxTlsKey value not recorded in m_allValues" );
}
if ( value )
m_allValues.push_back(value);
return true;
}
// free the key
~wxTlsKey()
{
if ( !IsOk() )
return;
// Win32 API doesn't have the equivalent of pthread's destructor, so we
// have to keep track of all allocated values and destroy them manually;
// ideally we'd do that at thread exit time, but since we could only
// do that with wxThread and not otherwise created threads, we do it
// here.
//
// TODO: We should still call destructors for wxTlsKey used in the
// thread from wxThread's thread shutdown code, *in addition*
// to doing it in ~wxTlsKey.
//
// NB: No need to lock m_csAllValues, by the time this code is called,
// no other thread can be using this key.
for ( wxVector<void*>::iterator i = m_allValues.begin();
i != m_allValues.end();
++i )
{
m_destructor(*i);
}
::TlsFree(m_slot);
}
private:
wxTlsDestructorFunction m_destructor;
DWORD m_slot;
wxVector<void*> m_allValues;
wxCriticalSection m_csAllValues;
wxDECLARE_NO_COPY_CLASS(wxTlsKey);
};
#endif // _WX_MSW_TLS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/notebook.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/notebook.h
// Purpose: MSW/GTK compatible notebook (a.k.a. property sheet)
// Author: Robert Roebling
// Modified by: Vadim Zeitlin for Windows version
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _NOTEBOOK_H
#define _NOTEBOOK_H
#if wxUSE_NOTEBOOK
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/control.h"
// ----------------------------------------------------------------------------
// wxNotebook
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNotebook : public wxNotebookBase
{
public:
// ctors
// -----
// default for dynamic class
wxNotebook();
// the same arguments as for wxControl (@@@ any special styles?)
wxNotebook(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
// Create() function
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
virtual ~wxNotebook();
// accessors
// ---------
// get number of pages in the dialog
virtual size_t GetPageCount() const wxOVERRIDE;
// set the currently selected page, return the index of the previously
// selected one (or wxNOT_FOUND on error)
// NB: this function will _not_ generate wxEVT_NOTEBOOK_PAGE_xxx events
int SetSelection(size_t nPage) wxOVERRIDE;
// changes selected page without sending events
int ChangeSelection(size_t nPage) wxOVERRIDE;
// set/get the title of a page
bool SetPageText(size_t nPage, const wxString& strText) wxOVERRIDE;
wxString GetPageText(size_t nPage) const wxOVERRIDE;
// image list stuff: each page may have an image associated with it. All
// the images belong to an image list, so you have to
// 1) create an image list
// 2) associate it with the notebook
// 3) set for each page it's image
// associate image list with a control
void SetImageList(wxImageList* imageList) wxOVERRIDE;
// sets/returns item's image index in the current image list
int GetPageImage(size_t nPage) const wxOVERRIDE;
bool SetPageImage(size_t nPage, int nImage) wxOVERRIDE;
// currently it's always 1 because wxGTK doesn't support multi-row
// tab controls
int GetRowCount() const wxOVERRIDE;
// control the appearance of the notebook pages
// set the size (the same for all pages)
void SetPageSize(const wxSize& size) wxOVERRIDE;
// set the padding between tabs (in pixels)
void SetPadding(const wxSize& padding) wxOVERRIDE;
// operations
// ----------
// remove all pages
bool DeleteAllPages() wxOVERRIDE;
// inserts a new page to the notebook (it will be deleted ny the notebook,
// don't delete it yourself). If bSelect, this page becomes active.
bool InsertPage(size_t nPage,
wxNotebookPage *pPage,
const wxString& strText,
bool bSelect = false,
int imageId = NO_IMAGE) wxOVERRIDE;
// Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
// style.
void SetTabSize(const wxSize& sz) wxOVERRIDE;
// hit test
virtual int HitTest(const wxPoint& pt, long *flags = NULL) const wxOVERRIDE;
// calculate the size of the notebook from the size of its page
virtual wxSize CalcSizeFromPage(const wxSize& sizePage) const wxOVERRIDE;
// callbacks
// ---------
void OnSize(wxSizeEvent& event);
void OnNavigationKey(wxNavigationKeyEvent& event);
// base class virtuals
// -------------------
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD nSBCode,
WXWORD pos, WXHWND control) wxOVERRIDE;
#if wxUSE_CONSTRAINTS
virtual void SetConstraintSizes(bool recurse = true) wxOVERRIDE;
virtual bool DoPhase(int nPhase) wxOVERRIDE;
#endif // wxUSE_CONSTRAINTS
// Attempts to get colour for UX theme page background
wxColour GetThemeBackgroundColour() const wxOVERRIDE;
// implementation only
// -------------------
#if wxUSE_UXTHEME
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE
{
if ( !wxNotebookBase::SetBackgroundColour(colour) )
return false;
UpdateBgBrush();
return true;
}
// draw child background
virtual bool MSWPrintChild(WXHDC hDC, wxWindow *win) wxOVERRIDE;
virtual bool MSWHasInheritableBackground() const wxOVERRIDE { return true; }
#endif // wxUSE_UXTHEME
// translate wxWin styles to the Windows ones
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// hides the currently shown page and shows the given one (if not -1) and
// updates m_selection accordingly
void UpdateSelection(int selNew);
// remove one page from the notebook, without deleting
virtual wxNotebookPage *DoRemovePage(size_t nPage) wxOVERRIDE;
// get the page rectangle for the current notebook size
//
// returns empty rectangle if an error occurs, do test for it
wxRect GetPageSize() const;
// set the size of the given page to fit in the notebook
void AdjustPageSize(wxNotebookPage *page);
#if wxUSE_UXTHEME
virtual void MSWAdjustBrushOrg(int *xOrg, int* yOrg) const wxOVERRIDE
{
*xOrg -= m_bgBrushAdj.x;
*yOrg -= m_bgBrushAdj.y;
}
// return the themed brush for painting our children
virtual WXHBRUSH MSWGetCustomBgBrush() wxOVERRIDE { return m_hbrBackground; }
// gets the bitmap of notebook background and returns a brush from it and
// sets m_bgBrushAdj
WXHBRUSH QueryBgBitmap();
// creates the brush to be used for drawing the tab control background
void UpdateBgBrush();
#endif // wxUSE_UXTHEME
// these function are used for reducing flicker on notebook resize
void OnEraseBackground(wxEraseEvent& event);
void OnPaint(wxPaintEvent& event);
// true if we have already subclassed our updown control
bool m_hasSubclassedUpdown;
#if wxUSE_UXTHEME
// background brush used to paint the tab control
WXHBRUSH m_hbrBackground;
// offset for MSWAdjustBrushOrg()
wxPoint m_bgBrushAdj;
#endif // wxUSE_UXTHEME
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxNotebook);
wxDECLARE_EVENT_TABLE();
};
#endif // wxUSE_NOTEBOOK
#endif // _NOTEBOOK_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/webview_ie.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/webview_ie.h
// Purpose: wxMSW IE wxWebView backend
// Author: Marianne Gagnon
// Copyright: (c) 2010 Marianne Gagnon, 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef wxWebViewIE_H
#define wxWebViewIE_H
#include "wx/setup.h"
#if wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE && defined(__WXMSW__)
#include "wx/control.h"
#include "wx/webview.h"
#include "wx/msw/ole/automtn.h"
#include "wx/msw/ole/activex.h"
#include "wx/msw/ole/oleutils.h"
#include "wx/msw/private/comptr.h"
#include "wx/msw/wrapwin.h"
#include "wx/msw/missing.h"
#include "wx/msw/webview_missing.h"
#include "wx/sharedptr.h"
#include "wx/vector.h"
#include "wx/msw/private.h"
struct IHTMLDocument2;
struct IHTMLElement;
struct IMarkupPointer;
class wxFSFile;
class ClassFactory;
class wxIEContainer;
class DocHostUIHandler;
class wxFindPointers;
class wxIInternetProtocol;
class WXDLLIMPEXP_WEBVIEW wxWebViewIE : public wxWebView
{
public:
wxWebViewIE() {}
wxWebViewIE(wxWindow* parent,
wxWindowID id,
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);
}
~wxWebViewIE();
bool 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;
virtual void LoadURL(const wxString& url) wxOVERRIDE;
virtual void LoadHistoryItem(wxSharedPtr<wxWebViewHistoryItem> item) wxOVERRIDE;
virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetBackwardHistory() wxOVERRIDE;
virtual wxVector<wxSharedPtr<wxWebViewHistoryItem> > GetForwardHistory() wxOVERRIDE;
virtual bool CanGoForward() const wxOVERRIDE;
virtual bool CanGoBack() const wxOVERRIDE;
virtual void GoBack() wxOVERRIDE;
virtual void GoForward() wxOVERRIDE;
virtual void ClearHistory() wxOVERRIDE;
virtual void EnableHistory(bool enable = true) wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
virtual void Reload(wxWebViewReloadFlags flags = wxWEBVIEW_RELOAD_DEFAULT) wxOVERRIDE;
virtual wxString GetPageSource() const wxOVERRIDE;
virtual wxString GetPageText() const wxOVERRIDE;
virtual bool IsBusy() const wxOVERRIDE;
virtual wxString GetCurrentURL() const wxOVERRIDE;
virtual wxString GetCurrentTitle() const wxOVERRIDE;
virtual void SetZoomType(wxWebViewZoomType) wxOVERRIDE;
virtual wxWebViewZoomType GetZoomType() const wxOVERRIDE;
virtual bool CanSetZoomType(wxWebViewZoomType) const wxOVERRIDE;
virtual void Print() wxOVERRIDE;
virtual wxWebViewZoom GetZoom() const wxOVERRIDE;
virtual void SetZoom(wxWebViewZoom zoom) 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 SelectAll() wxOVERRIDE;
virtual bool HasSelection() const wxOVERRIDE;
virtual void DeleteSelection() 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 void* GetNativeBackend() const wxOVERRIDE { return m_webBrowser; }
// ---- IE-specific methods
// FIXME: I seem to be able to access remote webpages even in offline mode...
bool IsOfflineMode();
void SetOfflineMode(bool offline);
wxWebViewZoom GetIETextZoom() const;
void SetIETextZoom(wxWebViewZoom level);
wxWebViewZoom GetIEOpticalZoom() const;
void SetIEOpticalZoom(wxWebViewZoom level);
void onActiveXEvent(wxActiveXEvent& evt);
void onEraseBg(wxEraseEvent&) {}
// Establish sufficiently modern emulation level for the browser control to
// allow RunScript() to return any kind of values.
static bool MSWSetModernEmulationLevel(bool modernLevel = true);
wxDECLARE_EVENT_TABLE();
protected:
virtual void DoSetPage(const wxString& html, const wxString& baseUrl) wxOVERRIDE;
private:
wxIEContainer* m_container;
wxAutomationObject m_ie;
IWebBrowser2* m_webBrowser;
wxCOMPtr<DocHostUIHandler> m_uiHandler;
//We store the current zoom type;
wxWebViewZoomType m_zoomType;
/** The "Busy" property of IWebBrowser2 does not always return busy when
* we'd want it to; this variable may be set to true in cases where the
* Busy property is false but should be true.
*/
bool m_isBusy;
//We manage our own history, the history list contains the history items
//which are added as documentcomplete events arrive, unless we are loading
//an item from the history. The position is stored as an int, and reflects
//where we are in the history list.
wxVector<wxSharedPtr<wxWebViewHistoryItem> > m_historyList;
wxVector<ClassFactory*> m_factories;
int m_historyPosition;
bool m_historyLoadingFromList;
bool m_historyEnabled;
//We store find flag, results and position.
wxVector<wxFindPointers> m_findPointers;
int m_findFlags;
wxString m_findText;
int m_findPosition;
//Generic helper functions
bool CanExecCommand(wxString command) const;
void ExecCommand(wxString command);
wxCOMPtr<IHTMLDocument2> GetDocument() const;
bool IsElementVisible(wxCOMPtr<IHTMLElement> elm);
//Find helper functions.
void FindInternal(const wxString& text, int flags, int internal_flag);
long FindNext(int direction = 1);
void FindClear();
//Toggles control features see INTERNETFEATURELIST for values.
bool EnableControlFeature(long flag, bool enable = true);
wxDECLARE_DYNAMIC_CLASS(wxWebViewIE);
};
class WXDLLIMPEXP_WEBVIEW wxWebViewFactoryIE : public wxWebViewFactory
{
public:
virtual wxWebView* Create() wxOVERRIDE { return new wxWebViewIE; }
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 wxWebViewIE(parent, id, url, pos, size, style, name); }
};
class VirtualProtocol : public wxIInternetProtocol
{
protected:
wxIInternetProtocolSink* m_protocolSink;
wxString m_html;
VOID * fileP;
wxFSFile* m_file;
wxSharedPtr<wxWebViewHandler> m_handler;
public:
VirtualProtocol(wxSharedPtr<wxWebViewHandler> handler);
virtual ~VirtualProtocol() {}
//IUnknown
DECLARE_IUNKNOWN_METHODS;
//IInternetProtocolRoot
HRESULT STDMETHODCALLTYPE Abort(HRESULT WXUNUSED(hrReason),
DWORD WXUNUSED(dwOptions)) wxOVERRIDE
{ return E_NOTIMPL; }
HRESULT STDMETHODCALLTYPE Continue(wxPROTOCOLDATA *WXUNUSED(pProtocolData)) wxOVERRIDE
{ return S_OK; }
HRESULT STDMETHODCALLTYPE Resume() wxOVERRIDE { return S_OK; }
HRESULT STDMETHODCALLTYPE Start(LPCWSTR szUrl,
wxIInternetProtocolSink *pOIProtSink,
wxIInternetBindInfo *pOIBindInfo,
DWORD grfPI,
HANDLE_PTR dwReserved) wxOVERRIDE;
HRESULT STDMETHODCALLTYPE Suspend() wxOVERRIDE { return S_OK; }
HRESULT STDMETHODCALLTYPE Terminate(DWORD WXUNUSED(dwOptions)) wxOVERRIDE { return S_OK; }
//IInternetProtocol
HRESULT STDMETHODCALLTYPE LockRequest(DWORD WXUNUSED(dwOptions)) wxOVERRIDE
{ return S_OK; }
HRESULT STDMETHODCALLTYPE Read(void *pv, ULONG cb, ULONG *pcbRead) wxOVERRIDE;
HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER WXUNUSED(dlibMove),
DWORD WXUNUSED(dwOrigin),
ULARGE_INTEGER* WXUNUSED(plibNewPosition)) wxOVERRIDE
{ return E_FAIL; }
HRESULT STDMETHODCALLTYPE UnlockRequest() wxOVERRIDE { return S_OK; }
};
class ClassFactory : public IClassFactory
{
public:
ClassFactory(wxSharedPtr<wxWebViewHandler> handler) : m_handler(handler)
{ AddRef(); }
virtual ~ClassFactory() {}
wxString GetName() { return m_handler->GetName(); }
//IClassFactory
HRESULT STDMETHODCALLTYPE CreateInstance(IUnknown* pUnkOuter,
REFIID riid, void** ppvObject) wxOVERRIDE;
HRESULT STDMETHODCALLTYPE LockServer(BOOL fLock) wxOVERRIDE;
//IUnknown
DECLARE_IUNKNOWN_METHODS;
private:
wxSharedPtr<wxWebViewHandler> m_handler;
};
class wxIEContainer : public wxActiveXContainer
{
public:
wxIEContainer(wxWindow *parent, REFIID iid, IUnknown *pUnk, DocHostUIHandler* uiHandler = NULL);
virtual ~wxIEContainer();
virtual bool QueryClientSiteInterface(REFIID iid, void **_interface, const char *&desc) wxOVERRIDE;
private:
DocHostUIHandler* m_uiHandler;
};
class DocHostUIHandler : public wxIDocHostUIHandler
{
public:
DocHostUIHandler(wxWebView* browser) { m_browser = browser; }
virtual ~DocHostUIHandler() {}
virtual HRESULT wxSTDCALL ShowContextMenu(DWORD dwID, POINT *ppt,
IUnknown *pcmdtReserved,
IDispatch *pdispReserved) wxOVERRIDE;
virtual HRESULT wxSTDCALL GetHostInfo(DOCHOSTUIINFO *pInfo) wxOVERRIDE;
virtual HRESULT wxSTDCALL ShowUI(DWORD dwID,
IOleInPlaceActiveObject *pActiveObject,
IOleCommandTarget *pCommandTarget,
IOleInPlaceFrame *pFrame,
IOleInPlaceUIWindow *pDoc) wxOVERRIDE;
virtual HRESULT wxSTDCALL HideUI(void) wxOVERRIDE;
virtual HRESULT wxSTDCALL UpdateUI(void) wxOVERRIDE;
virtual HRESULT wxSTDCALL EnableModeless(BOOL fEnable) wxOVERRIDE;
virtual HRESULT wxSTDCALL OnDocWindowActivate(BOOL fActivate) wxOVERRIDE;
virtual HRESULT wxSTDCALL OnFrameWindowActivate(BOOL fActivate) wxOVERRIDE;
virtual HRESULT wxSTDCALL ResizeBorder(LPCRECT prcBorder,
IOleInPlaceUIWindow *pUIWindow,
BOOL fRameWindow) wxOVERRIDE;
virtual HRESULT wxSTDCALL TranslateAccelerator(LPMSG lpMsg,
const GUID *pguidCmdGroup,
DWORD nCmdID) wxOVERRIDE;
virtual HRESULT wxSTDCALL GetOptionKeyPath(LPOLESTR *pchKey,
DWORD dw) wxOVERRIDE;
virtual HRESULT wxSTDCALL GetDropTarget(IDropTarget *pDropTarget,
IDropTarget **ppDropTarget) wxOVERRIDE;
virtual HRESULT wxSTDCALL GetExternal(IDispatch **ppDispatch) wxOVERRIDE;
virtual HRESULT wxSTDCALL TranslateUrl(DWORD dwTranslate,
OLECHAR *pchURLIn,
OLECHAR **ppchURLOut) wxOVERRIDE;
virtual HRESULT wxSTDCALL FilterDataObject(IDataObject *pDO,
IDataObject **ppDORet) wxOVERRIDE;
//IUnknown
DECLARE_IUNKNOWN_METHODS;
private:
wxWebView* m_browser;
};
class wxFindPointers
{
public:
wxFindPointers(wxIMarkupPointer *ptrBegin, wxIMarkupPointer *ptrEnd)
{
begin = ptrBegin;
end = ptrEnd;
}
//The two markup pointers.
wxIMarkupPointer *begin, *end;
};
#endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE && defined(__WXMSW__)
#endif // wxWebViewIE_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/statline.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/statline.h
// Purpose: MSW version of wxStaticLine class
// Author: Vadim Zeitlin
// Created: 28.06.99
// Copyright: (c) 1998 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STATLINE_H_
#define _WX_MSW_STATLINE_H_
// ----------------------------------------------------------------------------
// wxStaticLine
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStaticLine : public wxStaticLineBase
{
public:
// constructors and pseudo-constructors
wxStaticLine() { }
wxStaticLine( wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLI_HORIZONTAL,
const wxString &name = wxStaticLineNameStr )
{
Create(parent, id, pos, size, style, name);
}
bool Create( wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLI_HORIZONTAL,
const wxString &name = wxStaticLineNameStr );
// overridden base class virtuals
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
// usually overridden base class virtuals
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticLine);
};
#endif // _WX_MSW_STATLINE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/seh.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/seh.h
// Purpose: declarations for SEH (structured exceptions handling) support
// Author: Vadim Zeitlin
// Created: 2006-04-26
// Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_SEH_H_
#define _WX_MSW_SEH_H_
#if wxUSE_ON_FATAL_EXCEPTION
// the exception handler which should be called from the exception filter
//
// it calls wxApp::OnFatalException() if wxTheApp object exists
WXDLLIMPEXP_BASE unsigned long wxGlobalSEHandler(EXCEPTION_POINTERS *pExcPtrs);
// helper macro for wxSEH_HANDLE
#if defined(__BORLANDC__)
// some compilers don't understand that this code is unreachable and warn
// about no value being returned from the function without it, so calm them
// down
#define wxSEH_DUMMY_RETURN(rc) return rc;
#else
#define wxSEH_DUMMY_RETURN(rc)
#endif
// macros which allow to avoid many #if wxUSE_ON_FATAL_EXCEPTION in the code
// which uses them
#define wxSEH_TRY __try
#define wxSEH_IGNORE __except ( EXCEPTION_EXECUTE_HANDLER ) { }
#define wxSEH_HANDLE(rc) \
__except ( wxGlobalSEHandler(GetExceptionInformation()) ) \
{ \
/* use the same exit code as abort() */ \
::ExitProcess(3); \
\
wxSEH_DUMMY_RETURN(rc) \
}
#else // wxUSE_ON_FATAL_EXCEPTION
#define wxSEH_TRY
#define wxSEH_IGNORE
#define wxSEH_HANDLE(rc)
#endif // wxUSE_ON_FATAL_EXCEPTION
#if wxUSE_ON_FATAL_EXCEPTION && defined(__VISUALC__)
#include <eh.h>
// C++ exception to structured exceptions translator: we need it in order
// to prevent VC++ from "helpfully" translating structured exceptions (such
// as division by 0 or access violation) to C++ pseudo-exceptions
extern void wxSETranslator(unsigned int code, EXCEPTION_POINTERS *ep);
// up to VC 12 this warning ("calling _set_se_translator() requires /EHa")
// is harmless and it's easier to suppress it than deal with it as make/
// project file level as it seems to be harmless
#if __VISUALC__ < 2000
#pragma warning(disable: 4535)
#endif
// note that the SE translator must be called wxSETranslator!
#define DisableAutomaticSETranslator() _set_se_translator(wxSETranslator)
#else // !__VISUALC__
// the other compilers do nothing as stupid by default so nothing to do for
// them
#define DisableAutomaticSETranslator()
#endif // __VISUALC__/!__VISUALC__
#endif // _WX_MSW_SEH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/wrapcctl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapcctl.h
// Purpose: Wrapper for the standard <commctrl.h> header
// Author: Vadim Zeitlin
// Modified by:
// Created: 03.08.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WRAPCCTL_H_
#define _WX_MSW_WRAPCCTL_H_
#include "wx/msw/wrapwin.h"
#include <commctrl.h>
// define things which might be missing from our commctrl.h
#include "wx/msw/missing.h"
// Set Unicode format for a common control
inline void wxSetCCUnicodeFormat(HWND hwnd)
{
::SendMessage(hwnd, CCM_SETUNICODEFORMAT, wxUSE_UNICODE, 0);
}
#if wxUSE_GUI
// Return the default font for the common controls
//
// this is implemented in msw/settings.cpp
class wxFont;
extern wxFont wxGetCCDefaultFont();
// this is just a wrapper for HDITEM which we can't use in the public header
// because we don't want to include commctrl.h (and hence windows.h) from there
struct wxHDITEM : public HDITEM
{
wxHDITEM()
{
::ZeroMemory(this, sizeof(*this));
}
};
#endif // wxUSE_GUI
#endif // _WX_MSW_WRAPCCTL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/msw/msvcrt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/msvcrt.h
// Purpose: macros to use some non-standard features of MS Visual C++
// C run-time library
// Author: Vadim Zeitlin
// Modified by:
// Created: 31.01.1999
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// the goal of this file is to define wxCrtSetDbgFlag() macro which may be
// used like this:
// wxCrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
// to turn on memory leak checks for programs compiled with Microsoft Visual
// C++ (5.0+). The macro will not be defined under other compilers or if it
// can't be used with MSVC for whatever reason.
#ifndef _MSW_MSVCRT_H_
#define _MSW_MSVCRT_H_
// use debug CRT functions for memory leak detections in VC++ 5.0+ in debug
// builds
#undef wxUSE_VC_CRTDBG
#if defined(_DEBUG) && defined(__VISUALC__) \
&& !defined(UNDER_CE)
// it doesn't combine well with wxWin own memory debugging methods
#if !wxUSE_GLOBAL_MEMORY_OPERATORS && !wxUSE_MEMORY_TRACING && !defined(__NO_VC_CRTDBG__)
#define wxUSE_VC_CRTDBG
#endif
#endif
#ifdef wxUSE_VC_CRTDBG
// Need to undef new if including crtdbg.h which may redefine new itself
#ifdef new
#undef new
#endif
#include <stdlib.h>
// Defining _CRTBLD should never be necessary at all, but keep it for now
// as there is no time to retest all the compilers before 3.0 release.
// Definitely do not use it with MSVS 2013 as defining it results in errors
// if the standard <assert.h> is included afterwards.
#if !defined(_CRTBLD) && !wxCHECK_VISUALC_VERSION(12)
// Needed when building with pure MS SDK
#define _CRTBLD
#endif
#include <crtdbg.h>
#undef WXDEBUG_NEW
#define WXDEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
// this define works around a bug with inline declarations of new, see
//
// http://support.microsoft.com/kb/q140858/
//
// for the details
#define new WXDEBUG_NEW
#define wxCrtSetDbgFlag(flag) \
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | (flag))
#else // !using VC CRT
#define wxCrtSetDbgFlag(flag)
#endif // wxUSE_VC_CRTDBG
#endif // _MSW_MSVCRT_H_
| h |
Subsets and Splits