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/osx/datectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/datectrl.h
// Purpose: Declaration of wxOSX-specific wxDatePickerCtrl class.
// Author: Vadim Zeitlin
// Created: 2011-12-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_DATECTRL_H_
#define _WX_OSX_DATECTRL_H_
// ----------------------------------------------------------------------------
// wxDatePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDatePickerCtrl : public wxDatePickerCtrlBase
{
public:
// Constructors.
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);
// Implement the base class pure virtuals.
virtual void SetRange(const wxDateTime& dt1, const wxDateTime& dt2);
virtual bool GetRange(wxDateTime *dt1, wxDateTime *dt2) const;
virtual void OSXGenerateEvent(const wxDateTime& dt);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDatePickerCtrl);
};
#endif // _WX_OSX_DATECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/evtloop.h
// Purpose: simply forwards to wx/osx/carbon/evtloop.h or
// wx/osx/cocoa/evtloop.h for consistency with the other Mac
// headers
// Author: Vadim Zeitlin
// Modified by:
// Created: 2006-01-12
// Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_EVTLOOP_H_
#define _WX_OSX_EVTLOOP_H_
#include "wx/osx/cocoa/evtloop.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxNonOwnedWindow;
class WXDLLIMPEXP_CORE wxModalEventLoop : public wxGUIEventLoop
{
public:
wxModalEventLoop(wxWindow *modalWindow);
wxModalEventLoop(WXWindow modalNativeWindow);
#ifdef __WXOSX_COCOA__
// skip wxGUIEventLoop to avoid missing Enter/Exit notifications
virtual int Run() { return wxCFEventLoop::Run(); }
#endif
protected:
virtual void OSXDoRun();
virtual void OSXDoStop();
// (in case) the modal window for this event loop
wxNonOwnedWindow* m_modalWindow;
WXWindow m_modalNativeWindow;
};
#endif // _WX_OSX_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/palette.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/palette.h
// Purpose: wxPalette class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PALETTE_H_
#define _WX_PALETTE_H_
#include "wx/gdiobj.h"
#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
class WXDLLIMPEXP_CORE wxPalette : public wxPaletteBase
{
public:
wxPalette();
wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
virtual ~wxPalette();
bool Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue);
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;
virtual int GetColoursCount() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
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/osx/menu.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/menu.h
// Purpose: wxMenu, wxMenuBar classes
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MENU_H_
#define _WX_MENU_H_
class WXDLLIMPEXP_FWD_CORE wxFrame;
#include "wx/arrstr.h"
class wxMenuRadioItemsData;
// ----------------------------------------------------------------------------
// Menu
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxMenuImpl ;
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();
virtual void SetTitle(const wxString& title);
bool ProcessCommand(wxCommandEvent& event);
// get the menu handle
WXHMENU GetHMenu() const ;
// implementation only from now on
// -------------------------------
bool HandleCommandUpdateStatus( wxMenuItem* menuItem, wxWindow* senderWindow = NULL);
bool HandleCommandProcess( wxMenuItem* menuItem, wxWindow* senderWindow = NULL);
void HandleMenuItemHighlighted( wxMenuItem* menuItem );
void HandleMenuOpened();
void HandleMenuClosed();
wxMenuImpl* GetPeer() { return m_peer; }
// make sure we can veto
void SetAllowRearrange( bool allow );
bool AllowRearrange() const { return m_allowRearrange; }
// if a menu is used purely for internal implementation reasons (eg wxChoice)
// we don't want native menu events being triggered
void SetNoEventsMode( bool noEvents );
bool GetNoEventsMode() const { return m_noEventsMode; }
// Returns the start and end position of the radio group to which the item
// at given position belongs. Return false if there is no radio group
// containing this position.
bool OSXGetRadioGroupRange(int pos, int *start, int *end) const;
protected:
// hide special menu items like exit, preferences etc
// that are expected in the app menu
void DoRearrange() ;
virtual wxMenuItem* DoAppend(wxMenuItem *item);
virtual wxMenuItem* DoInsert(size_t pos, wxMenuItem *item);
virtual wxMenuItem* DoRemove(wxMenuItem *item);
private:
// common part of all ctors
void Init();
// common part of Do{Append,Insert}(): behaves as Append if pos == -1
bool DoInsertOrAppend(wxMenuItem *item, size_t pos = (size_t)-1);
// Common part of HandleMenu{Opened,Closed}().
void DoHandleMenuOpenedOrClosed(wxEventType evtType);
// if TRUE, insert a break before appending the next item
bool m_doBreak;
// in this menu rearranging of menu items (esp hiding) is allowed
bool m_allowRearrange;
// don't trigger native events
bool m_noEventsMode;
wxMenuRadioItemsData* m_radioData;
wxMenuImpl* m_peer;
wxDECLARE_DYNAMIC_CLASS(wxMenu);
};
#if wxOSX_USE_COCOA_OR_CARBON
// the iphone only has popup-menus
// ----------------------------------------------------------------------------
// 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 );
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title);
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title);
virtual wxMenu *Remove(size_t pos);
virtual void EnableTop( size_t pos, bool flag );
virtual bool IsEnabledTop(size_t pos) const;
virtual void SetMenuLabel( size_t pos, const wxString& label );
virtual wxString GetMenuLabel( size_t pos ) const;
virtual bool Enable( bool enable = true );
// for virtual function hiding
virtual void Enable( int itemid, bool enable )
{
wxMenuBarBase::Enable( itemid, enable );
}
// implementation from now on
void Detach();
// returns TRUE if we're attached to a frame
bool IsAttached() const { return m_menuBarFrame != NULL; }
// get the frame we live in
wxFrame *GetFrame() const { return m_menuBarFrame; }
// attach to a frame
void Attach(wxFrame *frame);
// if the menubar is modified, the display is not updated automatically,
// call this function to update it (m_menuBarFrame should be !NULL)
void Refresh(bool eraseBackground = true, const wxRect *rect = NULL);
#if wxABI_VERSION >= 30001
wxMenu *OSXGetAppleMenu() const { return m_appleMenu; }
#endif
static void SetAutoWindowMenu( bool enable ) { s_macAutoWindowMenu = enable ; }
static bool GetAutoWindowMenu() { return s_macAutoWindowMenu ; }
void MacUninstallMenuBar() ;
void MacInstallMenuBar() ;
static wxMenuBar* MacGetInstalledMenuBar() { return s_macInstalledMenuBar ; }
static void MacSetCommonMenuBar(wxMenuBar* menubar) { s_macCommonMenuBar=menubar; }
static wxMenuBar* MacGetCommonMenuBar() { return s_macCommonMenuBar; }
static WXHMENU MacGetWindowMenuHMenu() { return s_macWindowMenuHandle ; }
virtual void DoGetPosition(int *x, int *y) const;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetClientSize(int *width, int *height) const;
protected:
// common part of all ctors
void Init();
static bool s_macAutoWindowMenu ;
static WXHMENU s_macWindowMenuHandle ;
private:
static wxMenuBar* s_macInstalledMenuBar ;
static wxMenuBar* s_macCommonMenuBar ;
wxMenu* m_rootMenu;
wxMenu* m_appleMenu;
wxDECLARE_DYNAMIC_CLASS(wxMenuBar);
};
#endif
#endif // _WX_MENU_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/colour.h | #include "wx/osx/core/colour.h"
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/checkbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/checkbox.h
// Purpose: wxCheckBox class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHECKBOX_H_
#define _WX_CHECKBOX_H_
// Checkbox item (single checkbox)
class WXDLLIMPEXP_CORE wxCheckBox : public wxCheckBoxBase
{
public:
wxCheckBox() { }
wxCheckBox(wxWindow *parent, wxWindowID id, const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
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);
virtual bool GetValue() const;
virtual void Command(wxCommandEvent& event);
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec );
protected:
void DoSet3StateValue(wxCheckBoxState val);
virtual wxCheckBoxState DoGet3StateValue() const;
wxDECLARE_DYNAMIC_CLASS(wxCheckBox);
};
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_CORE wxBitmapCheckBox: public wxCheckBox
{
public:
int checkWidth;
int checkHeight;
wxBitmapCheckBox()
: checkWidth(-1), checkHeight(-1)
{ }
wxBitmapCheckBox(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);
}
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 = wxCheckBoxNameStr);
virtual void SetValue(bool);
virtual bool GetValue() const;
virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
virtual void SetLabel(const wxBitmap *bitmap);
virtual void SetLabel( const wxString & WXUNUSED(name) ) {}
wxDECLARE_DYNAMIC_CLASS(wxBitmapCheckBox);
};
#endif
// _WX_CHECKBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/bmpbuttn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/bmpbuttn.h
// Purpose: wxBitmapButton class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_BMPBUTTN_H_
#define _WX_OSX_BMPBUTTN_H_
#include "wx/button.h"
#define wxDEFAULT_BUTTON_MARGIN 4
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:
virtual wxSize DoGetBestSize() const;
wxDECLARE_DYNAMIC_CLASS(wxBitmapButton);
};
#endif // _WX_OSX_BMPBUTTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/mdi.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/mdi.h
// Purpose: MDI (Multiple Document Interface) classes.
// Author: Stefan Csomor
// Modified by: 2008-10-31 Vadim Zeitlin: derive from the base classes
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// (c) 2008 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_CARBON_MDI_H_
#define _WX_OSX_CARBON_MDI_H_
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);
}
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);
virtual ~wxMDIParentFrame();
// implement/override base class [pure] virtuals
// ---------------------------------------------
static bool IsTDI() { return false; }
virtual void AddChild(wxWindowBase *child) wxOVERRIDE;
virtual void RemoveChild(wxWindowBase *child) wxOVERRIDE;
virtual void ActivateNext() wxOVERRIDE { /* TODO */ }
virtual void ActivatePrevious() wxOVERRIDE { /* TODO */ }
virtual bool Show(bool show = true) wxOVERRIDE;
// Mac-specific implementation from now on
// ---------------------------------------
// Mac OS activate event
virtual void MacActivate(long timestamp, bool activating) wxOVERRIDE;
// wxWidgets activate event
void OnActivate(wxActivateEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
void SetMenuBar(wxMenuBar *menu_bar) wxOVERRIDE;
// Get rect to be used to center top-level children
virtual void GetRectForTopLevelChildren(int *x, int *y, int *w, int *h) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// returns true if this frame has some contents and so should be visible,
// false if it's used solely as container for its children
bool ShouldBeVisible() const;
wxMenu *m_windowMenu;
// true if MDI Frame is intercepting commands, not child
bool m_parentFrameActive;
// true if the frame should be shown but is not because it is empty and
// useless otherwise than a container for its children
bool m_shouldBeShown;
private:
friend class WXDLLIMPEXP_FWD_CORE wxMDIChildFrame;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxMDIParentFrame);
};
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();
// un-override the base class override
virtual bool IsTopLevel() const { return true; }
// implement MDI operations
virtual void Activate();
// Mac OS activate event
virtual void MacActivate(long timestamp, bool activating);
protected:
// common part of all ctors
void Init();
wxDECLARE_DYNAMIC_CLASS(wxMDIChildFrame);
};
class WXDLLIMPEXP_CORE wxMDIClientWindow : public wxMDIClientWindowBase
{
public:
wxMDIClientWindow() { }
virtual ~wxMDIClientWindow();
virtual bool CreateClient(wxMDIParentFrame *parent,
long style = wxVSCROLL | wxHSCROLL);
protected:
virtual void DoGetClientSize(int *width, int *height) const;
wxDECLARE_DYNAMIC_CLASS(wxMDIClientWindow);
};
#endif // _WX_OSX_CARBON_MDI_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dataview.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dataview.h
// Purpose: wxDataViewCtrl native implementation header for OSX
// Author:
// Copyright: (c) 2009
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DATAVIEWCTRL_OSX_H_
#define _WX_DATAVIEWCTRL_OSX_H_
#ifdef __WXMAC_CLASSIC__
# error "Native wxDataViewCtrl for classic environment not defined. Please use generic control."
#endif
// --------------------------------------------------------
// Class declarations to mask native types
// --------------------------------------------------------
class wxDataViewColumnNativeData; // class storing environment dependent data for the native implementation
class wxDataViewWidgetImpl; // class used as a common interface for carbon and cocoa implementation
// ---------------------------------------------------------
// wxDataViewColumn
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewColumn: public wxDataViewColumnBase
{
public:
// constructors / destructor
wxDataViewColumn(const wxString& title,
wxDataViewRenderer* renderer,
unsigned int model_column,
int width = wxDVC_DEFAULT_WIDTH,
wxAlignment align = wxALIGN_CENTER,
int flags = wxDATAVIEW_COL_RESIZABLE);
wxDataViewColumn(const wxBitmap& bitmap,
wxDataViewRenderer* renderer,
unsigned int model_column,
int width = wxDVC_DEFAULT_WIDTH,
wxAlignment align = wxALIGN_CENTER,
int flags = wxDATAVIEW_COL_RESIZABLE);
virtual ~wxDataViewColumn();
// implement wxHeaderColumnBase pure virtual methods
virtual wxAlignment GetAlignment() const { return m_alignment; }
virtual int GetFlags() const { return m_flags; }
virtual int GetMaxWidth() const { return m_maxWidth; }
virtual int GetMinWidth() const { return m_minWidth; }
virtual wxString GetTitle() const { return m_title; }
virtual int GetWidth() const;
virtual bool IsSortOrderAscending() const { return m_ascending; }
virtual bool IsSortKey() const;
virtual bool IsHidden() const;
virtual void SetAlignment (wxAlignment align);
virtual void SetBitmap (wxBitmap const& bitmap);
virtual void SetFlags (int flags) { m_flags = flags; /*SetIndividualFlags(flags); */ }
virtual void SetHidden (bool hidden);
virtual void SetMaxWidth (int maxWidth);
virtual void SetMinWidth (int minWidth);
virtual void SetReorderable(bool reorderable);
virtual void SetResizeable (bool resizable);
virtual void UnsetAsSortKey();
virtual void SetSortable (bool sortable);
virtual void SetSortOrder (bool ascending);
virtual void SetTitle (wxString const& title);
virtual void SetWidth (int width);
// implementation only
wxDataViewColumnNativeData* GetNativeData() const
{
return m_NativeDataPtr;
}
void SetNativeData(wxDataViewColumnNativeData* newNativeDataPtr); // class takes ownership of pointer
int GetWidthVariable() const
{
return m_width;
}
void SetWidthVariable(int NewWidth)
{
m_width = NewWidth;
}
void SetSortOrderVariable(bool NewOrder)
{
m_ascending = NewOrder;
}
private:
// common part of all ctors
void InitCommon(int width, wxAlignment align, int flags)
{
m_ascending = true;
m_flags = flags & ~wxDATAVIEW_COL_HIDDEN; // TODO
m_maxWidth = 30000;
m_minWidth = 0;
m_alignment = align;
SetWidth(width);
}
bool m_ascending; // sorting order
int m_flags; // flags for the column
int m_maxWidth; // maximum width for the column
int m_minWidth; // minimum width for the column
int m_width; // column width
wxAlignment m_alignment; // column header alignment
wxDataViewColumnNativeData* m_NativeDataPtr; // storing environment dependent data for the native implementation
wxString m_title; // column title
};
//
// type definitions related to wxDataViewColumn
//
WX_DEFINE_ARRAY(wxDataViewColumn*,wxDataViewColumnPtrArrayType);
// ---------------------------------------------------------
// wxDataViewCtrl
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewCtrl: public wxDataViewCtrlBase
{
public:
// Constructors / destructor:
wxDataViewCtrl()
{
Init();
}
wxDataViewCtrl(wxWindow *parent,
wxWindowID winid,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxDataViewCtrlNameStr )
{
Init();
Create(parent, winid, pos, size, style, validator, name);
}
~wxDataViewCtrl();
bool Create(wxWindow *parent,
wxWindowID winid,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxDataViewCtrlNameStr);
virtual wxWindow* GetMainWindow() // not used for the native implementation
{
return this;
}
// inherited methods from wxDataViewCtrlBase:
virtual bool AssociateModel(wxDataViewModel* model) wxOVERRIDE;
virtual bool AppendColumn (wxDataViewColumn* columnPtr) wxOVERRIDE;
virtual bool ClearColumns () wxOVERRIDE;
virtual bool DeleteColumn (wxDataViewColumn* columnPtr) wxOVERRIDE;
virtual wxDataViewColumn* GetColumn (unsigned int pos) const wxOVERRIDE;
virtual unsigned int GetColumnCount () const wxOVERRIDE;
virtual int GetColumnPosition(const wxDataViewColumn* columnPtr) const wxOVERRIDE;
virtual wxDataViewColumn* GetSortingColumn () const wxOVERRIDE;
virtual bool InsertColumn (unsigned int pos, wxDataViewColumn *col) wxOVERRIDE;
virtual bool PrependColumn (wxDataViewColumn* columnPtr) wxOVERRIDE;
virtual void Collapse( const wxDataViewItem& item) wxOVERRIDE;
virtual void EnsureVisible(const wxDataViewItem& item, const wxDataViewColumn* columnPtr=NULL) wxOVERRIDE;
virtual bool IsExpanded(const wxDataViewItem & item) const wxOVERRIDE;
virtual unsigned int GetCount() const;
virtual int GetCountPerPage() const wxOVERRIDE;
virtual wxRect GetItemRect(const wxDataViewItem& item,
const wxDataViewColumn* columnPtr = NULL) const wxOVERRIDE;
virtual int GetSelectedItemsCount() const wxOVERRIDE;
virtual int GetSelections(wxDataViewItemArray& sel) const wxOVERRIDE;
virtual wxDataViewItem GetTopItem() const wxOVERRIDE;
virtual void HitTest(const wxPoint& point, wxDataViewItem& item, wxDataViewColumn*& columnPtr) const wxOVERRIDE;
virtual bool SetRowHeight(int rowHeight) wxOVERRIDE;
virtual bool IsSelected(const wxDataViewItem& item) const wxOVERRIDE;
virtual void SelectAll() wxOVERRIDE;
virtual void Select(const wxDataViewItem& item) wxOVERRIDE;
virtual void SetSelections(const wxDataViewItemArray& sel) wxOVERRIDE;
virtual void Unselect(const wxDataViewItem& item) wxOVERRIDE;
virtual void UnselectAll() wxOVERRIDE;
//
// implementation
//
// returns a pointer to the native implementation
wxDataViewWidgetImpl* GetDataViewPeer() const;
// adds all children of the passed parent to the control; if 'parentItem' is invalid the root(s) is/are added:
void AddChildren(wxDataViewItem const& parentItem);
// finishes editing of custom items; if no custom item is currently edited the method does nothing
void FinishCustomItemEditing();
virtual void EditItem(const wxDataViewItem& item, const wxDataViewColumn *column) wxOVERRIDE;
// returns the n-th pointer to a column;
// this method is different from GetColumn(unsigned int pos) because here 'n' is not a position in the control but the n-th
// position in the internal list/array of column pointers
wxDataViewColumn* GetColumnPtr(size_t n) const
{
return m_ColumnPtrs[n];
}
// returns the current being rendered item of the customized renderer (this item is only valid during editing)
wxDataViewItem const& GetCustomRendererItem() const
{
return m_CustomRendererItem;
}
// returns a pointer to a customized renderer (this pointer is only valid during editing)
wxDataViewCustomRenderer* GetCustomRendererPtr() const
{
return m_CustomRendererPtr;
}
// checks if currently a delete process is running
bool IsDeleting() const
{
return m_Deleting;
}
// with CG, we need to get the context from an kEventControlDraw event
// unfortunately, the DataBrowser callbacks don't provide the context
// and we need it, so we need to set/remove it before and after draw
// events so we can access it in the callbacks.
void MacSetDrawingContext(void* context)
{
m_cgContext = context;
}
void* MacGetDrawingContext() const
{
return m_cgContext;
}
// sets the currently being edited item of the custom renderer
void SetCustomRendererItem(wxDataViewItem const& NewItem)
{
m_CustomRendererItem = NewItem;
}
// sets the custom renderer
void SetCustomRendererPtr(wxDataViewCustomRenderer* NewCustomRendererPtr)
{
m_CustomRendererPtr = NewCustomRendererPtr;
}
// sets the flag indicating a deletion process:
void SetDeleting(bool deleting)
{
m_Deleting = deleting;
}
virtual wxDataViewColumn *GetCurrentColumn() const wxOVERRIDE;
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
// inherited methods from wxDataViewCtrlBase
virtual void DoSetExpanderColumn() wxOVERRIDE;
virtual void DoSetIndent() wxOVERRIDE;
virtual void DoExpand(const wxDataViewItem& item) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// event handling
void OnSize(wxSizeEvent &event);
void OnMouse(wxMouseEvent &event);
private:
// initializing of local variables:
void Init();
virtual wxDataViewItem DoGetCurrentItem() const wxOVERRIDE;
virtual void DoSetCurrentItem(const wxDataViewItem& item) wxOVERRIDE;
//
// variables
//
bool m_Deleting; // flag indicating if a delete process is running; this flag is necessary because the notifier indicating an item deletion in the model may be called
// after the actual deletion of the item; then, native callback functions/delegates may try to update data of variables that are already deleted;
// if this flag is set all native variable update requests will be ignored
void* m_cgContext; // pointer to core graphics context
wxDataViewCustomRenderer* m_CustomRendererPtr; // pointer to a valid custom renderer while editing; this class does NOT own the pointer
wxDataViewItem m_CustomRendererItem; // currently edited item by the customrenderer; it is invalid while not editing a custom item
wxDataViewColumnPtrArrayType m_ColumnPtrs; // all column pointers are stored in an array
wxDataViewModelNotifier* m_ModelNotifier; // stores the model notifier for the control (does not own the notifier)
// wxWidget internal stuff:
wxDECLARE_DYNAMIC_CLASS(wxDataViewCtrl);
wxDECLARE_NO_COPY_CLASS(wxDataViewCtrl);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_DATAVIEWCTRL_OSX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/private.h | #ifndef _WX_PRIVATE_OSX_H_
#define _WX_PRIVATE_OSX_H_
#include "wx/osx/core/private.h"
#if wxOSX_USE_IPHONE
#include "wx/osx/iphone/private.h"
#elif wxOSX_USE_COCOA
#include "wx/osx/cocoa/private.h"
#elif wxUSE_GUI
#error "Must include wx/defs.h first"
#endif
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/accel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/accel.h
// Purpose: wxAcceleratorTable class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ACCEL_H_
#define _WX_ACCEL_H_
#include "wx/string.h"
#include "wx/event.h"
class WXDLLIMPEXP_CORE wxAcceleratorTable: public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxAcceleratorTable);
public:
wxAcceleratorTable();
wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]); // Load from array
virtual ~wxAcceleratorTable();
bool Ok() const { return IsOk(); }
bool IsOk() const;
int GetCommand( wxKeyEvent &event );
};
#endif
// _WX_ACCEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dvrenderer.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dvrenderer.h
// Purpose: wxDataViewRenderer for OS X wxDataViewCtrl implementations
// Author: Vadim Zeitlin
// Created: 2009-11-07 (extracted from wx/osx/dataview.h)
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_DVRENDERER_H_
#define _WX_OSX_DVRENDERER_H_
class wxDataViewRendererNativeData;
// ----------------------------------------------------------------------------
// wxDataViewRenderer
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewRenderer : public wxDataViewRendererBase
{
public:
// constructors / destructor
// -------------------------
wxDataViewRenderer(const wxString& varianttype,
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT);
virtual ~wxDataViewRenderer();
// inherited methods from wxDataViewRendererBase
// ---------------------------------------------
virtual int GetAlignment() const wxOVERRIDE
{
return m_alignment;
}
virtual wxDataViewCellMode GetMode() const wxOVERRIDE
{
return m_mode;
}
virtual bool GetValue(wxVariant& value) const wxOVERRIDE
{
value = m_value;
return true;
}
// NB: in Carbon this is always identical to the header alignment
virtual void SetAlignment(int align) wxOVERRIDE;
virtual void SetMode(wxDataViewCellMode mode) wxOVERRIDE;
virtual bool SetValue(const wxVariant& newValue) wxOVERRIDE
{
m_value = newValue;
return true;
}
virtual void EnableEllipsize(wxEllipsizeMode mode = wxELLIPSIZE_MIDDLE) wxOVERRIDE;
virtual wxEllipsizeMode GetEllipsizeMode() const wxOVERRIDE;
// implementation
// --------------
const wxVariant& GetValue() const
{
return m_value;
}
wxDataViewRendererNativeData* GetNativeData() const
{
return m_NativeDataPtr;
}
// a call to the native data browser function to render the data;
// returns true if the data value could be rendered, false otherwise
virtual bool MacRender() = 0;
void SetNativeData(wxDataViewRendererNativeData* newNativeDataPtr);
void OSXUpdateAlignment();
#if wxOSX_USE_COCOA
// called when a value was edited by user
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col);
protected:
virtual void SetAttr(const wxDataViewItemAttr& attr) wxOVERRIDE;
virtual void SetEnabled(bool enabled) wxOVERRIDE;
#else
protected:
void SetAttr(const wxDataViewItemAttr& WXUNUSED(attr)) wxOVERRIDE { };
void SetEnabled(bool WXUNUSED(enabled)) wxOVERRIDE { };
#endif
virtual bool IsHighlighted() const wxOVERRIDE;
private:
// contains the alignment flags
int m_alignment;
// storing the mode that determines how the cell is going to be shown
wxDataViewCellMode m_mode;
// data used by implementation of the native renderer
wxDataViewRendererNativeData* m_NativeDataPtr;
// value that is going to be rendered
wxVariant m_value;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewRenderer);
};
#endif // _WX_OSX_DVRENDERER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/scrolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/scrolbar.h
// Purpose: wxScrollBar class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// 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);
virtual int GetThumbPosition() const wxOVERRIDE;
virtual int GetThumbSize() const wxOVERRIDE { return m_viewSize; }
virtual int GetPageSize() const wxOVERRIDE { return m_pageSize; }
virtual 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 ) ; }
// implementation only from now on
void Command(wxCommandEvent& event) wxOVERRIDE;
virtual void TriggerScrollEvent( wxEventType scrollEvent ) wxOVERRIDE;
virtual bool OSXHandleClicked( double timestampsec ) wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
int m_pageSize;
int m_viewSize;
int m_objectSize;
wxDECLARE_DYNAMIC_CLASS(wxScrollBar);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_SCROLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dirdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dirdlg.h
// Purpose: wxDirDialog class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIRDLG_H_
#define _WX_DIRDLG_H_
#if wxOSX_USE_COCOA
DECLARE_WXCOCOA_OBJC_CLASS(NSOpenPanel);
#endif
class WXDLLIMPEXP_CORE wxDirDialog : public wxDirDialogBase
{
public:
wxDirDialog() { Init(); }
wxDirDialog(wxWindow *parent,
const wxString& message = wxDirSelectorPromptStr,
const wxString& defaultPath = wxT(""),
long style = wxDD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxDirDialogNameStr)
{
Init();
Create(parent,message,defaultPath,style,pos,size,name);
}
void Create(wxWindow *parent,
const wxString& message = wxDirSelectorPromptStr,
const wxString& defaultPath = wxT(""),
long style = wxDD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxDirDialogNameStr);
#if wxOSX_USE_COCOA
~wxDirDialog();
#endif
virtual int ShowModal();
#if wxOSX_USE_COCOA
virtual void ShowWindowModal();
virtual void ModalFinishedCallback(void* panel, int returnCode);
#endif
private:
#if wxOSX_USE_COCOA
// Create and initialize NSOpenPanel that we use in both ShowModal() and
// ShowWindowModal().
WX_NSOpenPanel OSXCreatePanel() const;
WX_NSObject m_sheetDelegate;
#endif
// Common part of all ctors.
void Init();
wxDECLARE_DYNAMIC_CLASS(wxDirDialog);
};
#endif // _WX_DIRDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/choice.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/choice.h
// Purpose: wxChoice class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHOICE_H_
#define _WX_CHOICE_H_
#include "wx/control.h"
#include "wx/dynarray.h"
#include "wx/arrstr.h"
WX_DEFINE_ARRAY( char * , wxChoiceDataArray ) ;
// Choice item
class WXDLLIMPEXP_CORE wxChoice: public wxChoiceBase
{
wxDECLARE_DYNAMIC_CLASS(wxChoice);
public:
wxChoice()
: m_strings(), m_datas()
{}
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)
{
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)
{
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 unsigned int GetCount() const ;
virtual int GetSelection() const ;
virtual void SetSelection(int n);
virtual int FindString(const wxString& s, bool bCase = false) const;
virtual wxString GetString(unsigned int n) const ;
virtual void SetString(unsigned int pos, const wxString& s);
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec );
protected:
virtual void DoDeleteOneItem(unsigned int n);
virtual void DoClear();
virtual wxSize DoGetBestSize() const ;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual void DoSetItemClientData(unsigned int n, void* clientData);
virtual void* DoGetItemClientData(unsigned int n) const;
wxArrayString m_strings;
wxChoiceDataArray m_datas ;
private:
// This should be called when the number of items in the control changes.
void DoAfterItemCountChange();
};
#endif
// _WX_CHOICE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/printmac.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/printmac.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 wxMacPrinter: public wxPrinterBase
{
wxDECLARE_DYNAMIC_CLASS(wxMacPrinter);
public:
wxMacPrinter(wxPrintDialogData *data = NULL);
virtual ~wxMacPrinter();
virtual bool Print(wxWindow *parent,
wxPrintout *printout,
bool prompt = true);
virtual wxDC* PrintDialog(wxWindow *parent);
virtual bool Setup(wxWindow *parent);
};
/*
* wxPrintPreview
* Programmer creates an object of this class to preview a wxPrintout.
*/
class WXDLLIMPEXP_CORE wxMacPrintPreview: public wxPrintPreviewBase
{
wxDECLARE_CLASS(wxMacPrintPreview);
public:
wxMacPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting = NULL,
wxPrintDialogData *data = NULL);
wxMacPrintPreview(wxPrintout *printout,
wxPrintout *printoutForPrinting,
wxPrintData *data);
virtual ~wxMacPrintPreview();
virtual bool Print(bool interactive);
virtual void DetermineScaling();
};
#endif
// _WX_PRINTWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/bitmap.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/bitmap.h
// Purpose: wxBitmap class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#include "wx/palette.h"
// Bitmap
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class wxBitmapRefData ;
class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;
class WXDLLIMPEXP_FWD_CORE wxControl;
class WXDLLIMPEXP_FWD_CORE wxCursor;
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxIcon;
class WXDLLIMPEXP_FWD_CORE wxImage;
class WXDLLIMPEXP_FWD_CORE wxPixelDataBase;
// A mask is a bitmap used for drawing bitmaps
// Internally it is stored as a 8 bit deep memory chunk, 0 = black means the source will be drawn
// 255 = white means the source will not be drawn, no other values will be present
// 8 bit is chosen only for performance reasons, note also that this is the inverse value range
// from alpha, where 0 = invisible , 255 = fully drawn
class WXDLLIMPEXP_CORE wxMask: public wxMaskBase
{
wxDECLARE_DYNAMIC_CLASS(wxMask);
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 mono bitmap (black meaning show pixels, white meaning transparent)
wxMask(const wxBitmap& bitmap);
virtual ~wxMask();
wxBitmap GetBitmap() const;
// Implementation below
void Init() ;
// a 8 bit depth mask
void* GetRawAccess() const;
int GetBytesPerRow() const;
int GetWidth() const;
int GetHeight() const;
// renders/updates native representation when necessary
void RealizeNative() ;
WXHBITMAP GetHBITMAP() const ;
// implementation helper only : construct a mask from a 32 bit memory buffer
bool OSXCreate(const wxMemoryBuffer& buf, int width , int height , int bytesPerRow ) ;
protected:
// this function is called from Create() to free the existing mask data
virtual void FreeData() wxOVERRIDE;
// these functions must be overridden to implement the corresponding public
// Create() methods, they shouldn't call FreeData() as it's already called
// by the public wrappers
virtual bool InitFromColour(const wxBitmap& bitmap,
const wxColour& colour) wxOVERRIDE;
virtual bool InitFromMonoBitmap(const wxBitmap& bitmap) wxOVERRIDE;
private:
void DoCreateMaskBitmap(int width, int height, int bytesPerRow = -1);
wxCFRef<CGContextRef> m_maskBitmap ;
};
class WXDLLIMPEXP_CORE wxBitmap: public wxBitmapBase
{
wxDECLARE_DYNAMIC_CLASS(wxBitmap);
friend class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;
public:
wxBitmap() {} // Platform-specific
// Initialize with raw data.
wxBitmap(const char bits[], int width, int height, int depth = 1);
// Initialize with XPM data
wxBitmap(const char* const* bits);
// Load a file or resource
wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
// Constructor for generalised creation from data
wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth = 1);
// creates an bitmap from the native image format
wxBitmap(CGImageRef image, double scale = 1.0);
wxBitmap(WXImage image);
wxBitmap(CGContextRef bitmapcontext);
// Create a bitmap compatible with the given DC
wxBitmap(int width, int height, const wxDC& dc);
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap(int width, int height, int depth = -1) { (void)Create(width, height, depth); }
wxBitmap(const wxSize& sz, int depth = -1) { (void)Create(sz, depth); }
// Convert from wxImage:
wxBitmap(const wxImage& image, int depth = -1, double scale = 1.0);
// Convert from wxIcon
wxBitmap(const wxIcon& icon) { CopyFromIcon(icon); }
virtual ~wxBitmap() {}
wxImage ConvertToImage() const;
// get the given part of bitmap
wxBitmap GetSubBitmap( const wxRect& rect ) const;
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(const void* data, wxBitmapType type, int width, int height, int depth = 1);
bool Create( CGImageRef image, double scale = 1.0 );
bool Create( WXImage image );
bool Create( CGContextRef bitmapcontext);
// Create a bitmap compatible with the given DC, inheriting its magnification factor
bool Create(int width, int height, const wxDC& dc);
// Create a bitmap with a scale factor, width and height are multiplied with that factor
bool CreateScaled(int logwidth, int logheight, int depth, double logicalScale);
// virtual bool Create( WXHICON icon) ;
virtual bool LoadFile(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
virtual bool SaveFile(const wxString& name, wxBitmapType type, const wxPalette *cmap = NULL) const;
const wxBitmapRefData *GetBitmapData() const
{ return (const wxBitmapRefData *)m_refData; }
wxBitmapRefData *GetBitmapData()
{ return (wxBitmapRefData *)m_refData; }
// copies the contents and mask of the given (colour) icon to the bitmap
virtual bool CopyFromIcon(const wxIcon& icon);
int GetWidth() const;
int GetHeight() const;
int GetDepth() const;
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_MSG("this value is determined during creation, this method could lead to inconsistencies")
void SetWidth(int width);
wxDEPRECATED_MSG("this value is determined during creation, this method could lead to inconsistencies")
void SetHeight(int height);
wxDEPRECATED_MSG("this value is determined during creation, this method could lead to inconsistencies")
void SetDepth(int depth);
#endif
#if wxUSE_PALETTE
wxPalette* GetPalette() const;
void SetPalette(const wxPalette& palette);
#endif // wxUSE_PALETTE
wxMask *GetMask() const;
void SetMask(wxMask *mask) ;
static void InitStandardHandlers();
// raw bitmap access support functions, for internal use only
void *GetRawData(wxPixelDataBase& data, int bpp);
void UngetRawData(wxPixelDataBase& data);
// these functions are internal and shouldn't be used, they risk to
// disappear in the future
bool HasAlpha() const;
void UseAlpha(bool use = true);
// returns the 'native' implementation, a GWorldPtr for the content and one for the mask
WXHBITMAP GetHBITMAP( WXHBITMAP * mask = NULL ) const;
// returns a CGImageRef which must released after usage with CGImageRelease
CGImageRef CreateCGImage() const ;
WXImage GetImage() const;
#if wxOSX_USE_COCOA
// returns an autoreleased version of the image
WX_NSImage GetNSImage() const
{ return GetImage(); }
#endif
#if wxOSX_USE_IPHONE
// returns an autoreleased version of the image
WX_UIImage GetUIImage() const
{ return GetImage(); }
#endif
#if WXWIN_COMPATIBILITY_3_0
#if wxOSX_USE_ICONREF
// returns a IconRef which must be retained before and released after usage
wxDEPRECATED_MSG("IconRefs are deprecated, this will be removed in the future")
IconRef GetIconRef() const;
// returns a IconRef which must be released after usage
wxDEPRECATED_MSG("IconRefs are deprecated, this will be removed in the future")
IconRef CreateIconRef() const;
#endif
// get read only access to the underlying buffer
wxDEPRECATED_MSG("use GetRawData for accessing the buffer")
const void *GetRawAccess() const;
// brackets to the underlying OS structure for read/write access
// makes sure that no cached images will be constructed until terminated
wxDEPRECATED_MSG("use GetRawData for accessing the buffer")
void *BeginRawAccess();
wxDEPRECATED_MSG("use GetRawData for accessing the buffer")
void EndRawAccess();
#endif
double GetScaleFactor() const;
void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
};
#endif // _WX_BITMAP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/minifram.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/minifram.h
// Purpose: wxMiniFrame class. A small frame for e.g. floating toolbars.
// If there is no equivalent on your platform, just make it a
// normal frame.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MINIFRAM_H_
#define _WX_MINIFRAM_H_
#include "wx/frame.h"
class WXDLLIMPEXP_CORE wxMiniFrame: public wxFrame {
wxDECLARE_DYNAMIC_CLASS(wxMiniFrame);
public:
wxMiniFrame() {}
wxMiniFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAPTION | wxRESIZE_BORDER | wxTINY_CAPTION,
const wxString& name = wxFrameNameStr)
{
// Use wxFrame constructor in absence of more specific code.
Create(parent, id, title, pos, size, style | wxFRAME_TOOL_WINDOW | wxFRAME_FLOAT_ON_PARENT , name);
}
virtual ~wxMiniFrame() {}
protected:
};
#endif
// _WX_MINIFRAM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/pen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/pen.h
// Purpose: wxPen class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PEN_H_
#define _WX_PEN_H_
#include "wx/gdiobj.h"
#include "wx/colour.h"
#include "wx/bitmap.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) ;
void SetColour(unsigned char r, unsigned char g, unsigned char b) ;
void SetWidth(int width) ;
void SetStyle(wxPenStyle style) ;
void SetStipple(const wxBitmap& stipple) ;
void SetDashes(int nb_dashes, const wxDash *dash) ;
void SetJoin(wxPenJoin join) ;
void SetCap(wxPenCap cap) ;
wxColour GetColour() const ;
int GetWidth() const;
wxPenStyle GetStyle() const;
wxPenJoin GetJoin() const;
wxPenCap GetCap() const;
int GetDashes(wxDash **ptr) const;
int GetDashCount() const;
wxBitmap *GetStipple() const ;
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); }
// Implementation
// Useful helper: create the brush resource
bool RealizeResource();
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
void Unshare();
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/osx/dialog.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dialog.h
// Purpose: wxDialog class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIALOG_H_
#define _WX_DIALOG_H_
#include "wx/panel.h"
class WXDLLIMPEXP_FWD_CORE wxMacToolTip ;
class WXDLLIMPEXP_FWD_CORE wxModalEventLoop ;
// Dialog boxes
class WXDLLIMPEXP_CORE wxDialog : public wxDialogBase
{
wxDECLARE_DYNAMIC_CLASS(wxDialog);
public:
wxDialog() { Init(); }
// Constructor with no modal flag - the new convention.
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();
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();
// virtual bool Destroy();
virtual bool Show(bool show = true);
// return true if we're showing the dialog modally
virtual bool IsModal() const;
// show the dialog modally and return the value passed to EndModal()
virtual int ShowModal();
virtual void ShowWindowModal();
// may be called to terminate the dialog with the given return code
virtual void EndModal(int retCode);
static bool OSXHasModalDialogsOpen();
void OSXBeginModalDialog();
void OSXEndModalDialog();
#if wxOSX_USE_COCOA
bool OSXGetWorksWhenModal();
void OSXSetWorksWhenModal(bool worksWhenModal);
#endif
// implementation
// --------------
wxDialogModality GetModality() const;
#if wxOSX_USE_COCOA
virtual void ModalFinishedCallback(void* WXUNUSED(panel), int WXUNUSED(returnCode)) {}
#endif
protected:
// show window modal dialog
void DoShowWindowModal();
// end window modal dialog.
void EndWindowModal();
// mac also takes command-period as cancel
virtual bool IsEscapeKey(const wxKeyEvent& event);
wxDialogModality m_modality;
wxModalEventLoop* m_eventLoop;
private:
void Init();
static wxVector<wxDialog*> s_modalStack;
#if wxOSX_USE_COCOA
static wxVector<bool> s_modalWorksStack;
#endif
};
#endif
// _WX_DIALOG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dataobj2.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dataobj2.h
// Purpose: declaration of standard wxDataObjectSimple-derived classes
// Author: David Webster (adapted from Robert Roebling's gtk port
// Modified by:
// Created: 10/21/99
// Copyright: (c) 1998, 1999 Vadim Zeitlin, Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_DATAOBJ2_H_
#define _WX_MAC_DATAOBJ2_H_
// ----------------------------------------------------------------------------
// wxBitmapDataObject is a specialization of wxDataObject for bitmaps
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapDataObject : public wxBitmapDataObjectBase
{
public:
// ctors
wxBitmapDataObject();
wxBitmapDataObject(const wxBitmap& bitmap);
// destr
virtual ~wxBitmapDataObject();
// override base class virtual to update PNG data too
virtual void SetBitmap(const wxBitmap& bitmap);
// implement base class pure virtuals
// ----------------------------------
virtual size_t GetDataSize() const ;
virtual bool GetDataHere(void *buf) const ;
virtual bool SetData(size_t len, const void *buf);
// Must provide overloads to avoid hiding them (and warnings about it)
virtual size_t GetDataSize(const wxDataFormat&) const
{
return GetDataSize();
}
virtual bool GetDataHere(const wxDataFormat&, void *buf) const
{
return GetDataHere(buf);
}
virtual bool SetData(const wxDataFormat&, size_t len, const void *buf)
{
return SetData(len, buf);
}
protected :
void Init() ;
void Clear() ;
void* m_pictHandle ;
bool m_pictCreated ;
};
// ----------------------------------------------------------------------------
// wxFileDataObject is a specialization of wxDataObject for file names
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDataObject : public wxFileDataObjectBase
{
public:
// implement base class pure virtuals
// ----------------------------------
void AddFile( const wxString &filename );
virtual size_t GetDataSize() const;
virtual bool GetDataHere(void *buf) const;
virtual bool SetData(size_t len, const void *buf);
// Must provide overloads to avoid hiding them (and warnings about it)
virtual size_t GetDataSize(const wxDataFormat&) const
{
return GetDataSize();
}
virtual bool GetDataHere(const wxDataFormat&, void *buf) const
{
return GetDataHere(buf);
}
virtual bool SetData(const wxDataFormat&, size_t len, const void *buf)
{
return SetData(len, buf);
}
protected:
// translates the filenames stored into a utf8 encoded char stream
void GetFileNames(wxCharBuffer &buf) const ;
};
#endif // _WX_MAC_DATAOBJ2_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cursor.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cursor.h
// Purpose: wxCursor class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CURSOR_H_
#define _WX_CURSOR_H_
#include "wx/bitmap.h"
// Cursor
class WXDLLIMPEXP_CORE wxCursor : public wxCursorBase
{
public:
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 ~wxCursor();
void MacInstall() const ;
void SetHCURSOR(WXHCURSOR cursor);
WXHCURSOR GetHCURSOR() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
private:
void InitFromStock(wxStockCursor);
void CreateFromImage(const wxImage & image) ;
wxDECLARE_DYNAMIC_CLASS(wxCursor);
};
extern WXDLLIMPEXP_CORE void wxSetCursor(const wxCursor& cursor);
#endif // _WX_CURSOR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dnd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dnd.h
// Purpose: Declaration of the wxDropTarget, wxDropSource class etc.
// Author: Stefan Csomor
// Copyright: (c) 1998 Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DND_H_
#define _WX_DND_H_
#if wxUSE_DRAG_AND_DROP
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/string.h"
#include "wx/dataobj.h"
#include "wx/cursor.h"
//-------------------------------------------------------------------------
// classes
//-------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxDropTarget;
class WXDLLIMPEXP_FWD_CORE wxTextDropTarget;
class WXDLLIMPEXP_FWD_CORE wxFileDropTarget;
class WXDLLIMPEXP_FWD_CORE wxDropSource;
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// this macro may be used instead for wxDropSource ctor arguments: it will use
// the icon 'name' from an XPM file under GTK, but will expand to something
// else under MSW. If you don't use it, you will have to use #ifdef in the
// application code.
#define wxDROP_ICON(X) wxCursor(X##_xpm)
//-------------------------------------------------------------------------
// wxDropTarget
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDropTarget: public wxDropTargetBase
{
public:
wxDropTarget(wxDataObject *dataObject = NULL );
virtual wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
virtual bool OnDrop(wxCoord x, wxCoord y);
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
virtual bool GetData();
// NOTE: This is needed by the generic wxDataViewCtrl, not sure how to implement.
virtual wxDataFormat GetMatchingPair();
bool CurrentDragHasSupportedFormat() ;
void SetCurrentDragPasteboard( void* dragpasteboard ) { m_currentDragPasteboard = dragpasteboard ; }
protected :
void* m_currentDragPasteboard ;
};
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDropSource: public wxDropSourceBase
{
public:
// ctors: if you use default ctor you must call SetData() later!
//
// NB: the "wxWindow *win" parameter is unused and is here only for wxGTK
// compatibility, as well as both icon parameters
wxDropSource( wxWindow *win = NULL,
const wxCursor &cursorCopy = wxNullCursor,
const wxCursor &cursorMove = wxNullCursor,
const wxCursor &cursorStop = wxNullCursor);
/* constructor for setting one data object */
wxDropSource( wxDataObject& data,
wxWindow *win,
const wxCursor &cursorCopy = wxNullCursor,
const wxCursor &cursorMove = wxNullCursor,
const wxCursor &cursorStop = wxNullCursor);
virtual ~wxDropSource();
// do it (call this in response to a mouse button press, for example)
// params: if bAllowMove is false, data can be only copied
virtual wxDragResult DoDragDrop(int flags = wxDrag_CopyOnly);
wxWindow* GetWindow() { return m_window ; }
void SetCurrentDragPasteboard( void* dragpasteboard ) { m_currentDragPasteboard = dragpasteboard ; }
bool MacInstallDefaultCursor(wxDragResult effect) ;
static wxDropSource* GetCurrentDropSource();
protected :
wxWindow *m_window;
void* m_currentDragPasteboard ;
};
#endif // wxUSE_DRAG_AND_DROP
#endif
//_WX_DND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/popupwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/popupwin.h
// Purpose: wxPopupWindow class for wxMac
// Author: Stefan Csomor
// Modified by:
// Created:
// Copyright: (c) 2006 Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_POPUPWIN_H_
#define _WX_MAC_POPUPWIN_H_
// ----------------------------------------------------------------------------
// wxPopupWindow
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPopupWindow : public wxPopupWindowBase
{
public:
wxPopupWindow() { }
~wxPopupWindow();
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);
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxPopupWindow);
};
#endif // _WX_MAC_POPUPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/evtloopsrc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/evtloopsrc.h
// Purpose: wxCFEventLoopSource class
// Author: Vadim Zeitlin
// Created: 2009-10-21
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_EVTLOOPSRC_H_
#define _WX_OSX_EVTLOOPSRC_H_
typedef struct __CFSocket* CFSocketRef;
// ----------------------------------------------------------------------------
// wxCFEventLoopSource: CoreFoundation-based wxEventLoopSource for OS X
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxCFEventLoopSource : public wxEventLoopSource
{
public:
// Create a new source in uninitialized state, call InitSocketRef() later
// to associate it with the socket it is going to use.
wxCFEventLoopSource(wxEventLoopSourceHandler *handler, int flags)
: wxEventLoopSource(handler, flags)
{
m_cfSocket = NULL;
}
// Finish initialization of the event loop source by providing the
// associated socket. This object takes ownership of it and will release it.
void InitSourceSocket(CFSocketRef cfSocket);
// Destructor deletes the associated socket.
virtual ~wxCFEventLoopSource();
private:
CFSocketRef m_cfSocket;
wxDECLARE_NO_COPY_CLASS(wxCFEventLoopSource);
};
#endif // _WX_OSX_EVTLOOPSRC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dataform.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dataform.h
// Purpose: declaration of the wxDataFormat class
// Author: Stefan Csomor (lifted from dnd.h)
// Modified by:
// Created: 10/21/99
// Copyright: (c) 1999 Stefan Csomor
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_DATAFORM_H
#define _WX_MAC_DATAFORM_H
class WXDLLIMPEXP_CORE wxDataFormat
{
public:
typedef unsigned long NativeFormat;
wxDataFormat();
wxDataFormat(wxDataFormatId vType);
wxDataFormat(const wxDataFormat& rFormat);
wxDataFormat(const wxString& rId);
wxDataFormat(const wxChar* pId);
wxDataFormat(NativeFormat vFormat);
~wxDataFormat();
wxDataFormat& operator=(NativeFormat vFormat)
{ SetId(vFormat); return *this; }
// comparison (must have both versions)
bool operator==(const wxDataFormat& format) const ;
bool operator!=(const wxDataFormat& format) const
{ return ! ( *this == format ); }
bool operator==(wxDataFormatId format) const
{ return m_type == (wxDataFormatId)format; }
bool operator!=(wxDataFormatId format) const
{ return m_type != (wxDataFormatId)format; }
wxDataFormat& operator=(const wxDataFormat& format);
// explicit and implicit conversions to NativeFormat which is one of
// standard data types (implicit conversion is useful for preserving the
// compatibility with old code)
NativeFormat GetFormatId() const { return m_format; }
operator NativeFormat() const { return m_format; }
void SetId(NativeFormat format);
// string ids are used for custom types - this SetId() must be used for
// application-specific formats
wxString GetId() const;
void SetId(const wxString& pId);
// implementation
wxDataFormatId GetType() const { return m_type; }
void SetType( wxDataFormatId type );
// returns true if the format is one of those defined in wxDataFormatId
bool IsStandard() const { return m_type > 0 && m_type < wxDF_PRIVATE; }
private:
wxDataFormatId m_type;
NativeFormat m_format;
// indicates the type in case of wxDF_PRIVATE :
wxString m_id ;
};
#endif // _WX_MAC_DATAFORM_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/joystick.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/joystick.h
// Purpose: wxJoystick class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_JOYSTICK_H_
#define _WX_JOYSTICK_H_
#include "wx/event.h"
class WXDLLIMPEXP_ADV wxJoystick: public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxJoystick);
public:
/*
* Public interface
*/
wxJoystick(int joystick = wxJOYSTICK1) { m_joystick = joystick; }
// Attributes
////////////////////////////////////////////////////////////////////////////
wxPoint GetPosition() const;
int GetPosition(unsigned axis) const;
bool GetButtonState(unsigned button) const;
int GetZPosition() const;
int GetButtonState() const;
int GetPOVPosition() const;
int GetPOVCTSPosition() const;
int GetRudderPosition() const;
int GetUPosition() const;
int GetVPosition() const;
int GetMovementThreshold() const;
void SetMovementThreshold(int threshold) ;
// Capabilities
////////////////////////////////////////////////////////////////////////////
bool IsOk() const; // Checks that the joystick is functioning
static int GetNumberJoysticks() ;
int GetManufacturerId() const ;
int GetProductId() const ;
wxString GetProductName() const ;
int GetXMin() const;
int GetYMin() const;
int GetZMin() const;
int GetXMax() const;
int GetYMax() const;
int GetZMax() const;
int GetNumberButtons() const;
int GetNumberAxes() const;
int GetMaxButtons() const;
int GetMaxAxes() const;
int GetPollingMin() const;
int GetPollingMax() const;
int GetRudderMin() const;
int GetRudderMax() const;
int GetUMin() const;
int GetUMax() const;
int GetVMin() const;
int GetVMax() const;
bool HasRudder() const;
bool HasZ() const;
bool HasU() const;
bool HasV() const;
bool HasPOV() const;
bool HasPOV4Dir() const;
bool HasPOVCTS() const;
// Operations
////////////////////////////////////////////////////////////////////////////
// pollingFreq = 0 means that movement events are sent when above the threshold.
// If pollingFreq > 0, events are received every this many milliseconds.
bool SetCapture(wxWindow* win, int pollingFreq = 0);
bool ReleaseCapture();
protected:
int m_joystick;
};
#endif
// _WX_JOYSTICK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/brush.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/brush.h
// Purpose: wxBrush class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BRUSH_H_
#define _WX_BRUSH_H_
#include "wx/gdicmn.h"
#include "wx/gdiobj.h"
#include "wx/bitmap.h"
class WXDLLIMPEXP_FWD_CORE wxBrush;
// Brush
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) ;
virtual void SetColour(unsigned char r, unsigned char g, unsigned char b) ;
virtual void SetStyle(wxBrushStyle style) ;
virtual void SetStipple(const wxBitmap& stipple) ;
bool operator==(const wxBrush& brush) const;
bool operator!=(const wxBrush& brush) const { return !(*this == brush); }
wxColour GetColour() const;
wxBrushStyle GetStyle() const ;
wxBitmap *GetStipple() const ;
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); }
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
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/osx/clipbrd.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/clipbrd.h
// Purpose: Clipboard functionality.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CLIPBRD_H_
#define _WX_CLIPBRD_H_
#if wxUSE_CLIPBOARD
#include "wx/osx/core/cfref.h"
//-----------------------------------------------------------------------------
// wxClipboard
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClipboard : public wxClipboardBase
{
public:
wxClipboard();
virtual ~wxClipboard();
// open the clipboard before SetData() and GetData()
virtual bool Open();
// close the clipboard after SetData() and GetData()
virtual void Close();
// query whether the clipboard is opened
virtual bool IsOpened() const;
// set the clipboard data. all other formats will be deleted.
virtual bool SetData( wxDataObject *data );
// add to the clipboard data.
virtual bool AddData( wxDataObject *data );
// ask if data in correct format is available
virtual bool IsSupported( const wxDataFormat& format );
// fill data with data on the clipboard (if available)
virtual bool GetData( wxDataObject& data );
// clears wxTheClipboard and the system's clipboard if possible
virtual void Clear();
// 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();
private:
wxDataObject *m_data;
bool m_open;
wxCFRef<PasteboardRef> m_pasteboard;
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/osx/timectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/timectrl.h
// Purpose: Declaration of wxOSX-specific wxTimePickerCtrl class.
// Author: Vadim Zeitlin
// Created: 2011-12-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_TIMECTRL_H_
#define _WX_OSX_TIMECTRL_H_
// ----------------------------------------------------------------------------
// wxTimePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxTimePickerCtrl : public wxTimePickerCtrlBase
{
public:
// Constructors.
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);
virtual void OSXGenerateEvent(const wxDateTime& dt);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTimePickerCtrl);
};
#endif // _WX_OSX_TIMECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/tglbtn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/tglbtn.h
// Purpose: Declaration of the wxToggleButton class, which implements a
// toggle button under wxMac.
// Author: Stefan Csomor
// Modified by:
// Created: 08.02.01
// Copyright: (c) 2004 Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TOGGLEBUTTON_H_
#define _WX_TOGGLEBUTTON_H_
class WXDLLIMPEXP_CORE wxToggleButton : public wxToggleButtonBase
{
public:
wxToggleButton() {}
wxToggleButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
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);
virtual bool GetValue() const ;
virtual bool OSXHandleClicked( double timestampsec );
virtual void Command(wxCommandEvent& event);
protected:
virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxToggleButton);
};
class WXDLLIMPEXP_CORE wxBitmapToggleButton : public wxToggleButton
{
public:
wxBitmapToggleButton() {}
wxBitmapToggleButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxBitmapToggleButton);
};
#endif // _WX_TOGGLEBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dcscreen.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dcscreen.h
// Purpose: wxScreenDC class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCSCREEN_H_
#define _WX_DCSCREEN_H_
#include "wx/dcclient.h"
#include "wx/osx/dcclient.h"
class WXDLLIMPEXP_CORE wxScreenDCImpl: public wxWindowDCImpl
{
public:
wxScreenDCImpl( wxDC *owner );
virtual ~wxScreenDCImpl();
virtual wxBitmap DoGetAsBitmap(const wxRect *subrect) const;
private:
void* m_overlayWindow;
private:
wxDECLARE_CLASS(wxScreenDCImpl);
wxDECLARE_NO_COPY_CLASS(wxScreenDCImpl);
};
#endif
// _WX_DCSCREEN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/combobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/combobox.h
// Purpose: wxComboBox class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COMBOBOX_H_
#define _WX_COMBOBOX_H_
#include "wx/containr.h"
#include "wx/choice.h"
#include "wx/textctrl.h"
WX_DEFINE_ARRAY( char * , wxComboBoxDataArray ) ;
// forward declaration of private implementation classes
class wxComboBoxText;
class wxComboBoxChoice;
class wxComboWidgetImpl;
// Combobox item
class WXDLLIMPEXP_CORE wxComboBox :
public wxWindowWithItems<
wxControl,
wxComboBoxBase>
{
wxDECLARE_DYNAMIC_CLASS(wxComboBox);
public:
virtual ~wxComboBox();
// callback functions
virtual void DelegateTextChanged( const wxString& value );
virtual void DelegateChoice( const wxString& value );
wxComboBox() { }
wxComboBox(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
{
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)
{
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);
virtual int GetSelection() const;
virtual void GetSelection(long *from, long *to) const;
virtual void SetSelection(int n);
virtual void SetSelection(long from, long to);
virtual int FindString(const wxString& s, bool bCase = false) const;
virtual wxString GetString(unsigned int n) const;
virtual wxString GetStringSelection() const;
virtual void SetString(unsigned int n, const wxString& s);
virtual unsigned int GetCount() const;
virtual void SetValue(const wxString& value);
// these methods are provided by wxTextEntry for the native impl.
#if wxOSX_USE_COCOA
virtual void Popup();
virtual void Dismiss();
#endif // wxOSX_USE_COCOA
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec );
#if wxOSX_USE_COCOA
wxComboWidgetImpl* GetComboPeer() const;
#endif
protected:
// List functions
virtual void DoDeleteOneItem(unsigned int n);
virtual void DoClear();
// wxTextEntry functions
virtual wxWindow *GetEditableWindow() { return this; }
// override the base class virtuals involved in geometry calculations
virtual wxSize DoGetBestSize() const;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual void DoSetItemClientData(unsigned int n, void* clientData);
virtual void * DoGetItemClientData(unsigned int n) const;
virtual void EnableTextChangedEvents(bool enable);
// the subcontrols
wxComboBoxText* m_text;
wxComboBoxChoice* m_choice;
wxComboBoxDataArray m_datas;
};
#endif // _WX_COMBOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/setup_inc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/setup_inc.h
// Purpose: OSX-specific setup.h options
// Author: Stefan Csomor
// Modified by: Stefan Csomor
// Created: 2017-11-09
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// Unix-specific options settings
// ----------------------------------------------------------------------------
// use wxSelectDispatcher class
#define wxUSE_SELECT_DISPATCHER 1
// use wxEpollDispatcher class (Linux only)
#define wxUSE_EPOLL_DISPATCHER 0
/*
Use GStreamer for Unix.
Default is 0 as this requires a lot of dependencies which might not be
available.
Recommended setting: 1 (wxMediaCtrl won't work by default without it).
*/
#define wxUSE_GSTREAMER 0
// This is only used under Unix, but needs to be defined here as it's checked
// by wx/unix/chkconf.h.
#define wxUSE_XTEST 0
// ----------------------------------------------------------------------------
// Mac-specific settings
// ----------------------------------------------------------------------------
#undef wxUSE_GRAPHICS_CONTEXT
#define wxUSE_GRAPHICS_CONTEXT 1
// things not implemented under Mac
#undef wxUSE_STACKWALKER
#define wxUSE_STACKWALKER 0
// wxWebKit is a wrapper for Apple's WebKit framework, use it if you want to
// embed the Safari browser control
// 0 by default because of Jaguar compatibility problems
#define wxUSE_WEBKIT 1
// Set to 0 for no libmspack
#define wxUSE_LIBMSPACK 0
// native toolbar does support embedding controls, but not complex panels, please test
#define wxOSX_USE_NATIVE_TOOLBAR 1
// make sure we have the proper dispatcher for the console event loop
#define wxUSE_SELECT_DISPATCHER 1
#define wxUSE_EPOLL_DISPATCHER 0
// set to 1 if you have older code that still needs icon refs
#define wxOSX_USE_ICONREF 0
// set to 0 if you have code that has problems with the new bitmap implementation
#define wxOSX_BITMAP_NATIVE_ACCESS 1
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/glcanvas.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/glcanvas.h
// Purpose: wxGLCanvas, for using OpenGL with wxWidgets under Macintosh
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GLCANVAS_H_
#define _WX_GLCANVAS_H_
#ifdef __WXOSX_IPHONE__
#import <OpenGLES/ES1/gl.h>
#import <OpenGLES/ES1/glext.h>
#define wxUSE_OPENGL_EMULATION 1
#else
#include <OpenGL/gl.h>
#endif
#include "wx/vector.h"
// low level calls
WXDLLIMPEXP_GL WXGLContext WXGLCreateContext( WXGLPixelFormat pixelFormat, WXGLContext shareContext );
WXDLLIMPEXP_GL void WXGLDestroyContext( WXGLContext context );
WXDLLIMPEXP_GL WXGLContext WXGLGetCurrentContext();
WXDLLIMPEXP_GL bool WXGLSetCurrentContext(WXGLContext context);
WXDLLIMPEXP_GL WXGLPixelFormat WXGLChoosePixelFormat(const int *GLAttrs = NULL,
int n1 = 0,
const int *ctxAttrs = NULL,
int n2 = 0);
WXDLLIMPEXP_GL void WXGLDestroyPixelFormat( WXGLPixelFormat pixelFormat );
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;
// Mac-specific
WXGLContext GetWXGLContext() const { return m_glContext; }
private:
WXGLContext m_glContext;
wxDECLARE_NO_COPY_CLASS(wxGLContext);
};
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasBase
{
public:
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);
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;
// Mac-specific functions
// ----------------------
// return true if multisample extension is supported
static bool IsAGLMultiSampleAvailable();
// return the pixel format used by this window
WXGLPixelFormat GetWXGLPixelFormat() const { return m_glFormat; }
// Return the copy of attributes passed at ctor
wxGLAttributes& GetGLDispAttrs() { return m_GLAttrs; }
// update the view port of the current context to match this window
void SetViewport();
// deprecated methods
// ------------------
#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
// implementation-only from now on
protected:
bool DoCreate(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name);
WXGLPixelFormat m_glFormat;
wxGLAttributes m_GLAttrs;
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/osx/window.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/window.h
// Purpose: wxWindowMac class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WINDOW_H_
#define _WX_WINDOW_H_
#include "wx/brush.h"
#include "wx/dc.h"
class WXDLLIMPEXP_FWD_CORE wxButton;
class WXDLLIMPEXP_FWD_CORE wxScrollBar;
class WXDLLIMPEXP_FWD_CORE wxPanel;
class WXDLLIMPEXP_FWD_CORE wxNonOwnedWindow;
#if wxOSX_USE_COCOA_OR_IPHONE
class WXDLLIMPEXP_FWD_CORE wxWidgetImpl ;
typedef wxWidgetImpl wxOSXWidgetImpl;
#endif
class WXDLLIMPEXP_CORE wxWindowMac: public wxWindowBase
{
wxDECLARE_DYNAMIC_CLASS(wxWindowMac);
friend class wxDC;
friend class wxPaintDC;
public:
wxWindowMac();
wxWindowMac( wxWindowMac *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr );
virtual ~wxWindowMac();
bool Create( wxWindowMac *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxPanelNameStr );
virtual void SendSizeEvent(int flags = 0) wxOVERRIDE;
// 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;
virtual bool Show( bool show = true ) wxOVERRIDE;
virtual bool ShowWithEffect(wxShowEffect effect,
unsigned timeout = 0) wxOVERRIDE
{
return OSXShowWithEffect(true, effect, timeout);
}
virtual bool HideWithEffect(wxShowEffect effect,
unsigned timeout = 0) wxOVERRIDE
{
return OSXShowWithEffect(false, effect, timeout);
}
virtual bool IsShownOnScreen() const wxOVERRIDE;
virtual void SetFocus() wxOVERRIDE;
virtual void WarpPointer( int x, int y ) wxOVERRIDE;
virtual bool EnableTouchEvents(int eventsMask) wxOVERRIDE;
virtual void Refresh( bool eraseBackground = true,
const wxRect *rect = NULL ) wxOVERRIDE;
virtual void Update() wxOVERRIDE;
virtual void ClearBackground() wxOVERRIDE;
virtual bool SetCursor( const wxCursor &cursor ) wxOVERRIDE;
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
virtual bool SetBackgroundColour( const wxColour &colour ) wxOVERRIDE;
virtual bool SetForegroundColour( const wxColour &colour ) wxOVERRIDE;
virtual bool SetBackgroundStyle(wxBackgroundStyle style) wxOVERRIDE;
virtual bool IsTransparentBackgroundSupported(wxString* reason = NULL) const wxOVERRIDE;
virtual int GetCharHeight() const wxOVERRIDE;
virtual int GetCharWidth() const wxOVERRIDE;
public:
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 void AlwaysShowScrollbars(bool horz = true, bool vert = true) wxOVERRIDE;
virtual bool IsScrollbarAlwaysShown(int orient) const wxOVERRIDE
{
return orient == wxHORIZONTAL ? m_hScrollBarAlwaysShown
: m_vScrollBarAlwaysShown;
}
virtual bool Reparent( wxWindowBase *newParent ) wxOVERRIDE;
#if wxUSE_HOTKEY && wxOSX_USE_COCOA_OR_CARBON
// hot keys (system wide accelerators)
// -----------------------------------
virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode) wxOVERRIDE;
virtual bool UnregisterHotKey(int hotkeyId) wxOVERRIDE;
#endif // wxUSE_HOTKEY
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget ) wxOVERRIDE;
// Accept files for dragging
virtual void DragAcceptFiles( bool accept ) wxOVERRIDE;
#endif
// implementation from now on
// --------------------------
void MacClientToRootWindow( int *x , int *y ) const;
void MacWindowToRootWindow( int *x , int *y ) const;
void MacRootWindowToWindow( int *x , int *y ) const;
virtual wxString MacGetToolTipString( wxPoint &where );
// simple accessors
// ----------------
virtual WXWidget GetHandle() const wxOVERRIDE;
virtual bool SetTransparent(wxByte alpha) wxOVERRIDE;
virtual bool CanSetTransparent() wxOVERRIDE;
virtual wxByte GetTransparent() const;
// event handlers
// --------------
void OnMouseEvent( wxMouseEvent &event );
void MacOnScroll( wxScrollEvent&event );
virtual bool AcceptsFocus() const wxOVERRIDE;
virtual bool IsDoubleBuffered() const wxOVERRIDE { return true; }
public:
static long MacRemoveBordersFromStyle( long style );
public:
// For implementation purposes:
// sometimes decorations make the client area smaller
virtual wxPoint GetClientAreaOrigin() const wxOVERRIDE;
wxWindowMac *FindItem(long id) const;
wxWindowMac *FindItemByHWND(WXHWND hWnd, bool controlOnly = false) const;
virtual void TriggerScrollEvent( wxEventType scrollEvent ) ;
// this should not be overridden in classes above wxWindowMac
// because it is called from its destructor via DeleteChildren
virtual void RemoveChild( wxWindowBase *child ) wxOVERRIDE;
virtual bool MacDoRedraw( long time ) ;
virtual void MacPaintChildrenBorders();
virtual void MacPaintBorders( int left , int top ) ;
void MacPaintGrowBox();
// invalidates the borders and focus area around the control;
// must not be virtual as it will be called during destruction
void MacInvalidateBorders() ;
WXWindow MacGetTopLevelWindowRef() const ;
wxNonOwnedWindow* MacGetTopLevelWindow() const ;
virtual long MacGetWXBorderSize() const;
virtual long MacGetLeftBorderSize() const ;
virtual long MacGetRightBorderSize() const ;
virtual long MacGetTopBorderSize() const ;
virtual long MacGetBottomBorderSize() const ;
virtual void MacSuperChangedPosition() ;
// absolute coordinates of this window's root have changed
virtual void MacTopLevelWindowChangedPosition() ;
virtual void MacChildAdded() ;
virtual void MacVisibilityChanged() ;
virtual void MacEnabledStateChanged() ;
virtual void MacHiliteChanged() ;
virtual wxInt32 MacControlHit( WXEVENTHANDLERREF handler , WXEVENTREF event ) ;
bool MacIsReallyEnabled() ;
bool MacIsReallyHilited() ;
#if WXWIN_COMPATIBILITY_2_8
bool MacIsUserPane();
#endif
bool MacIsUserPane() const;
virtual bool MacSetupCursor( const wxPoint& pt ) ;
// return the rectangle that would be visible of this control,
// regardless whether controls are hidden
// only taking into account clipping by parent windows
const wxRect& MacGetClippedClientRect() const ;
const wxRect& MacGetClippedRect() const ;
const wxRect& MacGetClippedRectWithOuterStructure() const ;
// returns the visible region of this control in window ie non-client coordinates
const wxRegion& MacGetVisibleRegion( bool includeOuterStructures = false ) ;
// returns true if children have to clipped to the content area
// (e.g., scrolled windows)
bool MacClipChildren() const { return m_clipChildren ; }
void MacSetClipChildren( bool clip ) { m_clipChildren = clip ; }
// returns true if the grandchildren need to be clipped to the children's content area
// (e.g., splitter windows)
virtual bool MacClipGrandChildren() const { return false ; }
bool MacIsWindowScrollbar( const wxWindow* sb ) const
{ return ((wxWindow*)m_hScrollBar == sb || (wxWindow*)m_vScrollBar == sb) ; }
virtual bool IsClientAreaChild(const wxWindow *child) const wxOVERRIDE
{
return !MacIsWindowScrollbar(child) && !((wxWindow*)m_growBox==child) &&
wxWindowBase::IsClientAreaChild(child);
}
void MacPostControlCreate(const wxPoint& pos, const wxSize& size) ;
wxList& GetSubcontrols() { return m_subControls; }
// translate wxWidgets coords into ones suitable
// to be passed to CreateControl calls
//
// returns true if non-default coords are returned, false otherwise
bool MacGetBoundsForControl(const wxPoint& pos,
const wxSize& size,
int& x, int& y,
int& w, int& h , bool adjustForOrigin ) const ;
// the 'true' OS level control for this wxWindow
wxOSXWidgetImpl* GetPeer() const;
// optimization to avoid creating a user pane in wxWindow::Create if we already know
// we will replace it with our own peer
void DontCreatePeer();
// return true unless DontCreatePeer() had been called
bool ShouldCreatePeer() const;
// sets the native implementation wrapper, can replace an existing peer, use peer = NULL to
// release existing peer
void SetPeer(wxOSXWidgetImpl* peer);
// wraps the already existing peer with the wrapper
void SetWrappingPeer(wxOSXWidgetImpl* wrapper);
#if wxOSX_USE_COCOA_OR_IPHONE
// the NSView or NSWindow of this window: can be used for both child and
// non-owned windows
//
// this is useful for a few Cocoa function which can work with either views
// or windows indiscriminately, e.g. for setting NSViewAnimationTargetKey
virtual void *OSXGetViewOrWindow() const;
#endif // Cocoa
void * MacGetCGContextRef() { return m_cgContextRef ; }
void MacSetCGContextRef(void * cg) { m_cgContextRef = cg ; }
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec );
virtual bool OSXHandleKeyEvent( wxKeyEvent& event );
virtual void OSXSimulateFocusEvents();
bool IsNativeWindowWrapper() const { return m_isNativeWindowWrapper; }
double GetContentScaleFactor() const wxOVERRIDE;
// internal response to size events
virtual void MacOnInternalSize() {}
protected:
// For controls like radio buttons which are genuinely composite
wxList m_subControls;
// the peer object, allowing for cleaner API support
void * m_cgContextRef ;
// cache the clipped rectangles within the window hierarchy
void MacUpdateClippedRects() const ;
mutable bool m_cachedClippedRectValid ;
mutable wxRect m_cachedClippedRectWithOuterStructure ;
mutable wxRect m_cachedClippedRect ;
mutable wxRect m_cachedClippedClientRect ;
mutable wxRegion m_cachedClippedRegionWithOuterStructure ;
mutable wxRegion m_cachedClippedRegion ;
mutable wxRegion m_cachedClippedClientRegion ;
// insets of the mac control from the wx top left corner
wxPoint m_macTopLeftInset ;
wxPoint m_macBottomRightInset ;
wxByte m_macAlpha ;
wxScrollBar* m_hScrollBar ;
wxScrollBar* m_vScrollBar ;
bool m_hScrollBarAlwaysShown;
bool m_vScrollBarAlwaysShown;
wxWindow* m_growBox ;
wxString m_label ;
bool m_isNativeWindowWrapper;
// set to true if we do a sharp clip at the content area of this window
// must be dynamic as eg a panel normally is not clipping precisely, but if
// it becomes the target window of a scrolled window it has to...
bool m_clipChildren ;
virtual bool MacIsChildOfClientArea( const wxWindow* child ) const ;
bool MacHasScrollBarCorner() const;
void MacCreateScrollBars( long style ) ;
void MacRepositionScrollBars() ;
void MacUpdateControlFont() ;
// implement the base class pure virtuals
virtual void DoGetTextExtent(const wxString& string,
int *x, int *y,
int *descent = NULL,
int *externalLeading = NULL,
const wxFont *theFont = NULL ) const wxOVERRIDE;
virtual void DoEnable( bool enable ) wxOVERRIDE;
#if wxUSE_MENUS
virtual bool DoPopupMenu( wxMenu *menu, int x, int y ) wxOVERRIDE;
#endif
virtual void DoFreeze() wxOVERRIDE;
virtual void DoThaw() wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetSizeFromClientSize( const wxSize & size ) const;
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 void DoCaptureMouse() wxOVERRIDE;
virtual void DoReleaseMouse() wxOVERRIDE;
// 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;
virtual void DoSetWindowVariant( wxWindowVariant variant ) wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE;
#endif
// common part of Show/HideWithEffect()
virtual bool OSXShowWithEffect(bool show,
wxShowEffect effect,
unsigned timeout);
private:
wxOSXWidgetImpl * m_peer ;
// common part of all ctors
void Init();
// show/hide scrollbars as needed, common part of SetScrollbar() and
// AlwaysShowScrollbars()
void DoUpdateScrollbarVisibility();
wxDECLARE_NO_COPY_CLASS(wxWindowMac);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_WINDOW_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/appprogress.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/appprogress.h
// Purpose: wxAppProgressIndicator OS X implementation
// Author: Tobias Taschner
// Created: 2014-10-22
// Copyright: (c) 2014 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_APPPROG_H_
#define _WX_OSX_APPPROG_H_
#include "wx/window.h"
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;
void *m_dockIcon;
wxDECLARE_NO_COPY_CLASS(wxAppProgressIndicator);
};
#endif // _WX_OSX_APPPROG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dc.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dc.h
// Purpose: wxDC class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DC_H_
#define _WX_DC_H_
#endif // _WX_DC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/msgdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/msgdlg.h
// Purpose: wxMessageDialog class. Use generic version if no
// platform-specific implementation.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// 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& pos = wxDefaultPosition);
#if wxOSX_USE_COCOA
~wxMessageDialog();
#endif
virtual int ShowModal();
#if wxOSX_USE_COCOA
virtual void ShowWindowModal();
virtual void ModalFinishedCallback(void* panel, int resultCode);
#endif
protected:
// not supported for message dialog
virtual void DoSetSize(int WXUNUSED(x), int WXUNUSED(y),
int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(sizeFlags) = wxSIZE_AUTO) {}
#if wxOSX_USE_COCOA
void* ConstructNSAlert();
#endif
int m_buttonId[4];
int m_buttonCount;
#if wxOSX_USE_COCOA
WX_NSObject m_sheetDelegate;
#endif
wxDECLARE_DYNAMIC_CLASS(wxMessageDialog);
};
#endif // _WX_MSGBOXDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/notebook.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/notebook.h
// Purpose: MSW/GTK compatible notebook (a.k.a. property sheet)
// Author: Stefan Csomor
// Modified by:
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_NOTEBOOK_H_
#define _WX_NOTEBOOK_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/event.h"
// ----------------------------------------------------------------------------
// types
// ----------------------------------------------------------------------------
// fwd declarations
class WXDLLIMPEXP_FWD_CORE wxImageList;
class WXDLLIMPEXP_FWD_CORE wxWindow;
// ----------------------------------------------------------------------------
// 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( parent, id, pos, size, style, name ); }
// Create() function
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxNotebookNameStr);
// dtor
virtual ~wxNotebook();
// accessors
// ---------
// 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 { return DoSetSelection(nPage, SetSelection_SendEvent); }
// changes selected page without sending events
int ChangeSelection(size_t nPage) wxOVERRIDE { return DoSetSelection(nPage); }
// set/get the title of a page
bool SetPageText(size_t nPage, const wxString& strText) wxOVERRIDE;
wxString GetPageText(size_t nPage) const 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;
// control the appearance of the notebook pages
// set the size (the same for all pages)
virtual void SetPageSize(const wxSize& size) wxOVERRIDE;
// set the padding between tabs (in pixels)
virtual void SetPadding(const wxSize& padding) wxOVERRIDE;
// sets the size of the tabs (assumes all tabs are the same size)
virtual void SetTabSize(const wxSize& sz) wxOVERRIDE;
// hit test
virtual int HitTest(const wxPoint& pt, long *flags = NULL) const wxOVERRIDE;
// calculate size for wxNotebookSizer
wxSize CalcSizeFromPage(const wxSize& sizePage) const wxOVERRIDE;
wxRect GetPageRect() const wxOVERRIDE;
// operations
// ----------
// remove all pages
bool DeleteAllPages() wxOVERRIDE;
// the same as AddPage(), but adds it at the specified position
bool InsertPage(size_t nPage,
wxNotebookPage *pPage,
const wxString& strText,
bool bSelect = false,
int imageId = NO_IMAGE) wxOVERRIDE;
// callbacks
// ---------
void OnSize(wxSizeEvent& event);
void OnSetFocus(wxFocusEvent& event);
void OnNavigationKey(wxNavigationKeyEvent& event);
// implementation
// --------------
#if wxUSE_CONSTRAINTS
virtual void SetConstraintSizes(bool recurse = true) wxOVERRIDE;
virtual bool DoPhase(int nPhase) wxOVERRIDE;
#endif
// base class virtuals
// -------------------
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec ) wxOVERRIDE;
protected:
virtual wxNotebookPage *DoRemovePage(size_t page) wxOVERRIDE;
// common part of all ctors
void Init();
// helper functions
void ChangePage(int nOldSel, int nSel); // change pages
void MacSetupTabs();
int DoSetSelection(size_t nPage, int flags = 0) wxOVERRIDE;
// the icon indices
wxArrayInt m_images;
wxDECLARE_DYNAMIC_CLASS(wxNotebook);
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_NOTEBOOK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/statline.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/statline.h
// Purpose: a generic wxStaticLine class used for mac before adaptation
// Author: Vadim Zeitlin
// Created: 28.06.99
// Copyright: (c) 1998 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GENERIC_STATLINE_H_
#define _WX_GENERIC_STATLINE_H_
class wxStaticBox;
// ----------------------------------------------------------------------------
// wxStaticLine
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStaticLine : public wxStaticLineBase
{
public:
// constructors and pseudo-constructors
wxStaticLine() : m_statbox(NULL) { }
wxStaticLine( wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = wxLI_HORIZONTAL,
const wxString &name = wxStaticLineNameStr )
: m_statbox(NULL)
{
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 );
// it's necessary to override this wxWindow function because we
// will want to return the main widget for m_statbox
//
WXWidget GetMainWidget() const;
protected:
// we implement the static line using a static box
wxStaticBox *m_statbox;
wxDECLARE_DYNAMIC_CLASS(wxStaticLine);
};
#endif // _WX_GENERIC_STATLINE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dvrenderers.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dvrenderers.h
// Purpose: All OS X wxDataViewCtrl renderer classes
// Author: Vadim Zeitlin
// Created: 2009-11-07 (extracted from wx/osx/dataview.h)
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_DVRENDERERS_H_
#define _WX_OSX_DVRENDERERS_H_
// ---------------------------------------------------------
// wxDataViewCustomRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewCustomRenderer : public wxDataViewCustomRendererBase
{
public:
static wxString GetDefaultType() { return wxS("string"); }
wxDataViewCustomRenderer(const wxString& varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT);
virtual ~wxDataViewCustomRenderer();
// implementation only
// -------------------
virtual bool MacRender();
virtual wxDC* GetDC(); // creates a device context and keeps it
void SetDC(wxDC* newDCPtr); // this method takes ownership of the pointer
private:
wxControl* m_editorCtrlPtr; // pointer to an in-place editor control
wxDC* m_DCPtr;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewCustomRenderer);
};
// ---------------------------------------------------------------------------
// This is a Mac-specific class that should be used as the base class for the
// renderers that should be disabled when they're inert, to prevent the user
// from editing them.
// ---------------------------------------------------------------------------
class wxOSXDataViewDisabledInertRenderer : public wxDataViewRenderer
{
protected:
wxOSXDataViewDisabledInertRenderer(const wxString& varianttype,
wxDataViewCellMode mode,
int alignment)
: wxDataViewRenderer(varianttype, mode, alignment)
{
}
virtual void SetEnabled(bool enabled) wxOVERRIDE
{
wxDataViewRenderer::SetEnabled(enabled &&
GetMode() != wxDATAVIEW_CELL_INERT);
}
};
// ---------------------------------------------------------
// wxDataViewTextRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewTextRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("string"); }
wxDataViewTextRenderer(const wxString& varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT);
#if wxUSE_MARKUP && wxOSX_USE_COCOA
void EnableMarkup(bool enable = true);
#endif // wxUSE_MARKUP && Cocoa
virtual bool MacRender();
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col);
private:
#if wxUSE_MARKUP && wxOSX_USE_COCOA
// True if we should interpret markup in our text.
bool m_useMarkup;
#endif // wxUSE_MARKUP && Cocoa
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewTextRenderer);
};
// ---------------------------------------------------------
// wxDataViewBitmapRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewBitmapRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("wxBitmap"); }
wxDataViewBitmapRenderer(const wxString& varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT);
virtual bool MacRender();
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewBitmapRenderer);
};
// -------------------------------------
// wxDataViewChoiceRenderer
// -------------------------------------
class WXDLLIMPEXP_ADV wxDataViewChoiceRenderer
: public wxOSXDataViewDisabledInertRenderer
{
public:
wxDataViewChoiceRenderer(const wxArrayString& choices,
wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
int alignment = wxDVR_DEFAULT_ALIGNMENT );
virtual bool MacRender();
wxString GetChoice(size_t index) const { return m_choices[index]; }
const wxArrayString& GetChoices() const { return m_choices; }
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col);
private:
wxArrayString m_choices;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewChoiceRenderer);
};
// ----------------------------------------------------------------------------
// wxDataViewChoiceByIndexRenderer
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewChoiceByIndexRenderer: public wxDataViewChoiceRenderer
{
public:
wxDataViewChoiceByIndexRenderer(const wxArrayString& choices,
wxDataViewCellMode mode = wxDATAVIEW_CELL_EDITABLE,
int alignment = wxDVR_DEFAULT_ALIGNMENT);
virtual bool SetValue(const wxVariant& value) wxOVERRIDE;
virtual bool GetValue(wxVariant& value) const wxOVERRIDE;
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col) wxOVERRIDE;
};
// ---------------------------------------------------------
// wxDataViewIconTextRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewIconTextRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("wxDataViewIconText"); }
wxDataViewIconTextRenderer(const wxString& varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT);
virtual bool MacRender();
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewIconTextRenderer);
};
// ---------------------------------------------------------
// wxDataViewToggleRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewToggleRenderer
: public wxOSXDataViewDisabledInertRenderer
{
public:
static wxString GetDefaultType() { return wxS("bool"); }
wxDataViewToggleRenderer(const wxString& varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT);
void ShowAsRadio();
virtual bool MacRender();
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col);
private:
void DoInitButtonCell(int buttonType);
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewToggleRenderer);
};
// ---------------------------------------------------------
// wxDataViewProgressRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewProgressRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("long"); }
wxDataViewProgressRenderer(const wxString& label = wxEmptyString,
const wxString& varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT,
int align = wxDVR_DEFAULT_ALIGNMENT);
virtual bool MacRender();
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewProgressRenderer);
};
// ---------------------------------------------------------
// wxDataViewDateRenderer
// ---------------------------------------------------------
class WXDLLIMPEXP_ADV wxDataViewDateRenderer: public wxDataViewRenderer
{
public:
static wxString GetDefaultType() { return wxS("datetime"); }
wxDataViewDateRenderer(const wxString& varianttype = GetDefaultType(),
wxDataViewCellMode mode = wxDATAVIEW_CELL_ACTIVATABLE,
int align = wxDVR_DEFAULT_ALIGNMENT);
virtual bool MacRender();
virtual void OSXOnCellChanged(NSObject *value,
const wxDataViewItem& item,
unsigned col);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDataViewDateRenderer);
};
#endif // _WX_OSX_DVRENDERERS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/frame.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/frame.h
// Purpose: wxFrame class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FRAME_H_
#define _WX_FRAME_H_
#include "wx/toolbar.h"
#include "wx/accel.h"
#include "wx/icon.h"
class WXDLLIMPEXP_FWD_CORE wxMacToolTip ;
class WXDLLIMPEXP_CORE wxFrame: public wxFrameBase
{
public:
// construction
wxFrame() { }
wxFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
// implementation only from now on
// -------------------------------
// get the origin of the client area (which may be different from (0, 0)
// if the frame has a toolbar) in client coordinates
virtual wxPoint GetClientAreaOrigin() const wxOVERRIDE;
// override some more virtuals
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
// event handlers
void OnActivate(wxActivateEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
// Toolbar
#if wxUSE_TOOLBAR
virtual wxToolBar* CreateToolBar(long style = -1,
wxWindowID id = -1,
const wxString& name = wxToolBarNameStr) wxOVERRIDE;
virtual void SetToolBar(wxToolBar *toolbar) wxOVERRIDE;
#endif // wxUSE_TOOLBAR
// Status bar
#if wxUSE_STATUSBAR
virtual wxStatusBar* OnCreateStatusBar(int number = 1,
long style = wxSTB_DEFAULT_STYLE,
wxWindowID id = 0,
const wxString& name = wxStatusLineNameStr) wxOVERRIDE;
#endif // wxUSE_STATUSBAR
void PositionBars();
// internal response to size events
virtual void MacOnInternalSize() wxOVERRIDE { PositionBars(); }
protected:
#if wxUSE_TOOLBAR
virtual void PositionToolBar() wxOVERRIDE;
#endif
#if wxUSE_STATUSBAR
virtual void PositionStatusBar() wxOVERRIDE;
#endif
// override base class virtuals
virtual void DoGetClientSize(int *width, int *height) const wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
#if wxUSE_MENUS
virtual void DetachMenuBar() wxOVERRIDE;
virtual void AttachMenuBar(wxMenuBar *menubar) wxOVERRIDE;
#endif
virtual bool MacIsChildOfClientArea( const wxWindow* child ) const wxOVERRIDE;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxFrame);
};
#endif
// _WX_FRAME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dataobj.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dataobj.h
// Purpose: declaration of the wxDataObject
// Author: Stefan Csomor (adapted from Robert Roebling's gtk port)
// Modified by:
// Created: 10/21/99
// Copyright: (c) 1998, 1999 Vadim Zeitlin, Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_DATAOBJ_H_
#define _WX_MAC_DATAOBJ_H_
// ----------------------------------------------------------------------------
// wxDataObject is the same as wxDataObjectBase under wxGTK
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxDataObject : public wxDataObjectBase
{
public:
wxDataObject();
#ifdef __DARWIN__
virtual ~wxDataObject() { }
#endif
virtual bool IsSupportedFormat( const wxDataFormat& format, Direction dir = Get ) const;
void AddToPasteboard( void * pasteboardRef , wxIntPtr itemID );
// returns true if the passed in format is present in the pasteboard
static bool IsFormatInPasteboard( void * pasteboardRef, const wxDataFormat &dataFormat );
// returns true if any of the accepted formats of this dataobj is in the pasteboard
bool HasDataInPasteboard( void * pasteboardRef );
bool GetFromPasteboard( void * pasteboardRef );
#if wxOSX_USE_COCOA
virtual void AddSupportedTypes( void* cfarray);
#endif
};
#endif // _WX_MAC_DATAOBJ_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/statbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/statbox.h
// Purpose: wxStaticBox class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATBOX_H_
#define _WX_STATBOX_H_
class WXDLLIMPEXP_CORE wxStaticBox : public wxStaticBoxBase
{
wxDECLARE_DYNAMIC_CLASS(wxStaticBox);
public:
wxStaticBox() {}
wxStaticBox(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBoxNameStr);
virtual void Command(wxCommandEvent& WXUNUSED(event)) {}
virtual void ProcessCommand(wxCommandEvent& WXUNUSED(event)) {}
virtual void GetBordersForSizer(int *borderTop, int *borderOther) const;
virtual bool AcceptsFocus() const { return false; }
// protect native font of box
virtual bool SetFont( const wxFont &font );
};
#endif
// _WX_STATBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/control.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/control.h
// Purpose: wxControl class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CONTROL_H_
#define _WX_CONTROL_H_
WXDLLIMPEXP_DATA_CORE(extern const char) wxControlNameStr[];
// General item class
class WXDLLIMPEXP_CORE wxControl : public wxControlBase
{
wxDECLARE_ABSTRACT_CLASS(wxControl);
public:
wxControl();
wxControl(wxWindow *parent, wxWindowID winid,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr)
{
Create(parent, winid, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID winid,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxControlNameStr);
// Simulates an event
virtual void Command(wxCommandEvent& event) { ProcessCommand(event); }
// implementation from now on
// --------------------------
// Calls the callback and appropriate event handlers
bool ProcessCommand(wxCommandEvent& event);
void OnKeyDown( wxKeyEvent &event ) ;
};
#endif
// _WX_CONTROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/chkconf.h | /*
* Name: wx/osx/chkconf.h
* Purpose: Mac-specific config settings checks
* Author: Vadim Zeitlin
* Modified by:
* Created: 2005-04-05 (extracted from wx/chkconf.h)
* Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_OSX_CHKCONF_H_
#define _WX_OSX_CHKCONF_H_
/*
* check graphics context option, must be on for every os x platform
* we only use core graphics now on all builds, try to catch attempts
* to configure the build otherwise and give error messages
*/
#if wxUSE_GUI && (!wxUSE_GRAPHICS_CONTEXT || \
( defined( wxMAC_USE_CORE_GRAPHICS ) && !wxMAC_USE_CORE_GRAPHICS ))
# error "OS X builds use CoreGraphics in this wx version, you cannot turn back to QuickDraw completely"
#endif
/*
* using mixins of cocoa functionality
*/
#ifdef __WXOSX_COCOA__
#define wxOSX_USE_COCOA 1
#else
#define wxOSX_USE_COCOA 0
#endif
#ifdef __WXOSX_CARBON__
#define wxOSX_USE_CARBON 1
#else
#define wxOSX_USE_CARBON 0
#endif
#ifdef __WXOSX_IPHONE__
#define wxOSX_USE_IPHONE 1
#else
#define wxOSX_USE_IPHONE 0
#endif
/*
* setting flags according to the platform
*/
#ifdef __LP64__
#if wxOSX_USE_CARBON
#error "Carbon does not support 64bit"
#endif
#endif
/*
* combination flags
*/
#if wxOSX_USE_COCOA || wxOSX_USE_CARBON
#define wxOSX_USE_COCOA_OR_CARBON 1
#else
#define wxOSX_USE_COCOA_OR_CARBON 0
#endif
#if wxOSX_USE_COCOA || wxOSX_USE_IPHONE
#define wxOSX_USE_COCOA_OR_IPHONE 1
#else
#define wxOSX_USE_COCOA_OR_IPHONE 0
#endif
#if wxOSX_USE_IPHONE
#include "wx/osx/iphone/chkconf.h"
#elif wxOSX_USE_COCOA
#include "wx/osx/cocoa/chkconf.h"
#endif
#endif /* _WX_OSX_CHKCONF_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/dcprint.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/dcprint.h
// Purpose: wxPrinterDC class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCPRINT_H_
#define _WX_DCPRINT_H_
#include "wx/dc.h"
#include "wx/dcgraph.h"
#include "wx/cmndata.h"
class wxNativePrinterDC ;
class WXDLLIMPEXP_CORE wxPrinterDCImpl: public wxGCDCImpl
{
public:
#if wxUSE_PRINTING_ARCHITECTURE
wxPrinterDCImpl( wxPrinterDC *owner, const wxPrintData& printdata );
virtual ~wxPrinterDCImpl();
virtual bool StartDoc( const wxString& WXUNUSED(message) ) ;
virtual void EndDoc(void) ;
virtual void StartPage(void) ;
virtual void EndPage(void) ;
wxRect GetPaperRect() const;
wxPrintData& GetPrintData() { return m_printData; }
virtual wxSize GetPPI() const;
protected:
virtual void DoGetSize( int *width, int *height ) const;
wxPrintData m_printData ;
wxNativePrinterDC* m_nativePrinterDC ;
private:
wxDECLARE_CLASS(wxPrinterDC);
#endif // wxUSE_PRINTING_ARCHITECTURE
};
#endif
// _WX_DCPRINT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/printdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/printdlg.h
// Purpose: wxPrintDialog, wxPageSetupDialog classes.
// Use generic, PostScript version if no
// platform-specific implementation.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRINTDLG_H_
#define _WX_PRINTDLG_H_
#include "wx/dialog.h"
#include "wx/cmndata.h"
#include "wx/printdlg.h"
#include "wx/prntbase.h"
/*
* wxMacPrintDialog
* The Mac dialog for printing
*/
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_CORE wxMacPrintDialog: public wxPrintDialogBase
{
public:
wxMacPrintDialog();
wxMacPrintDialog(wxWindow *parent, wxPrintDialogData* data = NULL);
wxMacPrintDialog(wxWindow *parent, wxPrintData* data );
virtual ~wxMacPrintDialog();
bool Create(wxWindow *parent, wxPrintDialogData* data = NULL);
virtual int ShowModal();
virtual wxPrintDialogData& GetPrintDialogData() { return m_printDialogData; }
virtual wxPrintData& GetPrintData() { return m_printDialogData.GetPrintData(); }
virtual wxDC *GetPrintDC();
private:
wxPrintDialogData m_printDialogData;
wxDC* m_printerDC;
bool m_destroyDC;
wxWindow* m_dialogParent;
private:
wxDECLARE_DYNAMIC_CLASS(wxPrintDialog);
};
/*
* wxMacPageSetupDialog
* The Mac page setup dialog
*/
class WXDLLIMPEXP_CORE wxMacPageSetupDialog: public wxPageSetupDialogBase
{
public:
wxMacPageSetupDialog(wxWindow *parent, wxPageSetupDialogData *data = NULL);
virtual ~wxMacPageSetupDialog();
virtual wxPageSetupDialogData& GetPageSetupDialogData();
bool Create(wxWindow *parent, wxPageSetupDialogData *data = NULL);
virtual int ShowModal();
private:
wxPageSetupDialogData m_pageSetupData;
wxWindow* m_dialogParent;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMacPageSetupDialog);
};
class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
/*
* wxMacPageMarginsDialog
* A Mac dialog for setting the page margins separately from page setup since
* (native) wxMacPageSetupDialog doesn't let you set margins.
*/
class WXDLLIMPEXP_CORE wxMacPageMarginsDialog : public wxDialog
{
public:
wxMacPageMarginsDialog(wxFrame* parent, wxPageSetupDialogData* data);
bool TransferToWindow();
bool TransferDataFromWindow();
virtual wxPageSetupDialogData& GetPageSetupDialogData() { return *m_pageSetupDialogData; }
private:
wxPageSetupDialogData* m_pageSetupDialogData;
wxPoint m_MinMarginTopLeft;
wxPoint m_MinMarginBottomRight;
wxTextCtrl *m_LeftMargin;
wxTextCtrl *m_TopMargin;
wxTextCtrl *m_RightMargin;
wxTextCtrl *m_BottomMargin;
void GetMinMargins();
bool CheckValue(wxTextCtrl* textCtrl, int *value, int minValue, const wxString& name);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMacPageMarginsDialog);
};
#endif // _WX_PRINTDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/mimetype.h | #include "wx/osx/core/mimetype.h"
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/colordlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/colordlg.h
// Purpose: wxColourDialog class. Use generic version if no
// platform-specific implementation.
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COLORDLG_H_
#define _WX_COLORDLG_H_
#include "wx/dialog.h"
/*
* Platform-specific colour dialog implementation
*/
class WXDLLIMPEXP_CORE wxColourDialog: public wxDialog
{
wxDECLARE_DYNAMIC_CLASS(wxColourDialog);
public:
wxColourDialog();
wxColourDialog(wxWindow *parent, wxColourData *data = NULL);
bool Create(wxWindow *parent, wxColourData *data = NULL);
int ShowModal();
wxColourData& GetColourData() { return m_colourData; }
protected:
wxColourData m_colourData;
wxWindow* m_dialogParent;
};
#endif
// _WX_COLORDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/button.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/button.h
// Purpose: wxButton class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_BUTTON_H_
#define _WX_OSX_BUTTON_H_
#include "wx/control.h"
#include "wx/gdicmn.h"
// Pushbutton
class WXDLLIMPEXP_CORE wxButton : public wxButtonBase
{
public:
wxButton() {}
wxButton(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
virtual void SetLabel(const wxString& label);
virtual wxWindow *SetDefault();
virtual void Command(wxCommandEvent& event);
// osx specific event handling common for all osx-ports
virtual bool OSXHandleClicked( double timestampsec );
#if wxOSX_USE_COCOA
void OSXUpdateAfterLabelChange(const wxString& label);
#endif
protected:
wxDECLARE_DYNAMIC_CLASS(wxButton);
};
#endif // _WX_OSX_BUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/textctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/textctrl.h
// Purpose: wxTextCtrl class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TEXTCTRL_H_
#define _WX_TEXTCTRL_H_
#if wxUSE_SYSTEM_OPTIONS
// set this to 'true' if you want to use the 'classic' MLTE-based implementation
// instead of the HIView-based implementation in 10.3 and upwards, the former
// has more features (backgrounds etc.), but may show redraw artefacts and other
// problems depending on your usage; hence, the default is 'false'.
#define wxMAC_TEXTCONTROL_USE_MLTE wxT("mac.textcontrol-use-mlte")
// set this to 'true' if you want editable text controls to have spell checking turned
// on by default, you can change this setting individually on a control using MacCheckSpelling
#define wxMAC_TEXTCONTROL_USE_SPELL_CHECKER wxT("mac.textcontrol-use-spell-checker")
#endif
#include "wx/control.h"
#include "wx/textctrl.h"
class WXDLLIMPEXP_CORE wxTextCtrl: public wxTextCtrlBase
{
wxDECLARE_DYNAMIC_CLASS(wxTextCtrl);
public:
wxTextCtrl()
{ Init(); }
wxTextCtrl(wxWindow *parent,
wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTextCtrlNameStr)
{
Init();
Create(parent, id, value, pos, size, style, validator, name);
}
virtual ~wxTextCtrl();
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTextCtrlNameStr);
// accessors
// ---------
virtual int GetLineLength(long lineNo) const wxOVERRIDE;
virtual wxString GetLineText(long lineNo) const wxOVERRIDE;
virtual int GetNumberOfLines() const wxOVERRIDE;
virtual bool IsModified() const wxOVERRIDE;
// operations
// ----------
// sets/clears the dirty flag
virtual void MarkDirty() wxOVERRIDE;
virtual void DiscardEdits() wxOVERRIDE;
// text control under some platforms supports the text styles: these
// methods apply the given text style to the given selection or to
// set/get the style which will be used for all appended text
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
virtual bool GetStyle(long position, wxTextAttr& style) wxOVERRIDE;
virtual bool SetStyle(long start, long end, const wxTextAttr& style) wxOVERRIDE;
virtual bool SetDefaultStyle(const wxTextAttr& style) wxOVERRIDE;
// translate between the position (which is just an index into the textctrl
// considering all its contents as a single strings) and (x, y) coordinates
// which represent column and line.
virtual long XYToPosition(long x, long y) const wxOVERRIDE;
virtual bool PositionToXY(long pos, long *x, long *y) const wxOVERRIDE;
virtual void ShowPosition(long pos) wxOVERRIDE;
// overrides so that we can send text updated events
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
// Implementation
// --------------
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool AcceptsFocus() const wxOVERRIDE;
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
// callbacks
void OnDropFiles(wxDropFilesEvent& event);
void OnChar(wxKeyEvent& event); // Process 'enter' if required
void OnKeyDown(wxKeyEvent& event); // Process clipboard shortcuts
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);
void OnContextMenu(wxContextMenuEvent& event);
virtual bool MacSetupCursor( const wxPoint& pt ) wxOVERRIDE;
virtual void MacVisibilityChanged() wxOVERRIDE;
virtual void MacSuperChangedPosition() wxOVERRIDE;
virtual void MacCheckSpelling(bool check);
void OSXEnableAutomaticQuoteSubstitution(bool enable);
void OSXEnableAutomaticDashSubstitution(bool enable);
void OSXDisableAllSmartSubstitutions();
protected:
// common part of all ctors
void Init();
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// flag is set to true when the user edits the controls contents
bool m_dirty;
virtual void EnableTextChangedEvents(bool WXUNUSED(enable)) wxOVERRIDE
{
// nothing to do here as the events are never generated when we change
// the controls value programmatically anyhow
}
private :
wxMenu *m_privateContextMenu;
wxDECLARE_EVENT_TABLE();
};
#endif // _WX_TEXTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/carbon/region.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/carbon/region.h
// Purpose: wxRegion class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_CARBON_REGION_H_
#define _WX_MAC_CARBON_REGION_H_
#include "wx/list.h"
class WXDLLIMPEXP_CORE wxRegion : public wxRegionWithCombine
{
public:
wxRegion() { }
wxRegion(long x, long y, long w, long h);
wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
wxRegion(const wxRect& rect);
wxRegion( WXHRGN hRegion );
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
virtual ~wxRegion();
// wxRegionBase methods
virtual void Clear();
virtual bool IsEmpty() const;
// Internal
WXHRGN GetWXHRGN() const ;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual bool DoIsEqual(const wxRegion& region) const;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const;
virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const;
virtual wxRegionContain DoContainsRect(const wxRect& rect) const;
virtual bool DoOffset(wxCoord x, wxCoord y);
virtual bool DoCombine(const wxRegion& region, wxRegionOp op);
virtual bool DoUnionWithRect(const wxRect& rect);
private:
wxDECLARE_DYNAMIC_CLASS(wxRegion);
friend class WXDLLIMPEXP_FWD_CORE wxRegionIterator;
};
class WXDLLIMPEXP_CORE wxRegionIterator : public wxObject
{
public:
wxRegionIterator();
wxRegionIterator(const wxRegion& region);
wxRegionIterator(const wxRegionIterator& iterator);
virtual ~wxRegionIterator();
wxRegionIterator& operator=(const wxRegionIterator& iterator);
void Reset() { m_current = 0; }
void Reset(const wxRegion& region);
operator bool () const { return m_current < m_numRects; }
bool HaveRects() const { return m_current < m_numRects; }
wxRegionIterator& operator++();
wxRegionIterator operator++(int);
long GetX() const;
long GetY() const;
long GetW() const;
long GetWidth() const { return GetW(); }
long GetH() const;
long GetHeight() const { return GetH(); }
wxRect GetRect() const { return wxRect((int)GetX(), (int)GetY(), (int)GetWidth(), (int)GetHeight()); }
private:
void SetRects(long numRects, wxRect *rects);
long m_current;
long m_numRects;
wxRegion m_region;
wxRect* m_rects;
wxDECLARE_DYNAMIC_CLASS(wxRegionIterator);
};
#endif // _WX_MAC_CARBON_REGION_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/carbon/private/overlay.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/carbon/private/overlay.h
// Purpose: wxOverlayImpl declaration
// Author: Stefan Csomor
// Modified by:
// Created: 2006-10-20
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_CARBON_PRIVATE_OVERLAY_H_
#define _WX_MAC_CARBON_PRIVATE_OVERLAY_H_
#include "wx/osx/private.h"
#include "wx/toplevel.h"
#include "wx/graphics.h"
class wxOverlayImpl
{
public:
wxOverlayImpl() ;
~wxOverlayImpl() ;
// clears the overlay without restoring the former state
// to be done eg when the window content has been changed and repainted
void Reset();
// returns true if it has been setup
bool IsOk();
void Init( wxDC* dc, int x , int y , int width , int height );
void BeginDrawing( wxDC* dc);
void EndDrawing( wxDC* dc);
void Clear( wxDC* dc);
private:
OSStatus CreateOverlayWindow();
void MacGetBounds( Rect *bounds );
WindowRef m_overlayWindow;
WindowRef m_overlayParentWindow;
CGContextRef m_overlayContext ;
// we store the window in case we would have to issue a Refresh()
wxWindow* m_window ;
int m_x ;
int m_y ;
int m_width ;
int m_height ;
} ;
#endif // _WX_MAC_CARBON_PRIVATE_OVERLAY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/carbon/private/print.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/carbon/private/print.h
// Purpose: private implementation for printing on OS X
// Author: Stefan Csomor
// Modified by:
// Created: 03/02/99
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_PRIVATE_PRINT_H_
#define _WX_MAC_PRIVATE_PRINT_H_
#include "wx/cmndata.h"
#include "wx/print.h"
// for PrintingManager
#include "ApplicationServices/ApplicationServices.h"
class WXDLLIMPEXP_CORE wxOSXPrintData : public wxPrintNativeDataBase
{
public:
wxOSXPrintData();
virtual ~wxOSXPrintData();
virtual bool TransferTo( wxPrintData &data );
virtual bool TransferFrom( const wxPrintData &data );
virtual bool IsOk() const ;
virtual void TransferFrom( const wxPageSetupDialogData * );
virtual void TransferTo( wxPageSetupDialogData * );
virtual void TransferFrom( const wxPrintDialogData * );
virtual void TransferTo( wxPrintDialogData * );
PMPrintSession GetPrintSession() { return m_macPrintSession; }
PMPageFormat GetPageFormat() { return m_macPageFormat; }
PMPrintSettings GetPrintSettings() { return m_macPrintSettings; }
protected :
virtual void TransferPrinterNameFrom( const wxPrintData &data );
virtual void TransferPaperInfoFrom( const wxPrintData &data );
virtual void TransferResolutionFrom( const wxPrintData &data );
virtual void TransferPrinterNameTo( wxPrintData &data );
virtual void TransferPaperInfoTo( wxPrintData &data );
virtual void TransferResolutionTo( wxPrintData &data );
virtual void UpdateFromPMState();
virtual void UpdateToPMState();
PMPrintSession m_macPrintSession ;
PMPageFormat m_macPageFormat ;
PMPrintSettings m_macPrintSettings ;
PMPaper m_macPaper;
private:
wxDECLARE_DYNAMIC_CLASS(wxOSXPrintData);
} ;
WXDLLIMPEXP_CORE wxPrintNativeDataBase* wxOSXCreatePrintData();
#if wxOSX_USE_COCOA
class WXDLLIMPEXP_CORE wxOSXCocoaPrintData : public wxOSXPrintData
{
public:
wxOSXCocoaPrintData();
virtual ~wxOSXCocoaPrintData();
WX_NSPrintInfo GetNSPrintInfo() { return m_macPrintInfo; }
protected:
virtual void UpdateFromPMState();
virtual void UpdateToPMState();
WX_NSPrintInfo m_macPrintInfo;
private:
wxDECLARE_DYNAMIC_CLASS(wxOSXCocoaPrintData);
} ;
#endif
#endif // _WX_MAC_PRIVATE_PRINT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/cfref.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/cfref.h
// Purpose: wxCFRef template class
// Author: David Elliott <[email protected]>
// Modified by: Stefan Csomor
// Created: 2007/05/10
// Copyright: (c) 2007 David Elliott <[email protected]>, Stefan Csomor
// Licence: wxWindows licence
// Notes: See http://developer.apple.com/documentation/CoreFoundation/Conceptual/CFMemoryMgmt/index.html
/////////////////////////////////////////////////////////////////////////////
/*! @header wx/osx/core/cfref.h
@abstract wxCFRef template class
@discussion FIXME: Convert doc tags to something less buggy with C++
*/
#ifndef _WX_MAC_COREFOUNDATION_CFREF_H__
#define _WX_MAC_COREFOUNDATION_CFREF_H__
// Include unistd to ensure that NULL is defined
#include <unistd.h>
// Include AvailabilityMacros for DEPRECATED_ATTRIBUTE
#include <AvailabilityMacros.h>
// #include <CoreFoundation/CFBase.h>
/* Don't include CFBase.h such that this header can be included from public
* headers with minimal namespace pollution.
* Note that Darwin CF uses extern for CF_EXPORT. If we need this on Win32
* or non-Darwin Mac OS we'll need to define the appropriate __declspec.
*/
typedef const void *CFTypeRef;
extern "C" {
extern /* CF_EXPORT */
CFTypeRef CFRetain(CFTypeRef cf);
extern /* CF_EXPORT */
void CFRelease(CFTypeRef cf);
} // extern "C"
/*! @function wxCFRelease
@abstract A CFRelease variant that checks for NULL before releasing.
@discussion The parameter is template not for type safety but to ensure the argument
is a raw pointer and not a ref holder of any type.
*/
template <class Type>
inline void wxCFRelease(Type *r)
{
if ( r != NULL )
::CFRelease((CFTypeRef)r);
}
/*! @function wxCFRetain
@abstract A typesafe CFRetain variant that checks for NULL.
*/
template <class Type>
inline Type* wxCFRetain(Type *r)
{
// NOTE(DE): Setting r to the result of CFRetain improves efficiency on both x86 and PPC
// Casting r to CFTypeRef ensures we are calling the real C version defined in CFBase.h
// and not any possibly templated/overloaded CFRetain.
if ( r != NULL )
r = (Type*)::CFRetain((CFTypeRef)r);
return r;
}
template <class refType>
class wxCFRef;
/*! @class wxCFWeakRef
@templatefield refType The CF reference type (e.g. CFStringRef, CFRunLoopRef, etc.)
It should already be a pointer. This is different from
shared_ptr where the template parameter is the pointee type.
@discussion Wraps a raw pointer without any retain or release.
Provides a way to get what amounts to a raw pointer from a wxCFRef without
using a raw pointer. Unlike a raw pointer, constructing a wxCFRef from this
class will cause it to be retained because it is assumed that a wxCFWeakRef
does not own its pointer.
*/
template <class refType>
class wxCFWeakRef
{
template <class refTypeA, class otherRefType>
friend wxCFWeakRef<refTypeA> static_cfref_cast(const wxCFRef<otherRefType> &otherRef);
public:
/*! @method wxCFWeakRef
@abstract Creates a NULL reference
*/
wxCFWeakRef()
: m_ptr(NULL)
{}
// Default copy constructor is fine.
// Default destructor is fine but we'll set NULL to avoid bugs
~wxCFWeakRef()
{ m_ptr = NULL; }
// Do not implement a raw-pointer constructor.
/*! @method wxCFWeakRef
@abstract Copies another ref holder where its type can be converted to ours
@templatefield otherRefType Any type held by another wxCFWeakRef.
@param otherRef The other weak ref holder to copy.
@discussion This is merely a copy or implicit cast.
*/
template <class otherRefType>
wxCFWeakRef(const wxCFWeakRef<otherRefType>& otherRef)
: m_ptr(otherRef.get()) // Implicit conversion from otherRefType to refType should occur
{}
/*! @method wxCFWeakRef
@abstract Copies a strong ref holder where its type can be converted to ours
@templatefield otherRefType Any type held by a wxCFRef.
@param otherRef The strong ref holder to copy.
@discussion This ref is merely a pointer copy, the strong ref still holds the pointer.
*/
template <class otherRefType>
wxCFWeakRef(const wxCFRef<otherRefType>& otherRef)
: m_ptr(otherRef.get()) // Implicit conversion from otherRefType to refType should occur
{}
/*! @method get
@abstract Explicit conversion to the underlying pointer type
@discussion Allows the caller to explicitly get the underlying pointer.
*/
refType get() const
{ return m_ptr; }
/*! @method operator refType
@abstract Implicit conversion to the underlying pointer type
@discussion Allows the ref to be used in CF function calls.
*/
operator refType() const
{ return m_ptr; }
protected:
/*! @method wxCFWeakRef
@abstract Constructs a weak reference to the raw pointer
@templatefield otherType Any type.
@param p The raw pointer to assume ownership of. May be NULL.
@discussion This method is private so that the friend static_cfref_cast can use it
*/
template <class otherType>
explicit wxCFWeakRef(otherType *p)
: m_ptr(p) // Implicit conversion from otherType* to refType should occur.
{}
/*! @var m_ptr The raw pointer.
*/
refType m_ptr;
};
/*! @class wxCFRef
@templatefield refType The CF reference type (e.g. CFStringRef, CFRunLoopRef, etc.)
It should already be a pointer. This is different from
shared_ptr where the template parameter is the pointee type.
@discussion Properly retains/releases reference to CoreFoundation objects
*/
template <class refType>
class wxCFRef
{
public:
/*! @method wxCFRef
@abstract Creates a NULL reference
*/
wxCFRef()
: m_ptr(NULL)
{}
/*! @method wxCFRef
@abstract Assumes ownership of p and creates a reference to it.
@param p The raw core foundation reference to assume ownership of. May be NULL.
@discussion Like shared_ptr, it is assumed that the caller has a strong reference to p and intends
to transfer ownership of that reference to this ref holder. If the object comes from
a Create or Copy method then this is the correct behaviour. If the object comes from
a Get method then you must CFRetain it yourself before passing it to this constructor.
A handy way to do this is to use the non-member wxCFRefFromGet factory function.
*/
wxCFRef(refType p) : m_ptr(p)
{
}
/*! @method wxCFRef
@abstract Assumes ownership of p and creates a reference to it.
@templatefield otherType Any type.
@param p The raw pointer to assume ownership of. May be NULL.
@discussion Like shared_ptr, it is assumed that the caller has a strong reference to p and intends
to transfer ownership of that reference to this ref holder. If the object comes from
a Create or Copy method then this is the correct behaviour. If the object comes from
a Get method then you must CFRetain it yourself before passing it to this constructor.
A handy way to do this is to use the non-member wxCFRefFromGet factory function.
This method is templated and takes an otherType *p. This prevents implicit conversion
using an operator refType() in a different ref-holding class type.
*/
template <class otherType>
explicit wxCFRef(otherType *p)
: m_ptr(p) // Implicit conversion from otherType* to refType should occur.
{}
/*! @method wxCFRef
@abstract Copies a ref holder of the same type
@param otherRef The other ref holder to copy.
@discussion Ownership will be shared by the original ref and the newly created ref. That is,
the object will be explicitly retained by this new ref.
*/
wxCFRef(const wxCFRef& otherRef)
: m_ptr(wxCFRetain(otherRef.m_ptr))
{}
/*! @method wxCFRef
@abstract Copies a ref holder where its type can be converted to ours
@templatefield otherRefType Any type held by another wxCFRef.
@param otherRef The other ref holder to copy.
@discussion Ownership will be shared by the original ref and the newly created ref. That is,
the object will be explicitly retained by this new ref.
*/
template <class otherRefType>
wxCFRef(const wxCFRef<otherRefType>& otherRef)
: m_ptr(wxCFRetain(otherRef.get())) // Implicit conversion from otherRefType to refType should occur
{}
/*! @method wxCFRef
@abstract Copies a weak ref holder where its type can be converted to ours
@templatefield otherRefType Any type held by a wxCFWeakRef.
@param otherRef The weak ref holder to copy.
@discussion Ownership will be taken by this newly created ref. That is,
the object will be explicitly retained by this new ref.
Ownership is most likely shared with some other ref as well.
*/
template <class otherRefType>
wxCFRef(const wxCFWeakRef<otherRefType>& otherRef)
: m_ptr(wxCFRetain(otherRef.get())) // Implicit conversion from otherRefType to refType should occur
{}
/*! @method ~wxCFRef
@abstract Releases (potentially shared) ownership of the ref.
@discussion A ref holder instance is always assumed to have ownership so ownership is always
released (CFRelease called) upon destruction.
*/
~wxCFRef()
{ reset(); }
/*! @method operator=
@abstract Assigns the other ref's pointer to us when the otherRef is the same type.
@param otherRef The other ref holder to copy.
@discussion The incoming pointer is retained, the original pointer is released, and this object
is made to point to the new pointer.
*/
wxCFRef& operator=(const wxCFRef& otherRef)
{
if (this != &otherRef)
{
wxCFRetain(otherRef.m_ptr);
wxCFRelease(m_ptr);
m_ptr = otherRef.m_ptr;
}
return *this;
}
/*! @method operator=
@abstract Assigns the other ref's pointer to us when the other ref can be converted to our type.
@templatefield otherRefType Any type held by another wxCFRef
@param otherRef The other ref holder to copy.
@discussion The incoming pointer is retained, the original pointer is released, and this object
is made to point to the new pointer.
*/
template <class otherRefType>
wxCFRef& operator=(const wxCFRef<otherRefType>& otherRef)
{
wxCFRetain(otherRef.get());
wxCFRelease(m_ptr);
m_ptr = otherRef.get(); // Implicit conversion from otherRefType to refType should occur
return *this;
}
/*! @method get
@abstract Explicit conversion to the underlying pointer type
@discussion Allows the caller to explicitly get the underlying pointer.
*/
refType get() const
{ return m_ptr; }
/*! @method operator refType
@abstract Implicit conversion to the underlying pointer type
@discussion Allows the ref to be used in CF function calls.
*/
operator refType() const
{ return m_ptr; }
#if 0
< // HeaderDoc is retarded and thinks the GT from operator-> is part of a template param.
// So give it that < outside of a comment to fake it out. (if 0 is not a comment to HeaderDoc)
#endif
/*! @method operator->
@abstract Implicit conversion to the underlying pointer type
@discussion This is nearly useless for CF types which are nearly always opaque
*/
refType operator-> () const
{ return m_ptr; }
/*! @method reset
@abstract Nullifies the reference
@discussion Releases ownership (calls CFRelease) before nullifying the pointer.
*/
void reset()
{
wxCFRelease(m_ptr);
m_ptr = NULL;
}
/*! @method reset
@abstract Sets this to a new reference
@templatefield otherType Any type.
@param p The raw pointer to assume ownership of
@discussion The existing reference is released (like destruction). It is assumed that the caller
has a strong reference to the new p and intends to transfer ownership of that reference
to this ref holder. Take care to call CFRetain if you received the object from a Get method.
This method is templated and takes an otherType *p. This prevents implicit conversion
using an operator refType() in a different ref-holding class type.
*/
template <class otherType>
void reset(otherType* p)
{
wxCFRelease(m_ptr);
m_ptr = p; // Automatic conversion should occur
}
// Release the pointer, i.e. give up its ownership.
refType release()
{
refType p = m_ptr;
m_ptr = NULL;
return p;
}
protected:
/*! @var m_ptr The raw pointer.
*/
refType m_ptr;
};
/*! @function wxCFRefFromGet
@abstract Factory function to create wxCFRef from a raw pointer obtained from a Get-rule function
@param p The pointer to retain and create a wxCFRef from. May be NULL.
@discussion Unlike the wxCFRef raw pointer constructor, this function explicitly retains its
argument. This can be used for functions such as CFDictionaryGetValue() or
CFAttributedStringGetString() which return a temporary reference (Get-rule functions).
FIXME: Anybody got a better name?
*/
template <typename Type>
inline wxCFRef<Type*> wxCFRefFromGet(Type *p)
{
return wxCFRef<Type*>(wxCFRetain(p));
}
/*! @function static_cfref_cast
@abstract Works like static_cast but with a wxCFRef as the argument.
@param refType Template parameter. The destination raw pointer type
@param otherRef Normal parameter. The source wxCFRef<> object.
@discussion This is intended to be a clever way to make static_cast work while allowing
the return value to be converted to either a strong ref or a raw pointer
while ensuring that the retain count is updated appropriately.
This is modeled after shared_ptr's static_pointer_cast. Just as wxCFRef is
parameterized on a pointer to an opaque type so is this class. Note that
this differs from shared_ptr which is parameterized on the pointee type.
FIXME: Anybody got a better name?
*/
template <class refType, class otherRefType>
inline wxCFWeakRef<refType> static_cfref_cast(const wxCFRef<otherRefType> &otherRef);
template <class refType, class otherRefType>
inline wxCFWeakRef<refType> static_cfref_cast(const wxCFRef<otherRefType> &otherRef)
{
return wxCFWeakRef<refType>(static_cast<refType>(otherRef.get()));
}
/*! @function CFRelease
@abstract Overloads CFRelease so that the user is warned of bad behaviour.
@discussion It is rarely appropriate to retain or release a wxCFRef. If one absolutely
must do it he can explicitly get() the raw pointer
Normally, this function is unimplemented resulting in a linker error if used.
*/
template <class T>
inline void CFRelease(const wxCFRef<T*> & cfref) DEPRECATED_ATTRIBUTE;
/*! @function CFRetain
@abstract Overloads CFRetain so that the user is warned of bad behaviour.
@discussion It is rarely appropriate to retain or release a wxCFRef. If one absolutely
must do it he can explicitly get() the raw pointer
Normally, this function is unimplemented resulting in a linker error if used.
*/
template <class T>
inline void CFRetain(const wxCFRef<T*>& cfref) DEPRECATED_ATTRIBUTE;
// Change the 0 to a 1 if you want the functions to work (no link errors)
// Neither function will cause retain/release side-effects if implemented.
#if 0
template <class T>
void CFRelease(const wxCFRef<T*> & cfref)
{
CFRelease(cfref.get());
}
template <class T>
void CFRetain(const wxCFRef<T*> & cfref)
{
CFRetain(cfref.get());
}
#endif
#endif //ndef _WX_MAC_COREFOUNDATION_CFREF_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/cftype.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/cftype.h
// Purpose: wxCFDictionaryRef class
// Author: Stefan Csomor
// Modified by:
// Created: 2018/07/27
// Copyright: (c) 2018 Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*! @header wx/osx/core/cftype.h
@abstract wxCFTypeRef class and derived classes
*/
#ifndef _WX_OSX_COREFOUNDATION_CFTYPEREF_H__
#define _WX_OSX_COREFOUNDATION_CFTYPEREF_H__
#include "wx/osx/core/cfref.h"
#include "wx/osx/core/cfstring.h"
#ifndef WX_PRECOMP
#include "wx/string.h"
#endif
class wxCFTypeRef : public wxCFRef<CFTypeRef>
{
public:
typedef wxCFRef<CFTypeRef> super_type;
wxCFTypeRef(CFTypeRef d)
: super_type(d)
{
}
template <typename V>
bool GetValue(V* ptr) const;
template <typename V>
bool GetValue(V* ptr, V defaultValue) const
{
bool hasKey = GetValue(ptr);
if (!hasKey)
*ptr = defaultValue;
return hasKey;
}
template <typename V>
bool GetValue(V& ref) const
{
return GetValue(&ref);
}
template <typename V>
bool GetValue(V& ref, V defaultValue) const
{
bool hasKey = GetValue(ref);
if (!hasKey)
ref = defaultValue;
return hasKey;
}
// spezialization through overload
bool GetValue(CGFloat* ptr) const
{
if (m_ptr)
CFNumberGetValue((CFNumberRef)m_ptr, kCFNumberCGFloatType, ptr);
return m_ptr;
}
bool GetValue(int32_t* ptr) const
{
if (m_ptr)
CFNumberGetValue((CFNumberRef)m_ptr, kCFNumberSInt32Type, ptr);
return m_ptr;
}
bool GetValue(uint32_t* ptr) const
{
if (m_ptr)
CFNumberGetValue((CFNumberRef)m_ptr, kCFNumberSInt32Type, ptr);
return m_ptr;
}
bool GetValue(int64_t* ptr) const
{
if (m_ptr)
CFNumberGetValue((CFNumberRef)m_ptr, kCFNumberSInt64Type, ptr);
return m_ptr;
}
bool GetValue(uint64_t* ptr) const
{
if (m_ptr)
CFNumberGetValue((CFNumberRef)m_ptr, kCFNumberSInt64Type, ptr);
return m_ptr;
}
bool GetValue(wxString* s) const
{
if (m_ptr)
*s = wxCFStringRef::AsString((CFStringRef)m_ptr);
return m_ptr;
}
};
class wxCFNumberRef : public wxCFTypeRef
{
public:
wxCFNumberRef(CGFloat v)
: wxCFTypeRef(CFNumberCreate(NULL, kCFNumberCGFloatType, &v))
{
}
wxCFNumberRef(int v)
: wxCFTypeRef(CFNumberCreate(NULL, kCFNumberIntType, &v))
{
}
};
#endif //ifndef _WX_OSX_COREFOUNDATION_CFTYPEREF_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/cfstring.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/cfstring.h
// Purpose: wxCFStringRef and other string functions
// Author: Stefan Csomor
// Modified by:
// Created: 2004-10-29 (from code in wx/mac/carbon/private.h)
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
// Usage: Darwin (base library)
/////////////////////////////////////////////////////////////////////////////
#ifndef __WX_CFSTRINGHOLDER_H__
#define __WX_CFSTRINGHOLDER_H__
#include <CoreFoundation/CFString.h>
#include "wx/dlimpexp.h"
#include "wx/fontenc.h"
#include "wx/osx/core/cfref.h"
#ifdef WORDS_BIGENDIAN
#define kCFStringEncodingUTF32Native kCFStringEncodingUTF32BE
#else
#define kCFStringEncodingUTF32Native kCFStringEncodingUTF32LE
#endif
class WXDLLIMPEXP_FWD_BASE wxString;
WXDLLIMPEXP_BASE wxString wxMacConvertNewlines13To10(const wxString& data);
WXDLLIMPEXP_BASE wxString wxMacConvertNewlines10To13(const wxString& data);
WXDLLIMPEXP_BASE wxUint32 wxMacGetSystemEncFromFontEnc(wxFontEncoding encoding) ;
WXDLLIMPEXP_BASE wxFontEncoding wxMacGetFontEncFromSystemEnc(wxUint32 encoding) ;
WXDLLIMPEXP_BASE void wxMacWakeUp() ;
class WXDLLIMPEXP_BASE wxCFStringRef : public wxCFRef< CFStringRef >
{
public:
wxCFStringRef()
{
}
wxCFStringRef(const wxString &str,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT) ;
#ifdef __WXMAC__
wxCFStringRef(NSString* ref)
: wxCFRef< CFStringRef >((CFStringRef) ref)
{
}
#endif
wxCFStringRef(CFStringRef ref)
: wxCFRef< CFStringRef >(ref)
{
}
wxCFStringRef(const wxCFStringRef& otherRef )
: wxCFRef< CFStringRef >(otherRef)
{
}
~wxCFStringRef()
{
}
wxString AsString( wxFontEncoding encoding = wxFONTENCODING_DEFAULT ) const;
static wxString AsString( CFStringRef ref, wxFontEncoding encoding = wxFONTENCODING_DEFAULT ) ;
static wxString AsStringWithNormalizationFormC( CFStringRef ref, wxFontEncoding encoding = wxFONTENCODING_DEFAULT ) ;
#ifdef __WXMAC__
static wxString AsString( NSString* ref, wxFontEncoding encoding = wxFONTENCODING_DEFAULT ) ;
static wxString AsStringWithNormalizationFormC( NSString* ref, wxFontEncoding encoding = wxFONTENCODING_DEFAULT ) ;
NSString* AsNSString() const { return (NSString*)(CFStringRef) *this; }
#endif
private:
} ;
// corresponding class for holding UniChars (native unicode characters)
class WXDLLIMPEXP_BASE wxMacUniCharBuffer
{
public :
wxMacUniCharBuffer( const wxString &str ) ;
~wxMacUniCharBuffer() ;
UniCharPtr GetBuffer() ;
UniCharCount GetChars() ;
private :
UniCharPtr m_ubuf ;
UniCharCount m_chars ;
};
#endif //__WXCFSTRINGHOLDER_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/objcid.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/objcid.h
// Purpose: Define wxObjCID working in both C++ and Objective-C.
// Author: Vadim Zeitlin
// Created: 2012-05-20
// Copyright: (c) 2012 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_CORE_OBJCID_H_
#define _WX_OSX_CORE_OBJCID_H_
// ----------------------------------------------------------------------------
// wxObjCID: Equivalent of Objective-C "id" that works in C++ code.
// ----------------------------------------------------------------------------
#ifdef __OBJC__
#define wxObjCID id
#else
typedef struct objc_object* wxObjCID;
#endif
#endif // _WX_OSX_CORE_OBJCID_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/evtloop.h
// Purpose: CoreFoundation-based event loop
// Author: Vadim Zeitlin
// Modified by:
// Created: 2006-01-12
// Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_CORE_EVTLOOP_H_
#define _WX_OSX_CORE_EVTLOOP_H_
DECLARE_WXOSX_OPAQUE_CFREF( CFRunLoop )
DECLARE_WXOSX_OPAQUE_CFREF( CFRunLoopObserver )
class WXDLLIMPEXP_FWD_BASE wxCFEventLoopPauseIdleEvents;
class WXDLLIMPEXP_BASE wxCFEventLoop : public wxEventLoopBase
{
friend class wxCFEventLoopPauseIdleEvents;
public:
wxCFEventLoop();
virtual ~wxCFEventLoop();
// sets the "should exit" flag and wakes up the loop so that it terminates
// soon
virtual void ScheduleExit(int rc = 0);
// return true if any events are available
virtual bool Pending() const;
// dispatch a single event, return false if we should exit from the loop
virtual bool Dispatch();
// same as Dispatch() but doesn't wait for longer than the specified (in
// ms) timeout, return true if an event was processed, false if we should
// exit the loop or -1 if timeout expired
virtual int DispatchTimeout(unsigned long timeout);
// implement this to wake up the loop: usually done by posting a dummy event
// to it (can be called from non main thread)
virtual void WakeUp();
bool ShouldProcessIdleEvents() const { return m_processIdleEvents ; }
#if wxUSE_UIACTIONSIMULATOR
// notifies Yield and Dispatch to wait for at least one event before
// returning, this is necessary, because the synthesized events need to be
// converted by the OS before being available on the native event queue
void SetShouldWaitForEvent(bool should) { m_shouldWaitForEvent = should; }
#endif
protected:
// enters a loop calling OnNextIteration(), Pending() and Dispatch() and
// terminating when Exit() is called
virtual int DoRun();
// may be overridden to perform some action at the start of each new event
// loop iteration
virtual void OnNextIteration() {}
virtual void DoYieldFor(long eventsToProcess);
void CommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity);
void DefaultModeObserverCallBack(CFRunLoopObserverRef observer, int activity);
// set to false to avoid idling at unexpected moments - eg when having native message boxes
void SetProcessIdleEvents(bool process) { m_processIdleEvents = process; }
static void OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info);
static void OSXDefaultModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info);
// get the currently executing CFRunLoop
virtual CFRunLoopRef CFGetCurrentRunLoop() const;
virtual int DoDispatchTimeout(unsigned long timeout);
virtual void OSXDoRun();
virtual void OSXDoStop();
// the loop exit code
int m_exitcode;
// cfrunloop
CFRunLoopRef m_runLoop;
// common modes runloop observer
CFRunLoopObserverRef m_commonModeRunLoopObserver;
// default mode runloop observer
CFRunLoopObserverRef m_defaultModeRunLoopObserver;
// set to false to avoid idling at unexpected moments - eg when having native message boxes
bool m_processIdleEvents;
#if wxUSE_UIACTIONSIMULATOR
bool m_shouldWaitForEvent;
#endif
private:
// process all already pending events and dispatch a new one (blocking
// until it appears in the event queue if necessary)
//
// returns the return value of DoDispatchTimeout()
int DoProcessEvents();
wxDECLARE_NO_COPY_CLASS(wxCFEventLoop);
};
class WXDLLIMPEXP_BASE wxCFEventLoopPauseIdleEvents : public wxObject
{
public:
wxCFEventLoopPauseIdleEvents();
virtual ~wxCFEventLoopPauseIdleEvents();
private:
bool m_formerState;
};
#endif // _WX_OSX_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/colour.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/colour.h
// Purpose: wxColour class
// Author: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COLOUR_H_
#define _WX_COLOUR_H_
#include "wx/object.h"
#include "wx/string.h"
#include "wx/osx/core/cfref.h"
struct RGBColor;
// Colour
class WXDLLIMPEXP_CORE wxColour: public wxColourBase
{
public:
// constructors
// ------------
DEFINE_STD_WXCOLOUR_CONSTRUCTORS
// default copy ctor and dtor are ok
// accessors
virtual ChannelType Red() const wxOVERRIDE;
virtual ChannelType Green() const wxOVERRIDE;
virtual ChannelType Blue() const wxOVERRIDE;
virtual ChannelType Alpha() const wxOVERRIDE;
virtual bool IsSolid() const wxOVERRIDE;
wxColour& operator=(const wxColour& col);
// comparison
bool operator == (const wxColour& colour) const;
bool operator != (const wxColour& colour) const { return !(*this == colour); }
// CoreGraphics CGColor
// --------------------
// This ctor does take ownership of the color.
wxColour( CGColorRef col );
// don't take ownership of the returned value
CGColorRef GetCGColor() const;
// do take ownership of the returned value
CGColorRef CreateCGColor() const { return wxCFRetain(GetCGColor()); }
#if wxOSX_USE_COCOA_OR_CARBON
// Quickdraw RGBColor
// ------------------
wxColour(const RGBColor& col);
void GetRGBColor( RGBColor *col ) const;
#endif
#if wxOSX_USE_COCOA
// NSColor Cocoa
// -------------
// This ctor does not take ownership of the color.
explicit wxColour(WX_NSColor color);
WX_NSColor OSXGetNSColor() const;
#endif
protected :
virtual void
InitRGBA(ChannelType r, ChannelType g, ChannelType b, ChannelType a) wxOVERRIDE;
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxColour);
};
class wxColourRefData : public wxGDIRefData
{
public:
wxColourRefData() {}
virtual ~wxColourRefData() {}
virtual CGFloat Red() const = 0;
virtual CGFloat Green() const = 0;
virtual CGFloat Blue() const = 0;
virtual CGFloat Alpha() const = 0;
virtual bool IsSolid() const
{ return true; }
virtual CGColorRef GetCGColor() const = 0;
virtual wxColourRefData* Clone() const = 0;
#if wxOSX_USE_COCOA
virtual WX_NSColor GetNSColor() const;
#endif
};
#endif
// _WX_COLOUR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/hid.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/hid.h
// Purpose: DARWIN HID layer for WX
// Author: Ryan Norton
// Modified by:
// Created: 11/11/2003
// Copyright: (c) Ryan Norton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ===========================================================================
// declarations
// ===========================================================================
// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
#ifndef _WX_MACCARBONHID_H_
#define _WX_MACCARBONHID_H_
#include "wx/defs.h"
#include "wx/string.h"
//Mac OSX only
#ifdef __DARWIN__
#include <IOKit/IOKitLib.h>
#include <IOKit/IOCFPlugIn.h>
#include <IOKit/hid/IOHIDLib.h>
#include <IOKit/hid/IOHIDKeys.h>
#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
//Darn apple - doesn't properly wrap their headers in extern "C"!
//http://www.macosx.com/forums/archive/index.php/t-68069.html
extern "C" {
#include <mach/mach_port.h>
}
#include <mach/mach.h> //this actually includes mach_port.h (see above)
// ===========================================================================
// definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// wxHIDDevice
//
// A wrapper around OS X HID Manager procedures.
// The tutorial "Working With HID Class Device Interfaces" Is
// Quite good, as is the sample program associated with it
// (Depite the author's protests!).
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxHIDDevice
{
public:
wxHIDDevice() : m_ppDevice(NULL), m_ppQueue(NULL), m_pCookies(NULL) {}
bool Create (int nClass = -1, int nType = -1, int nDev = 1);
static size_t GetCount(int nClass = -1, int nType = -1);
void AddCookie(CFTypeRef Data, int i);
void AddCookieInQueue(CFTypeRef Data, int i);
void InitCookies(size_t dwSize, bool bQueue = false);
//Must be implemented by derived classes
//builds the cookie array -
//first call InitCookies to initialize the cookie
//array, then AddCookie to add a cookie at a certain point in an array
virtual void BuildCookies(CFArrayRef Array) = 0;
//checks to see whether the cookie at nIndex is active (element value != 0)
bool IsActive(int nIndex);
//checks to see whether an element in the internal cookie array
//exists
bool HasElement(int nIndex);
//closes the device and cleans the queue and cookies
virtual ~wxHIDDevice();
protected:
IOHIDDeviceInterface** m_ppDevice; //this, essentially
IOHIDQueueInterface** m_ppQueue; //queue (if we want one)
IOHIDElementCookie* m_pCookies; //cookies
wxString m_szProductName; //product name
int m_nProductId; //product id
int m_nManufacturerId; //manufacturer id
mach_port_t m_pPort; //mach port to use
};
// ---------------------------------------------------------------------------
// wxHIDKeyboard
//
// Semi-simple implementation that opens a connection to the first
// keyboard of the machine. Used in wxGetKeyState.
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxHIDKeyboard : public wxHIDDevice
{
public:
static int GetCount();
bool Create(int nDev = 1);
void AddCookie(CFTypeRef Data, int i);
virtual void BuildCookies(CFArrayRef Array);
void DoBuildCookies(CFArrayRef Array);
};
#endif //__DARWIN__
#endif
// _WX_MACCARBONHID_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/cfdataref.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/cfdataref.h
// Purpose: wxCFDataRef class
// Author: Stefan Csomor
// Modified by:
// Created: 2007/05/10
// Copyright: (c) 2007 Stefan Csomor
// Licence: wxWindows licence
// Notes: See http://developer.apple.com/documentation/CoreFoundation/Conceptual/CFBinaryData/index.html
/////////////////////////////////////////////////////////////////////////////
/*! @header wx/osx/core/cfdataref.h
@abstract wxCFDataRef template class
*/
#ifndef _WX_MAC_COREFOUNDATION_CFDATAREF_H__
#define _WX_MAC_COREFOUNDATION_CFDATAREF_H__
#include "wx/osx/core/cfref.h"
#include <CoreFoundation/CFData.h>
/*! @class wxCFDataRef
@discussion Properly retains/releases reference to CoreFoundation data objects
*/
class wxCFDataRef : public wxCFRef< CFDataRef >
{
public:
/*! @method wxCFDataRef
@abstract Creates a NULL data ref
*/
wxCFDataRef()
{}
typedef wxCFRef<CFDataRef> super_type;
/*! @method wxCFDataRef
@abstract Assumes ownership of r and creates a reference to it.
@param r The data reference to assume ownership of. May be NULL.
@discussion Like shared_ptr, it is assumed that the caller has a strong reference to r and intends
to transfer ownership of that reference to this ref holder. If the object comes from
a Create or Copy method then this is the correct behaviour. If the object comes from
a Get method then you must CFRetain it yourself before passing it to this constructor.
A handy way to do this is to use the non-member wxCFRefFromGet factory function.
This method is templated and takes an otherType *p. This prevents implicit conversion
using an operator refType() in a different ref-holding class type.
*/
explicit wxCFDataRef(CFDataRef r)
: super_type(r)
{}
/*! @method wxCFDataRef
@abstract Copies a ref holder of the same type
@param otherRef The other ref holder to copy.
@discussion Ownership will be shared by the original ref and the newly created ref. That is,
the object will be explicitly retained by this new ref.
*/
wxCFDataRef(const wxCFDataRef& otherRef)
: super_type( otherRef )
{}
/*! @method wxCFDataRef
@abstract Copies raw data into a data ref
@param data The raw data.
@param length The data length.
*/
wxCFDataRef(const UInt8* data, CFIndex length)
: super_type(CFDataCreate(kCFAllocatorDefault, data, length))
{
}
/*! @method GetLength
@abstract returns the length in bytes of the data stored
*/
CFIndex GetLength() const
{
if ( m_ptr )
return CFDataGetLength( *this );
else
return 0;
}
/*! @method GetBytes
@abstract Copies the data into an external buffer
@param range The desired range.
@param buffer The target buffer.
*/
void GetBytes( CFRange range, UInt8 *buffer ) const
{
if ( m_ptr )
CFDataGetBytes(m_ptr, range, buffer);
}
};
#endif //ifndef _WX_MAC_COREFOUNDATION_CFDATAREF_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/cfdictionary.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/cfdictionaryref.h
// Purpose: wxCFDictionaryRef class
// Author: Stefan Csomor
// Modified by:
// Created: 2018/07/27
// Copyright: (c) 2018 Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*! @header wx/osx/core/cfdictionaryref.h
@abstract wxCFDictionaryRef class
*/
#ifndef _WX_OSX_COREFOUNDATION_CFDICTIONARYREF_H__
#define _WX_OSX_COREFOUNDATION_CFDICTIONARYREF_H__
#include "wx/osx/core/cfref.h"
#include "wx/osx/core/cfstring.h"
#include "wx/osx/core/cftype.h"
#include <CoreFoundation/CFDictionary.h>
/*! @class wxCFDictionaryRef
@discussion Properly retains/releases reference to CoreFoundation data objects
*/
template <typename T>
class wxCFDictionaryRefCommon : public wxCFRef<T>
{
public:
typedef wxCFRef<T> super_type;
explicit wxCFDictionaryRefCommon()
: super_type()
{
}
/*! @method wxCFDictionaryRef
@abstract Assumes ownership of r and creates a reference to it.
@param r The dictionary reference to assume ownership of. May be NULL.
@discussion Like shared_ptr, it is assumed that the caller has a strong reference to r and intends
to transfer ownership of that reference to this ref holder. If the object comes from
a Create or Copy method then this is the correct behaviour. If the object comes from
a Get method then you must CFRetain it yourself before passing it to this constructor.
A handy way to do this is to use the non-member wxCFRefFromGet factory function.
This method is templated and takes an otherType *p. This prevents implicit conversion
using an operator refType() in a different ref-holding class type.
*/
explicit wxCFDictionaryRefCommon(T r)
: super_type(r)
{
}
/*! @method wxCFDictionaryRef
@abstract Copies a ref holder of the same type
@param otherRef The other ref holder to copy.
@discussion Ownership will be shared by the original ref and the newly created ref. That is,
the object will be explicitly retained by this new ref.
*/
wxCFDictionaryRefCommon(const wxCFDictionaryRefCommon& otherRef)
: super_type(otherRef)
{
}
wxCFTypeRef GetValue(const void* key)
{
CFTypeRef val = CFDictionaryGetValue(this->m_ptr, key);
if (val)
::CFRetain(val);
return val;
}
};
class wxCFMutableDictionaryRef;
class wxCFDictionaryRef : public wxCFDictionaryRefCommon<CFDictionaryRef>
{
public:
wxCFDictionaryRef()
{
}
wxCFDictionaryRef(CFDictionaryRef r)
: wxCFDictionaryRefCommon(r)
{
}
wxCFDictionaryRef& operator=(const wxCFMutableDictionaryRef& other);
CFDictionaryRef CreateCopy() const
{
return CFDictionaryCreateCopy(kCFAllocatorDefault, this->m_ptr);
}
CFMutableDictionaryRef CreateMutableCopy() const
{
return CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, this->m_ptr);
}
};
class wxCFMutableDictionaryRef : public wxCFDictionaryRefCommon<CFMutableDictionaryRef>
{
public:
wxCFMutableDictionaryRef()
: wxCFDictionaryRefCommon(CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks))
{
}
wxCFMutableDictionaryRef(CFMutableDictionaryRef r)
: wxCFDictionaryRefCommon(r)
{
}
void SetValue(const void* key, const void* data)
{
CFDictionarySetValue(this->m_ptr, key, data);
}
void SetValue(const void* key, CGFloat v)
{
SetValue(key, wxCFNumberRef(v));
}
CFMutableDictionaryRef CreateCopy() const
{
return CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, this->m_ptr);
}
friend class wxCFDictionaryRef;
};
inline wxCFDictionaryRef& wxCFDictionaryRef::operator=(const wxCFMutableDictionaryRef& otherRef)
{
wxCFRetain(otherRef.m_ptr);
wxCFRelease(m_ptr);
m_ptr = (CFDictionaryRef)otherRef.m_ptr;
return *this;
}
#endif //ifndef _WX_OSX_COREFOUNDATION_CFDICTIONARYREF_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/dataview.h |
/////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/dataview.h
// Purpose: wxDataViewCtrl native implementation header for OSX
// Author:
// Copyright: (c) 2009
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DATAVIEWCTRL_CORE_H_
#define _WX_DATAVIEWCTRL_CORE_H_
#include "wx/dataview.h"
typedef wxWidgetImpl wxWidgetImplType;
// ---------------------------------------------------------
// Helper functions for dataview implementation on OSX
// ---------------------------------------------------------
wxWidgetImplType* CreateDataView(wxWindowMac* wxpeer, wxWindowMac* parent, wxWindowID id,
wxPoint const& pos, wxSize const& size,
long style, long extraStyle);
wxString ConcatenateDataViewItemValues(wxDataViewCtrl const* dataViewCtrlPtr, wxDataViewItem const& dataViewItem); // concatenates all data of the visible columns of the passed control
// and item TAB separated into a string and returns it
// ---------------------------------------------------------
// wxDataViewWidgetImpl
// Common interface of the native dataview implementation
// for the carbon and cocoa environment.
// ATTENTION
// All methods assume that the passed column pointers are
// valid (unless a NULL pointer is explicitly allowed
// to be passed)!
// ATTENTION
// ---------------------------------------------------------
class WXDLLIMPEXP_CORE wxDataViewWidgetImpl
{
public:
//
// constructors / destructor
//
virtual ~wxDataViewWidgetImpl(void)
{
}
//
// column related methods
//
virtual bool ClearColumns (void) = 0; // deletes all columns in the native control
virtual bool DeleteColumn (wxDataViewColumn* columnPtr) = 0; // deletes the column in the native control
virtual void DoSetExpanderColumn(wxDataViewColumn const* columnPtr) = 0; // sets the disclosure column in the native control
virtual wxDataViewColumn* GetColumn (unsigned int pos) const = 0; // returns the column belonging to 'pos' in the native control
virtual int GetColumnPosition (wxDataViewColumn const* columnPtr) const = 0; // returns the position of the passed column in the native control
virtual bool InsertColumn (unsigned int pos, wxDataViewColumn* columnPtr) = 0; // inserts a column at pos in the native control;
// the method can assume that the column's owner is already set
virtual void FitColumnWidthToContent(unsigned int pos) = 0; // resizes column to fit its content
//
// item related methods
//
virtual bool Add (wxDataViewItem const& parent, wxDataViewItem const& item) = 0; // adds an item to the native control
virtual bool Add (wxDataViewItem const& parent, wxDataViewItemArray const& itesm) = 0; // adds a items to the native control
virtual void Collapse (wxDataViewItem const& item) = 0; // collapses the passed item in the native control
virtual void EnsureVisible(wxDataViewItem const& item, wxDataViewColumn const* columnPtr) = 0; // ensures that the passed item's value in the passed column is visible (column pointer can be NULL)
virtual unsigned int GetCount (void) const = 0; // returns the number of items in the native control
virtual int GetCountPerPage(void) const = 0; // get number of items that fit into a single page
virtual wxRect GetRectangle (wxDataViewItem const& item, wxDataViewColumn const* columnPtr) = 0; // returns the rectangle that is used by the passed item and column in the native control
virtual wxDataViewItem GetTopItem (void) const = 0; // get top-most visible item
virtual bool IsExpanded (wxDataViewItem const& item) const = 0; // checks if the passed item is expanded in the native control
virtual bool Reload (void) = 0; // clears the native control and reloads all data
virtual bool Remove (wxDataViewItem const& parent, wxDataViewItem const& item) = 0; // removes an item from the native control
virtual bool Remove (wxDataViewItem const& parent, wxDataViewItemArray const& item) = 0; // removes items from the native control
virtual bool Update (wxDataViewColumn const* columnPtr) = 0; // updates the items in the passed column of the native control
virtual bool Update (wxDataViewItem const& parent, wxDataViewItem const& item) = 0; // updates the passed item in the native control
virtual bool Update (wxDataViewItem const& parent, wxDataViewItemArray const& items) = 0; // updates the passed items in the native control
//
// model related methods
//
virtual bool AssociateModel(wxDataViewModel* model) = 0; // informs the native control that a model is present
//
// selection related methods
//
virtual wxDataViewItem GetCurrentItem() const = 0;
virtual void SetCurrentItem(const wxDataViewItem& item) = 0;
virtual wxDataViewColumn *GetCurrentColumn() const = 0;
virtual int GetSelectedItemsCount() const = 0;
virtual int GetSelections(wxDataViewItemArray& sel) const = 0; // returns all selected items in the native control
virtual bool IsSelected (wxDataViewItem const& item) const = 0; // checks if the passed item is selected in the native control
virtual void Select (wxDataViewItem const& item) = 0; // selects the passed item in the native control
virtual void SelectAll (void) = 0; // selects all items in the native control
virtual void Unselect (wxDataViewItem const& item) = 0; // unselects the passed item in the native control
virtual void UnselectAll (void) = 0; // unselects all items in the native control
//
// sorting related methods
//
virtual wxDataViewColumn* GetSortingColumn (void) const = 0; // returns the column that is primarily responsible for sorting in the native control
virtual void Resort (void) = 0; // asks the native control to start a resorting process
//
// other methods
//
virtual void DoSetIndent (int indent) = 0; // sets the indention in the native control
virtual void DoExpand (wxDataViewItem const& item) = 0; // expands the passed item in the native control
virtual void HitTest (wxPoint const& point, wxDataViewItem& item, wxDataViewColumn*& columnPtr) const = 0; // return the item and column pointer that contains with the passed point
virtual void SetRowHeight(int height) = 0; // sets the height of all rows
virtual void SetRowHeight(wxDataViewItem const& item, unsigned int height) = 0; // sets the height of the row containg the passed item in the native control
virtual void OnSize (void) = 0; // updates the layout of the native control after a size event
virtual void StartEditor( const wxDataViewItem & item, unsigned int column ) = 0; // starts editing the passed in item and column
};
#endif // _WX_DATAVIEWCTRL_CORE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/private.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/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: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_CORE_H_
#define _WX_PRIVATE_CORE_H_
#include "wx/defs.h"
#include <CoreFoundation/CoreFoundation.h>
#include "wx/osx/core/cfstring.h"
#include "wx/osx/core/cfdataref.h"
#include "wx/osx/core/cfarray.h"
#include "wx/osx/core/cfdictionary.h"
// platform specific Clang analyzer support
#ifndef NS_RETURNS_RETAINED
# if WX_HAS_CLANG_FEATURE(attribute_ns_returns_retained)
# define NS_RETURNS_RETAINED __attribute__((ns_returns_retained))
# else
# define NS_RETURNS_RETAINED
# endif
#endif
#ifndef CF_RETURNS_RETAINED
# if WX_HAS_CLANG_FEATURE(attribute_cf_returns_retained)
# define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))
# else
# define CF_RETURNS_RETAINED
# endif
#endif
#if ( !wxUSE_GUI && !wxOSX_USE_IPHONE ) || wxOSX_USE_COCOA_OR_CARBON
// Carbon functions are currently still used in wxOSX/Cocoa too (including
// wxBase part of it).
#include <Carbon/Carbon.h>
void WXDLLIMPEXP_CORE wxMacStringToPascal( const wxString&from , unsigned char * to );
wxString WXDLLIMPEXP_CORE wxMacMakeStringFromPascal( const unsigned char * from );
WXDLLIMPEXP_BASE wxString wxMacFSRefToPath( const FSRef *fsRef , CFStringRef additionalPathComponent = NULL );
WXDLLIMPEXP_BASE OSStatus wxMacPathToFSRef( const wxString&path , FSRef *fsRef );
WXDLLIMPEXP_BASE wxString wxMacHFSUniStrToString( ConstHFSUniStr255Param uniname );
// keycode utils from app.cpp
WXDLLIMPEXP_BASE CGKeyCode wxCharCodeWXToOSX(wxKeyCode code);
WXDLLIMPEXP_BASE long wxMacTranslateKey(unsigned char key, unsigned char code);
#endif
#if wxUSE_GUI
#if wxOSX_USE_IPHONE
#include <CoreGraphics/CoreGraphics.h>
#else
#include <ApplicationServices/ApplicationServices.h>
#endif
#include "wx/bitmap.h"
#include "wx/window.h"
class WXDLLIMPEXP_CORE wxMacCGContextStateSaver
{
wxDECLARE_NO_COPY_CLASS(wxMacCGContextStateSaver);
public:
wxMacCGContextStateSaver( CGContextRef cg )
{
m_cg = cg;
CGContextSaveGState( cg );
}
~wxMacCGContextStateSaver()
{
CGContextRestoreGState( m_cg );
}
private:
CGContextRef m_cg;
};
class WXDLLIMPEXP_CORE wxDeferredObjectDeleter : public wxObject
{
public :
wxDeferredObjectDeleter( wxObject* obj ) : m_obj(obj)
{
}
virtual ~wxDeferredObjectDeleter()
{
delete m_obj;
}
protected :
wxObject* m_obj ;
} ;
// Quartz
WXDLLIMPEXP_CORE CGDataProviderRef wxMacCGDataProviderCreateWithCFData( CFDataRef data );
WXDLLIMPEXP_CORE CGDataConsumerRef wxMacCGDataConsumerCreateWithCFData( CFMutableDataRef data );
WXDLLIMPEXP_CORE CGDataProviderRef wxMacCGDataProviderCreateWithMemoryBuffer( const wxMemoryBuffer& buf );
WXDLLIMPEXP_CORE CGColorSpaceRef wxMacGetGenericRGBColorSpace(void);
WXDLLIMPEXP_CORE double wxOSXGetMainScreenContentScaleFactor();
// UI
CGSize WXDLLIMPEXP_CORE wxOSXGetImageSize(WXImage image);
CGImageRef WXDLLIMPEXP_CORE wxOSXCreateCGImageFromImage( WXImage nsimage, double *scale = NULL );
CGImageRef WXDLLIMPEXP_CORE wxOSXGetCGImageFromImage( WXImage nsimage, CGRect* r, CGContextRef cg);
CGContextRef WXDLLIMPEXP_CORE wxOSXCreateBitmapContextFromImage( WXImage nsimage, bool *isTemplate = NULL);
WXImage WXDLLIMPEXP_CORE wxOSXGetImageFromCGImage( CGImageRef image, double scale = 1.0, bool isTemplate = false);
double WXDLLIMPEXP_CORE wxOSXGetImageScaleFactor(WXImage image);
class wxWindowMac;
// to
extern wxWindow* g_MacLastWindow;
class wxNonOwnedWindow;
// temporary typedef so that no additional casts are necessary within carbon code at the moment
class wxMacControl;
class wxWidgetImpl;
class wxComboBox;
class wxNotebook;
class wxTextCtrl;
class wxSearchCtrl;
class wxMenuItem;
class wxAcceleratorEntry;
WXDLLIMPEXP_CORE wxWindowMac * wxFindWindowFromWXWidget(WXWidget inControl );
typedef wxWidgetImpl wxWidgetImplType;
#if wxUSE_MENUS
class wxMenuItemImpl : public wxObject
{
public :
wxMenuItemImpl( wxMenuItem* peer ) : m_peer(peer)
{
}
virtual ~wxMenuItemImpl() ;
virtual void SetBitmap( const wxBitmap& bitmap ) = 0;
virtual void Enable( bool enable ) = 0;
virtual void Check( bool check ) = 0;
virtual void SetLabel( const wxString& text, wxAcceleratorEntry *entry ) = 0;
virtual void Hide( bool hide = true ) = 0;
virtual void * GetHMenuItem() = 0;
wxMenuItem* GetWXPeer() { return m_peer ; }
static wxMenuItemImpl* Create( wxMenuItem* peer, wxMenu *pParentMenu,
int id,
const wxString& text,
wxAcceleratorEntry *entry,
const wxString& strHelp,
wxItemKind kind,
wxMenu *pSubMenu );
// handle OS specific menu items if they weren't handled during normal processing
virtual bool DoDefault() { return false; }
protected :
wxMenuItem* m_peer;
wxDECLARE_ABSTRACT_CLASS(wxMenuItemImpl);
} ;
class wxMenuImpl : public wxObject
{
public :
wxMenuImpl( wxMenu* peer ) : m_peer(peer)
{
}
virtual ~wxMenuImpl() ;
virtual void InsertOrAppend(wxMenuItem *pItem, size_t pos) = 0;
virtual void Remove( wxMenuItem *pItem ) = 0;
virtual void MakeRoot() = 0;
virtual void SetTitle( const wxString& text ) = 0;
virtual WXHMENU GetHMenu() = 0;
wxMenu* GetWXPeer() { return m_peer ; }
virtual void PopUp( wxWindow *win, int x, int y ) = 0;
virtual void GetMenuBarDimensions(int &x, int &y, int &width, int &height) const
{
x = y = width = height = -1;
}
static wxMenuImpl* Create( wxMenu* peer, const wxString& title );
static wxMenuImpl* CreateRootMenu( wxMenu* peer );
protected :
wxMenu* m_peer;
wxDECLARE_ABSTRACT_CLASS(wxMenuImpl);
} ;
#endif
class WXDLLIMPEXP_CORE wxWidgetImpl : public wxObject
{
public :
wxWidgetImpl( wxWindowMac* peer , bool isRootControl = false, bool isUserPane = false );
wxWidgetImpl();
virtual ~wxWidgetImpl();
void Init();
bool IsRootControl() const { return m_isRootControl; }
bool IsUserPane() const { return m_isUserPane; }
wxWindowMac* GetWXPeer() const { return m_wxPeer; }
bool IsOk() const { return GetWXWidget() != NULL; }
// not only the control itself, but also all its parents must be visible
// in order for this function to return true
virtual bool IsVisible() const = 0;
// set the visibility of this widget (maybe latent)
virtual void SetVisibility( bool visible ) = 0;
virtual bool ShowWithEffect(bool WXUNUSED(show),
wxShowEffect WXUNUSED(effect),
unsigned WXUNUSED(timeout))
{
return false;
}
virtual void Raise() = 0;
virtual void Lower() = 0;
virtual void ScrollRect( const wxRect *rect, int dx, int dy ) = 0;
virtual WXWidget GetWXWidget() const = 0;
virtual void SetBackgroundColour( const wxColour& col ) = 0;
virtual bool SetBackgroundStyle(wxBackgroundStyle style) = 0;
// all coordinates in native parent widget relative coordinates
virtual void GetContentArea( int &left , int &top , int &width , int &height ) const = 0;
virtual void Move(int x, int y, int width, int height) = 0;
virtual void GetPosition( int &x, int &y ) const = 0;
virtual void GetSize( int &width, int &height ) const = 0;
virtual void SetControlSize( wxWindowVariant variant ) = 0;
virtual double GetContentScaleFactor() const
{
return 1.0;
}
// the native coordinates may have an 'aura' for shadows etc, if this is the case the layout
// inset indicates on which insets the real control is drawn
virtual void GetLayoutInset(int &left , int &top , int &right, int &bottom) const
{
left = top = right = bottom = 0;
}
// native view coordinates are topleft to bottom right (flipped regarding CoreGraphics origin)
virtual bool IsFlipped() const { return true; }
virtual void SetNeedsDisplay( const wxRect* where = NULL ) = 0;
virtual bool GetNeedsDisplay() const = 0;
virtual bool NeedsFocusRect() const;
virtual void SetNeedsFocusRect( bool needs );
virtual bool NeedsFrame() const;
virtual void SetNeedsFrame( bool needs );
virtual void SetDrawingEnabled(bool enabled);
virtual bool CanFocus() const = 0;
// return true if successful
virtual bool SetFocus() = 0;
virtual bool HasFocus() const = 0;
virtual void RemoveFromParent() = 0;
virtual void Embed( wxWidgetImpl *parent ) = 0;
virtual void SetDefaultButton( bool isDefault ) = 0;
virtual void PerformClick() = 0;
virtual void SetLabel( const wxString& title, wxFontEncoding encoding ) = 0;
#if wxUSE_MARKUP && wxOSX_USE_COCOA
virtual void SetLabelMarkup( const wxString& WXUNUSED(markup) ) { }
#endif
virtual void SetInitialLabel( const wxString& title, wxFontEncoding encoding )
{ SetLabel(title, encoding); }
virtual void SetCursor( const wxCursor & cursor ) = 0;
virtual void CaptureMouse() = 0;
virtual void ReleaseMouse() = 0;
virtual void SetDropTarget( wxDropTarget * WXUNUSED(dropTarget) ) {}
virtual wxInt32 GetValue() const = 0;
virtual void SetValue( wxInt32 v ) = 0;
virtual wxBitmap GetBitmap() const = 0;
virtual void SetBitmap( const wxBitmap& bitmap ) = 0;
virtual void SetBitmapPosition( wxDirection dir ) = 0;
virtual void SetupTabs( const wxNotebook& WXUNUSED(notebook) ) {}
virtual int TabHitTest( const wxPoint & WXUNUSED(pt), long *flags ) {*flags=1; return -1;}
virtual void GetBestRect( wxRect *r ) const = 0;
virtual bool IsEnabled() const = 0;
virtual void Enable( bool enable ) = 0;
virtual void SetMinimum( wxInt32 v ) = 0;
virtual void SetMaximum( wxInt32 v ) = 0;
virtual wxInt32 GetMinimum() const = 0;
virtual wxInt32 GetMaximum() const = 0;
virtual void PulseGauge() = 0;
virtual void SetScrollThumb( wxInt32 value, wxInt32 thumbSize ) = 0;
virtual void SetFont( const wxFont & font , const wxColour& foreground , long windowStyle, bool ignoreBlack = true ) = 0;
virtual void SetToolTip(wxToolTip* WXUNUSED(tooltip)) { }
// is the clicked event sent AFTER the state already changed, so no additional
// state changing logic is required from the outside
virtual bool ButtonClickDidStateChange() = 0;
virtual void InstallEventHandler( WXWidget control = NULL ) = 0;
virtual bool EnableTouchEvents(int eventsMask) = 0;
// Mechanism used to keep track of whether a change should send an event
// Do SendEvents(false) when starting actions that would trigger programmatic events
// and SendEvents(true) at the end of the block.
virtual void SendEvents(bool shouldSendEvents) { m_shouldSendEvents = shouldSendEvents; }
virtual bool ShouldSendEvents() { return m_shouldSendEvents; }
// static methods for associating native controls and their implementations
// finds the impl associated with this native control
static wxWidgetImpl*
FindFromWXWidget(WXWidget control);
// finds the impl associated with this native control, if the native control itself is not known
// also checks whether its parent is eg a registered scrollview, ie whether the control is a native subpart
// of a known control
static wxWidgetImpl*
FindBestFromWXWidget(WXWidget control);
static void RemoveAssociations( wxWidgetImpl* impl);
static void RemoveAssociation(WXWidget control);
static void Associate( WXWidget control, wxWidgetImpl *impl );
static WXWidget FindFocus();
// static creation methods, must be implemented by all toolkits
static wxWidgetImplType* CreateUserPane( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateContentView( wxNonOwnedWindow* now ) ;
static wxWidgetImplType* CreateButton( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateDisclosureTriangle( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateStaticLine( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateGroupBox( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateStaticText( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateTextControl( wxTextCtrl* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& content,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateSearchControl( wxSearchCtrl* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& content,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle) ;
static wxWidgetImplType* CreateCheckBox( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateRadioButton( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateToggleButton( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateBitmapToggleButton( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateBitmapButton( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateTabView( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateGauge( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
wxInt32 value,
wxInt32 minimum,
wxInt32 maximum,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateSlider( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
wxInt32 value,
wxInt32 minimum,
wxInt32 maximum,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateSpinButton( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
wxInt32 value,
wxInt32 minimum,
wxInt32 maximum,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateScrollBar( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateChoice( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
wxMenu* menu,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
static wxWidgetImplType* CreateListBox( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
#if wxOSX_USE_COCOA
static wxWidgetImplType* CreateComboBox( wxComboBox* wxpeer,
wxWindowMac* parent,
wxWindowID id,
wxMenu* menu,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
#endif
static wxWidgetImplType* CreateStaticBitmap( wxWindowMac* wxpeer,
wxWindowMac* parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& size,
long style,
long extraStyle);
// converts from Toplevel-Content relative to local
static void Convert( wxPoint *pt , wxWidgetImpl *from , wxWidgetImpl *to );
protected :
bool m_isRootControl;
bool m_isUserPane;
wxWindowMac* m_wxPeer;
bool m_needsFocusRect;
bool m_needsFrame;
bool m_shouldSendEvents;
wxDECLARE_ABSTRACT_CLASS(wxWidgetImpl);
};
//
// the interface to be implemented eg by a listbox
//
class WXDLLIMPEXP_CORE wxListWidgetColumn
{
public :
virtual ~wxListWidgetColumn() {}
} ;
class WXDLLIMPEXP_CORE wxListWidgetCellValue
{
public :
wxListWidgetCellValue() {}
virtual ~wxListWidgetCellValue() {}
virtual void Set( CFStringRef value ) = 0;
virtual void Set( const wxString& value ) = 0;
virtual void Set( int value ) = 0;
virtual void Check( bool check );
virtual bool IsChecked() const;
virtual int GetIntValue() const = 0;
virtual wxString GetStringValue() const = 0;
} ;
class WXDLLIMPEXP_CORE wxListWidgetImpl
{
public:
wxListWidgetImpl() {}
virtual ~wxListWidgetImpl() { }
virtual wxListWidgetColumn* InsertTextColumn( unsigned pos, const wxString& title, bool editable = false,
wxAlignment just = wxALIGN_LEFT , int defaultWidth = -1) = 0 ;
virtual wxListWidgetColumn* InsertCheckColumn( unsigned pos , const wxString& title, bool editable = false,
wxAlignment just = wxALIGN_LEFT , int defaultWidth = -1) = 0 ;
// add and remove
// TODO will be replaced
virtual void ListDelete( unsigned int n ) = 0;
virtual void ListInsert( unsigned int n ) = 0;
virtual void ListClear() = 0;
// selecting
virtual void ListDeselectAll() = 0;
virtual void ListSetSelection( unsigned int n, bool select, bool multi ) = 0;
virtual int ListGetSelection() const = 0;
virtual int ListGetSelections( wxArrayInt& aSelections ) const = 0;
virtual bool ListIsSelected( unsigned int n ) const = 0;
// display
virtual void ListScrollTo( unsigned int n ) = 0;
virtual int ListGetTopItem() const = 0;
virtual int ListGetCountPerPage() const = 0;
virtual void UpdateLine( unsigned int n, wxListWidgetColumn* col = NULL ) = 0;
virtual void UpdateLineToEnd( unsigned int n) = 0;
// accessing content
virtual unsigned int ListGetCount() const = 0;
virtual int DoListHitTest( const wxPoint& inpoint ) const = 0;
};
//
// interface to be implemented by a textcontrol
//
class WXDLLIMPEXP_FWD_CORE wxTextAttr;
class WXDLLIMPEXP_FWD_CORE wxTextEntry;
// common interface for all implementations
class WXDLLIMPEXP_CORE wxTextWidgetImpl
{
public :
// Any widgets implementing this interface must be associated with a
// wxTextEntry so instead of requiring the derived classes to implement
// another (pure) virtual function, just take the pointer to this entry in
// our ctor and implement GetTextEntry() ourselves.
wxTextWidgetImpl(wxTextEntry *entry) : m_entry(entry) {}
virtual ~wxTextWidgetImpl() {}
wxTextEntry *GetTextEntry() const { return m_entry; }
virtual bool CanFocus() const { return true; }
virtual wxString GetStringValue() const = 0 ;
virtual void SetStringValue( const wxString &val ) = 0 ;
virtual void SetSelection( long from, long to ) = 0 ;
virtual void GetSelection( long* from, long* to ) const = 0 ;
virtual void WriteText( const wxString& str ) = 0 ;
virtual bool CanClipMaxLength() const { return false; }
virtual void SetMaxLength(unsigned long WXUNUSED(len)) {}
virtual bool CanForceUpper() { return false; }
virtual void ForceUpper() {}
virtual bool GetStyle( long position, wxTextAttr& style);
virtual void SetStyle( long start, long end, const wxTextAttr& style ) ;
virtual void Copy() ;
virtual void Cut() ;
virtual void Paste() ;
virtual bool CanPaste() const ;
virtual void SetEditable( bool editable ) ;
virtual long GetLastPosition() const ;
virtual void Replace( long from, long to, const wxString &str ) ;
virtual void Remove( long from, long to ) ;
virtual bool HasOwnContextMenu() const
{ return false ; }
virtual bool SetupCursor( const wxPoint& WXUNUSED(pt) )
{ return false ; }
virtual void Clear() ;
virtual bool CanUndo() const;
virtual void Undo() ;
virtual bool CanRedo() const;
virtual void Redo() ;
virtual int GetNumberOfLines() const ;
virtual long XYToPosition(long x, long y) const;
virtual bool PositionToXY(long pos, long *x, long *y) const ;
virtual void ShowPosition(long pos) ;
virtual int GetLineLength(long lineNo) const ;
virtual wxString GetLineText(long lineNo) const ;
virtual void CheckSpelling(bool WXUNUSED(check)) { }
virtual void EnableAutomaticQuoteSubstitution(bool WXUNUSED(enable)) {}
virtual void EnableAutomaticDashSubstitution(bool WXUNUSED(enable)) {}
virtual wxSize GetBestSize() const { return wxDefaultSize; }
virtual bool SetHint(const wxString& WXUNUSED(hint)) { return false; }
virtual void SetJustification();
private:
wxTextEntry * const m_entry;
wxDECLARE_NO_COPY_CLASS(wxTextWidgetImpl);
};
// common interface for all combobox implementations
class WXDLLIMPEXP_CORE wxComboWidgetImpl
{
public :
wxComboWidgetImpl() {}
virtual ~wxComboWidgetImpl() {}
virtual int GetSelectedItem() const { return -1; }
virtual void SetSelectedItem(int WXUNUSED(item)) {}
virtual int GetNumberOfItems() const { return -1; }
virtual void InsertItem(int WXUNUSED(pos), const wxString& WXUNUSED(item)) {}
virtual void RemoveItem(int WXUNUSED(pos)) {}
virtual void Clear() {}
virtual void Popup() {}
virtual void Dismiss() {}
virtual wxString GetStringAtIndex(int WXUNUSED(pos)) const { return wxEmptyString; }
virtual int FindString(const wxString& WXUNUSED(text)) const { return -1; }
};
//
// common interface for choice
//
class WXDLLIMPEXP_CORE wxChoiceWidgetImpl
{
public :
wxChoiceWidgetImpl() {}
virtual ~wxChoiceWidgetImpl() {}
virtual int GetSelectedItem() const { return -1; }
virtual void SetSelectedItem(int WXUNUSED(item)) {}
virtual size_t GetNumberOfItems() const = 0;
virtual void InsertItem(size_t pos, int itemid, const wxString& text) = 0;
virtual void RemoveItem(size_t pos) = 0;
virtual void Clear()
{
size_t count = GetNumberOfItems();
for ( size_t i = 0 ; i < count ; i++ )
{
RemoveItem( 0 );
}
}
virtual void SetItem(int pos, const wxString& item) = 0;
};
//
// common interface for buttons
//
class wxButtonImpl
{
public :
wxButtonImpl(){}
virtual ~wxButtonImpl(){}
virtual void SetPressedBitmap( const wxBitmap& bitmap ) = 0;
} ;
//
// common interface for search controls
//
class wxSearchWidgetImpl
{
public :
wxSearchWidgetImpl(){}
virtual ~wxSearchWidgetImpl(){}
// search field options
virtual void ShowSearchButton( bool show ) = 0;
virtual bool IsSearchButtonVisible() const = 0;
virtual void ShowCancelButton( bool show ) = 0;
virtual bool IsCancelButtonVisible() const = 0;
virtual void SetSearchMenu( wxMenu* menu ) = 0;
virtual void SetDescriptiveText(const wxString& text) = 0;
} ;
//
// toplevel window implementation class
//
class wxNonOwnedWindowImpl : public wxObject
{
public :
wxNonOwnedWindowImpl( wxNonOwnedWindow* nonownedwnd) : m_wxPeer(nonownedwnd)
{
}
wxNonOwnedWindowImpl()
{
}
virtual ~wxNonOwnedWindowImpl()
{
}
virtual void WillBeDestroyed()
{
}
virtual void Create( wxWindow* parent, const wxPoint& pos, const wxSize& size,
long style, long extraStyle, const wxString& name ) = 0;
virtual WXWindow GetWXWindow() const = 0;
virtual void Raise()
{
}
virtual void Lower()
{
}
virtual bool Show(bool WXUNUSED(show))
{
return false;
}
virtual bool ShowWithEffect(bool show, wxShowEffect WXUNUSED(effect), unsigned WXUNUSED(timeout))
{
return Show(show);
}
virtual void Update()
{
}
virtual bool SetTransparent(wxByte WXUNUSED(alpha))
{
return false;
}
virtual bool SetBackgroundColour(const wxColour& WXUNUSED(col) )
{
return false;
}
virtual void SetExtraStyle( long WXUNUSED(exStyle) )
{
}
virtual void SetWindowStyleFlag( long WXUNUSED(style) )
{
}
virtual bool SetBackgroundStyle(wxBackgroundStyle WXUNUSED(style))
{
return false ;
}
virtual bool CanSetTransparent()
{
return false;
}
virtual void GetContentArea( int &left , int &top , int &width , int &height ) const = 0;
virtual void MoveWindow(int x, int y, int width, int height) = 0;
virtual void GetPosition( int &x, int &y ) const = 0;
virtual void GetSize( int &width, int &height ) const = 0;
virtual bool SetShape(const wxRegion& WXUNUSED(region))
{
return false;
}
virtual void SetTitle( const wxString& title, wxFontEncoding encoding ) = 0;
virtual bool EnableCloseButton(bool enable) = 0;
virtual bool EnableMaximizeButton(bool enable) = 0;
virtual bool EnableMinimizeButton(bool enable) = 0;
virtual bool IsMaximized() const = 0;
virtual bool IsIconized() const= 0;
virtual void Iconize( bool iconize )= 0;
virtual void Maximize(bool maximize) = 0;
virtual bool IsFullScreen() const= 0;
virtual void ShowWithoutActivating() { Show(true); }
virtual bool EnableFullScreenView(bool enable) = 0;
virtual bool ShowFullScreen(bool show, long style)= 0;
virtual void RequestUserAttention(int flags) = 0;
virtual void ScreenToWindow( int *x, int *y ) = 0;
virtual void WindowToScreen( int *x, int *y ) = 0;
virtual bool IsActive() = 0;
wxNonOwnedWindow* GetWXPeer() { return m_wxPeer; }
static wxNonOwnedWindowImpl*
FindFromWXWindow(WXWindow window);
static void RemoveAssociations( wxNonOwnedWindowImpl* impl);
static void Associate( WXWindow window, wxNonOwnedWindowImpl *impl );
// static creation methods, must be implemented by all toolkits
static wxNonOwnedWindowImpl* CreateNonOwnedWindow( wxNonOwnedWindow* wxpeer, wxWindow* parent, WXWindow native) ;
static wxNonOwnedWindowImpl* CreateNonOwnedWindow( wxNonOwnedWindow* wxpeer, wxWindow* parent, const wxPoint& pos, const wxSize& size,
long style, long extraStyle, const wxString& name ) ;
virtual void SetModified(bool WXUNUSED(modified)) { }
virtual bool IsModified() const { return false; }
virtual void SetRepresentedFilename(const wxString& WXUNUSED(filename)) { }
#if wxOSX_USE_IPHONE
virtual CGFloat GetWindowLevel() const { return 0.0; }
#else
virtual CGWindowLevel GetWindowLevel() const { return kCGNormalWindowLevel; }
#endif
virtual void RestoreWindowLevel() {}
protected :
wxNonOwnedWindow* m_wxPeer;
wxDECLARE_ABSTRACT_CLASS(wxNonOwnedWindowImpl);
};
#endif // wxUSE_GUI
//---------------------------------------------------------------------------
// cocoa bridging utilities
//---------------------------------------------------------------------------
bool wxMacInitCocoa();
class WXDLLIMPEXP_CORE wxMacAutoreleasePool
{
public :
wxMacAutoreleasePool();
~wxMacAutoreleasePool();
private :
void* m_pool;
};
// NSObject
void wxMacCocoaRelease( void* obj );
void wxMacCocoaAutorelease( void* obj );
void* wxMacCocoaRetain( void* obj );
#endif
// _WX_PRIVATE_CORE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/cfarray.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/cfarrayref.h
// Purpose: wxCFArrayRef class
// Author: Stefan Csomor
// Modified by:
// Created: 2018/07/27
// Copyright: (c) 2018 Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*! @header wx/osx/core/cfarrayref.h
@abstract wxCFArrayRef class
*/
#ifndef _WX_OSX_COREFOUNDATION_CFARRAYREF_H__
#define _WX_OSX_COREFOUNDATION_CFARRAYREF_H__
#include "wx/osx/core/cfref.h"
#include "wx/osx/core/cftype.h"
#include <CoreFoundation/CFArray.h>
template <typename T, typename E>
class wxCFArrayRefCommon : public wxCFRef<T>
{
public:
typedef wxCFRef<T> super_type;
typedef size_t size_type;
wxCFArrayRefCommon(T r)
: super_type(r)
{
}
wxCFArrayRefCommon(const wxCFArrayRefCommon& otherRef)
: super_type(otherRef)
{
}
size_type size() const
{
return (size_type)CFArrayGetCount(this->m_ptr);
}
bool empty() const
{
return size() == 0;
}
wxCFRef<E> at(size_type idx)
{
wxASSERT(idx < size());
return wxCFRefFromGet((E)CFArrayGetValueAtIndex(this->m_ptr, idx));
}
operator WX_NSArray() { return (WX_NSArray) this->get(); }
wxCFRef<E> operator[](size_type idx) { return at(idx); }
wxCFRef<E> front() { return at(0); }
wxCFRef<E> back() { return at(size() - 1); }
};
template <typename E>
class wxCFArrayRef : public wxCFArrayRefCommon<CFArrayRef, E>
{
public:
wxCFArrayRef(CFArrayRef r)
: wxCFArrayRefCommon<CFArrayRef, E>(r)
{
}
wxCFArrayRef(const wxCFArrayRef& otherRef)
: wxCFArrayRefCommon<CFArrayRef, E>(otherRef)
{
}
};
template <typename E>
class wxCFMutableArrayRef : public wxCFArrayRefCommon<CFMutableArrayRef, E>
{
public:
wxCFMutableArrayRef()
: wxCFArrayRefCommon<CFMutableArrayRef, E>(CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks))
{
}
wxCFMutableArrayRef(CFMutableArrayRef r)
: wxCFArrayRefCommon<CFMutableArrayRef, E>(r)
{
}
wxCFMutableArrayRef(const wxCFMutableArrayRef& otherRef)
: wxCFArrayRefCommon<CFMutableArrayRef, E>(otherRef)
{
}
void push_back(E v)
{
CFArrayAppendValue(this->m_ptr, v);
}
void clear()
{
CFArrayRemoveAllValues(this->m_ptr);
}
};
#endif //ifndef _WX_OSX_COREFOUNDATION_CFARRAYREF_H__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/joystick.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/joystick.h
// Purpose: wxJoystick class
// Author: Ryan Norton
// Modified by:
// Created: 2/13/2005
// Copyright: (c) Ryan Norton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_JOYSTICK_H_
#define _WX_JOYSTICK_H_
#include "wx/event.h"
class WXDLLIMPEXP_FWD_CORE wxJoystickThread;
class WXDLLIMPEXP_ADV wxJoystick: public wxObject
{
wxDECLARE_DYNAMIC_CLASS(wxJoystick);
public:
wxJoystick(int joystick = wxJOYSTICK1);
virtual ~wxJoystick();
// Attributes
////////////////////////////////////////////////////////////////////////////
wxPoint GetPosition() const;
int GetPosition(unsigned axis) const;
bool GetButtonState(unsigned button) const;
int GetZPosition() const;
int GetButtonState() const;
int GetPOVPosition() const;
int GetPOVCTSPosition() const;
int GetRudderPosition() const;
int GetUPosition() const;
int GetVPosition() const;
int GetMovementThreshold() const;
void SetMovementThreshold(int threshold) ;
// Capabilities
////////////////////////////////////////////////////////////////////////////
bool IsOk() const; // Checks that the joystick is functioning
static int GetNumberJoysticks() ;
int GetManufacturerId() const ;
int GetProductId() const ;
wxString GetProductName() const ;
int GetXMin() const;
int GetYMin() const;
int GetZMin() const;
int GetXMax() const;
int GetYMax() const;
int GetZMax() const;
int GetNumberButtons() const;
int GetNumberAxes() const;
int GetMaxButtons() const;
int GetMaxAxes() const;
int GetPollingMin() const;
int GetPollingMax() const;
int GetRudderMin() const;
int GetRudderMax() const;
int GetUMin() const;
int GetUMax() const;
int GetVMin() const;
int GetVMax() const;
bool HasRudder() const;
bool HasZ() const;
bool HasU() const;
bool HasV() const;
bool HasPOV() const;
bool HasPOV4Dir() const;
bool HasPOVCTS() const;
// Operations
////////////////////////////////////////////////////////////////////////////
// pollingFreq = 0 means that movement events are sent when above the threshold.
// If pollingFreq > 0, events are received every this many milliseconds.
bool SetCapture(wxWindow* win, int pollingFreq = 0);
bool ReleaseCapture();
protected:
int m_joystick;
wxJoystickThread* m_thread;
class wxHIDJoystick* m_hid;
};
#endif
// _WX_JOYSTICK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/mimetype.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/mimetype.h
// Purpose: Mac implementation for wx mime-related classes
// Author: Neil Perkins
// Modified by:
// Created: 2010-05-15
// Copyright: (C) 2010 Neil Perkins
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _MIMETYPE_IMPL_H
#define _MIMETYPE_IMPL_H
#include "wx/defs.h"
#if wxUSE_MIMETYPE
#include "wx/mimetype.h"
#include "wx/hashmap.h"
#include "wx/iconloc.h"
// This class implements mime type functionality for Mac OS X using UTIs and Launch Services
// Currently only the GetFileTypeFromXXXX public functions have been implemented
class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl
{
public:
wxMimeTypesManagerImpl();
virtual ~wxMimeTypesManagerImpl();
// These functions are not needed on Mac OS X and have no-op implementations
void Initialize(int mailcapStyles = wxMAILCAP_STANDARD, const wxString& extraDir = wxEmptyString);
void ClearData();
// Functions to look up types by ext, mime or UTI
wxFileType *GetFileTypeFromExtension(const wxString& ext);
wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
wxFileType *GetFileTypeFromUti(const wxString& uti);
// These functions are only stubs on Mac OS X
size_t EnumAllFileTypes(wxArrayString& mimetypes);
wxFileType *Associate(const wxFileTypeInfo& ftInfo);
bool Unassociate(wxFileType *ft);
private:
// The work of querying the OS for type data is done in these two functions
void LoadTypeDataForUti(const wxString& uti);
void LoadDisplayDataForUti(const wxString& uti);
// These functions are pass-throughs from wxFileTypeImpl
bool GetExtensions(const wxString& uti, wxArrayString& extensions);
bool GetMimeType(const wxString& uti, wxString *mimeType);
bool GetMimeTypes(const wxString& uti, wxArrayString& mimeTypes);
bool GetIcon(const wxString& uti, wxIconLocation *iconLoc);
bool GetDescription(const wxString& uti, wxString *desc);
bool GetApplication(const wxString& uti, wxString *command);
// Structure to represent file types
typedef struct FileTypeData
{
wxArrayString extensions;
wxArrayString mimeTypes;
wxIconLocation iconLoc;
wxString application;
wxString description;
}
FileTypeInfo;
// Map types
WX_DECLARE_STRING_HASH_MAP( wxString, TagMap );
WX_DECLARE_STRING_HASH_MAP( FileTypeData, UtiMap );
// Data store
TagMap m_extMap;
TagMap m_mimeMap;
UtiMap m_utiMap;
friend class wxFileTypeImpl;
};
// This class provides the interface between wxFileType and wxMimeTypesManagerImple for Mac OS X
// Currently only extension, mimetype, description and icon information is available
// All other methods have no-op implementation
class WXDLLIMPEXP_BASE wxFileTypeImpl
{
public:
wxFileTypeImpl();
virtual ~wxFileTypeImpl();
bool GetExtensions(wxArrayString& extensions) const ;
bool GetMimeType(wxString *mimeType) const ;
bool GetMimeTypes(wxArrayString& mimeTypes) const ;
bool GetIcon(wxIconLocation *iconLoc) const ;
bool GetDescription(wxString *desc) const ;
bool GetOpenCommand(wxString *openCmd, const wxFileType::MessageParameters& params) const;
// These functions are only stubs on Mac OS X
bool GetPrintCommand(wxString *printCmd, const wxFileType::MessageParameters& params) const;
size_t GetAllCommands(wxArrayString *verbs, wxArrayString *commands, const wxFileType::MessageParameters& params) const;
bool SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt = TRUE);
bool SetDefaultIcon(const wxString& strIcon = wxEmptyString, int index = 0);
bool Unassociate(wxFileType *ft);
wxString
GetExpandedCommand(const wxString& verb,
const wxFileType::MessageParameters& params) const;
private:
// All that is needed to query type info - UTI and pointer to the manager
wxString m_uti;
wxMimeTypesManagerImpl* m_manager;
friend class wxMimeTypesManagerImpl;
};
#endif // wxUSE_MIMETYPE
#endif //_MIMETYPE_IMPL_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/private/datetimectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/private/datetime.h
// Purpose:
// Author: Vadim Zeitlin
// Created: 2011-12-19
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_CORE_PRIVATE_DATETIMECTRL_H_
#define _WX_OSX_CORE_PRIVATE_DATETIMECTRL_H_
#if wxUSE_DATEPICKCTRL
#include "wx/osx/private.h"
#include "wx/datetime.h"
enum wxDateTimeWidgetKind
{
wxDateTimeWidget_YearMonthDay,
wxDateTimeWidget_HourMinuteSecond
};
// ----------------------------------------------------------------------------
// wxDateTimeWidgetImpl: peer class for wxDateTimePickerCtrl.
// ----------------------------------------------------------------------------
class wxDateTimeWidgetImpl
#if wxOSX_USE_COCOA
: public wxWidgetCocoaImpl
#else
#error "Unsupported platform"
#endif
{
public:
static wxDateTimeWidgetImpl*
CreateDateTimePicker(wxDateTimePickerCtrl* wxpeer,
const wxDateTime& dt,
const wxPoint& pos,
const wxSize& size,
long style,
wxDateTimeWidgetKind kind);
virtual void SetDateTime(const wxDateTime& dt) = 0;
virtual wxDateTime GetDateTime() const = 0;
virtual void SetDateRange(const wxDateTime& dt1, const wxDateTime& dt2) = 0;
virtual bool GetDateRange(wxDateTime* dt1, wxDateTime* dt2) = 0;
virtual ~wxDateTimeWidgetImpl() { }
protected:
#if wxOSX_USE_COCOA
wxDateTimeWidgetImpl(wxDateTimePickerCtrl* wxpeer, WXWidget view)
: wxWidgetCocoaImpl(wxpeer, view)
{
}
#endif
};
#endif // wxUSE_DATEPICKCTRL
#endif // _WX_OSX_CORE_PRIVATE_DATETIMECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/private/timer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/private/timer.h
// Purpose: wxTimer class based on core foundation
// Author: Stefan Csomor
// Created: 2008-07-16
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_CORE_PRIVATE_TIMER_H_
#define _WX_OSX_CORE_PRIVATE_TIMER_H_
#include "wx/private/timer.h"
struct wxOSXTimerInfo;
class WXDLLIMPEXP_CORE wxOSXTimerImpl : public wxTimerImpl
{
public:
wxOSXTimerImpl(wxTimer *timer);
virtual ~wxOSXTimerImpl();
virtual bool Start(int milliseconds = -1, bool one_shot = false);
virtual void Stop();
virtual bool IsRunning() const;
private:
wxOSXTimerInfo *m_info;
};
#endif // _WX_OSX_CORE_PRIVATE_TIMER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/core/private/strconv_cf.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/core/private/strconv_cf.h
// Purpose: Unicode conversion classes
// Author: David Elliott, Ryan Norton
// Modified by:
// Created: 2007-07-06
// Copyright: (c) 2004 Ryan Norton
// (c) 2007 David Elliott
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/strconv.h"
#include <CoreFoundation/CFString.h>
#include <CoreFoundation/CFStringEncodingExt.h>
// ============================================================================
// CoreFoundation conversion classes
// ============================================================================
inline CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding)
{
CFStringEncoding enc = kCFStringEncodingInvalidId ;
switch (encoding)
{
case wxFONTENCODING_DEFAULT :
enc = CFStringGetSystemEncoding();
break ;
case wxFONTENCODING_ISO8859_1 :
enc = kCFStringEncodingISOLatin1 ;
break ;
case wxFONTENCODING_ISO8859_2 :
enc = kCFStringEncodingISOLatin2;
break ;
case wxFONTENCODING_ISO8859_3 :
enc = kCFStringEncodingISOLatin3 ;
break ;
case wxFONTENCODING_ISO8859_4 :
enc = kCFStringEncodingISOLatin4;
break ;
case wxFONTENCODING_ISO8859_5 :
enc = kCFStringEncodingISOLatinCyrillic;
break ;
case wxFONTENCODING_ISO8859_6 :
enc = kCFStringEncodingISOLatinArabic;
break ;
case wxFONTENCODING_ISO8859_7 :
enc = kCFStringEncodingISOLatinGreek;
break ;
case wxFONTENCODING_ISO8859_8 :
enc = kCFStringEncodingISOLatinHebrew;
break ;
case wxFONTENCODING_ISO8859_9 :
enc = kCFStringEncodingISOLatin5;
break ;
case wxFONTENCODING_ISO8859_10 :
enc = kCFStringEncodingISOLatin6;
break ;
case wxFONTENCODING_ISO8859_11 :
enc = kCFStringEncodingISOLatinThai;
break ;
case wxFONTENCODING_ISO8859_13 :
enc = kCFStringEncodingISOLatin7;
break ;
case wxFONTENCODING_ISO8859_14 :
enc = kCFStringEncodingISOLatin8;
break ;
case wxFONTENCODING_ISO8859_15 :
enc = kCFStringEncodingISOLatin9;
break ;
case wxFONTENCODING_KOI8 :
enc = kCFStringEncodingKOI8_R;
break ;
case wxFONTENCODING_ALTERNATIVE : // MS-DOS CP866
enc = kCFStringEncodingDOSRussian;
break ;
// case wxFONTENCODING_BULGARIAN :
// enc = ;
// break ;
case wxFONTENCODING_CP437 :
enc = kCFStringEncodingDOSLatinUS ;
break ;
case wxFONTENCODING_CP850 :
enc = kCFStringEncodingDOSLatin1;
break ;
case wxFONTENCODING_CP852 :
enc = kCFStringEncodingDOSLatin2;
break ;
case wxFONTENCODING_CP855 :
enc = kCFStringEncodingDOSCyrillic;
break ;
case wxFONTENCODING_CP866 :
enc = kCFStringEncodingDOSRussian ;
break ;
case wxFONTENCODING_CP874 :
enc = kCFStringEncodingDOSThai;
break ;
case wxFONTENCODING_CP932 :
enc = kCFStringEncodingDOSJapanese;
break ;
case wxFONTENCODING_CP936 :
enc = kCFStringEncodingDOSChineseSimplif ;
break ;
case wxFONTENCODING_CP949 :
enc = kCFStringEncodingDOSKorean;
break ;
case wxFONTENCODING_CP950 :
enc = kCFStringEncodingDOSChineseTrad;
break ;
case wxFONTENCODING_CP1250 :
enc = kCFStringEncodingWindowsLatin2;
break ;
case wxFONTENCODING_CP1251 :
enc = kCFStringEncodingWindowsCyrillic ;
break ;
case wxFONTENCODING_CP1252 :
enc = kCFStringEncodingWindowsLatin1 ;
break ;
case wxFONTENCODING_CP1253 :
enc = kCFStringEncodingWindowsGreek;
break ;
case wxFONTENCODING_CP1254 :
enc = kCFStringEncodingWindowsLatin5;
break ;
case wxFONTENCODING_CP1255 :
enc = kCFStringEncodingWindowsHebrew ;
break ;
case wxFONTENCODING_CP1256 :
enc = kCFStringEncodingWindowsArabic ;
break ;
case wxFONTENCODING_CP1257 :
enc = kCFStringEncodingWindowsBalticRim;
break ;
// This only really encodes to UTF7 (if that) evidently
// case wxFONTENCODING_UTF7 :
// enc = kCFStringEncodingNonLossyASCII ;
// break ;
case wxFONTENCODING_UTF8 :
enc = kCFStringEncodingUTF8 ;
break ;
case wxFONTENCODING_EUC_JP :
enc = kCFStringEncodingEUC_JP;
break ;
/* Don't support conversion to/from UTF16 as wxWidgets can do this better.
* In particular, ToWChar would fail miserably using strlen on an input UTF16.
case wxFONTENCODING_UTF16 :
enc = kCFStringEncodingUnicode ;
break ;
*/
case wxFONTENCODING_MACROMAN :
enc = kCFStringEncodingMacRoman ;
break ;
case wxFONTENCODING_MACJAPANESE :
enc = kCFStringEncodingMacJapanese ;
break ;
case wxFONTENCODING_MACCHINESETRAD :
enc = kCFStringEncodingMacChineseTrad ;
break ;
case wxFONTENCODING_MACKOREAN :
enc = kCFStringEncodingMacKorean ;
break ;
case wxFONTENCODING_MACARABIC :
enc = kCFStringEncodingMacArabic ;
break ;
case wxFONTENCODING_MACHEBREW :
enc = kCFStringEncodingMacHebrew ;
break ;
case wxFONTENCODING_MACGREEK :
enc = kCFStringEncodingMacGreek ;
break ;
case wxFONTENCODING_MACCYRILLIC :
enc = kCFStringEncodingMacCyrillic ;
break ;
case wxFONTENCODING_MACDEVANAGARI :
enc = kCFStringEncodingMacDevanagari ;
break ;
case wxFONTENCODING_MACGURMUKHI :
enc = kCFStringEncodingMacGurmukhi ;
break ;
case wxFONTENCODING_MACGUJARATI :
enc = kCFStringEncodingMacGujarati ;
break ;
case wxFONTENCODING_MACORIYA :
enc = kCFStringEncodingMacOriya ;
break ;
case wxFONTENCODING_MACBENGALI :
enc = kCFStringEncodingMacBengali ;
break ;
case wxFONTENCODING_MACTAMIL :
enc = kCFStringEncodingMacTamil ;
break ;
case wxFONTENCODING_MACTELUGU :
enc = kCFStringEncodingMacTelugu ;
break ;
case wxFONTENCODING_MACKANNADA :
enc = kCFStringEncodingMacKannada ;
break ;
case wxFONTENCODING_MACMALAJALAM :
enc = kCFStringEncodingMacMalayalam ;
break ;
case wxFONTENCODING_MACSINHALESE :
enc = kCFStringEncodingMacSinhalese ;
break ;
case wxFONTENCODING_MACBURMESE :
enc = kCFStringEncodingMacBurmese ;
break ;
case wxFONTENCODING_MACKHMER :
enc = kCFStringEncodingMacKhmer ;
break ;
case wxFONTENCODING_MACTHAI :
enc = kCFStringEncodingMacThai ;
break ;
case wxFONTENCODING_MACLAOTIAN :
enc = kCFStringEncodingMacLaotian ;
break ;
case wxFONTENCODING_MACGEORGIAN :
enc = kCFStringEncodingMacGeorgian ;
break ;
case wxFONTENCODING_MACARMENIAN :
enc = kCFStringEncodingMacArmenian ;
break ;
case wxFONTENCODING_MACCHINESESIMP :
enc = kCFStringEncodingMacChineseSimp ;
break ;
case wxFONTENCODING_MACTIBETAN :
enc = kCFStringEncodingMacTibetan ;
break ;
case wxFONTENCODING_MACMONGOLIAN :
enc = kCFStringEncodingMacMongolian ;
break ;
case wxFONTENCODING_MACETHIOPIC :
enc = kCFStringEncodingMacEthiopic ;
break ;
case wxFONTENCODING_MACCENTRALEUR :
enc = kCFStringEncodingMacCentralEurRoman ;
break ;
case wxFONTENCODING_MACVIATNAMESE :
enc = kCFStringEncodingMacVietnamese ;
break ;
case wxFONTENCODING_MACARABICEXT :
enc = kCFStringEncodingMacExtArabic ;
break ;
case wxFONTENCODING_MACSYMBOL :
enc = kCFStringEncodingMacSymbol ;
break ;
case wxFONTENCODING_MACDINGBATS :
enc = kCFStringEncodingMacDingbats ;
break ;
case wxFONTENCODING_MACTURKISH :
enc = kCFStringEncodingMacTurkish ;
break ;
case wxFONTENCODING_MACCROATIAN :
enc = kCFStringEncodingMacCroatian ;
break ;
case wxFONTENCODING_MACICELANDIC :
enc = kCFStringEncodingMacIcelandic ;
break ;
case wxFONTENCODING_MACROMANIAN :
enc = kCFStringEncodingMacRomanian ;
break ;
case wxFONTENCODING_MACCELTIC :
enc = kCFStringEncodingMacCeltic ;
break ;
case wxFONTENCODING_MACGAELIC :
enc = kCFStringEncodingMacGaelic ;
break ;
/* CFString is known to support this back to the original CarbonLib */
/* http://developer.apple.com/samplecode/CarbonMDEF/listing2.html */
case wxFONTENCODING_MACKEYBOARD :
/* We don't wish to pollute the namespace too much, even though we're a private header. */
/* The constant is well-defined as 41 and is not expected to change. */
enc = 41 /*kTextEncodingMacKeyboardGlyphs*/ ;
break ;
default :
// because gcc is picky
break ;
}
return enc ;
}
class wxMBConv_cf : public wxMBConv
{
public:
wxMBConv_cf()
{
Init(CFStringGetSystemEncoding()) ;
}
wxMBConv_cf(const wxMBConv_cf& conv) : wxMBConv()
{
m_encoding = conv.m_encoding;
}
#if wxUSE_FONTMAP
wxMBConv_cf(const char* name)
{
Init( wxCFStringEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name, false) ) ) ;
}
#endif
wxMBConv_cf(wxFontEncoding encoding)
{
Init( wxCFStringEncFromFontEnc(encoding) );
}
virtual ~wxMBConv_cf()
{
}
void Init( CFStringEncoding encoding)
{
m_encoding = encoding ;
}
virtual size_t ToWChar(wchar_t * dst, size_t dstSize, const char * src, size_t srcSize = wxNO_LEN) const;
virtual size_t FromWChar(char *dst, size_t dstSize, const wchar_t *src, size_t srcSize = wxNO_LEN) const;
virtual wxMBConv *Clone() const { return new wxMBConv_cf(*this); }
bool IsOk() const
{
return m_encoding != kCFStringEncodingInvalidId &&
CFStringIsEncodingAvailable(m_encoding);
}
private:
CFStringEncoding m_encoding ;
};
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/private/addremovectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/private/addremovectrl.h
// Purpose: OS X specific wxAddRemoveImpl implementation
// Author: Vadim Zeitlin
// Created: 2015-02-05
// Copyright: (c) 2015 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_PRIVATE_ADDREMOVECTRL_H_
#define _WX_OSX_PRIVATE_ADDREMOVECTRL_H_
#include "wx/artprov.h"
#include "wx/bmpbuttn.h"
#include "wx/panel.h"
#include "wx/osx/private.h"
// ----------------------------------------------------------------------------
// wxAddRemoveImpl itself
// ----------------------------------------------------------------------------
class wxAddRemoveImpl : public wxAddRemoveImplWithButtons
{
public:
wxAddRemoveImpl(wxAddRemoveAdaptor* adaptor,
wxAddRemoveCtrl* parent,
wxWindow* ctrlItems)
: wxAddRemoveImplWithButtons(adaptor, parent, ctrlItems),
m_ctrlItems(ctrlItems)
{
// This size is hard coded for now as this is what the system dialogs
// themselves (e.g. the buttons under the lists in the "Users" or
// "Network" panes of the "System Preferences") use under OS X 10.8.
const wxSize sizeBtn(25, 23);
m_btnAdd = new wxBitmapButton(parent, wxID_ADD,
wxArtProvider::GetBitmap("NSAddTemplate"),
wxDefaultPosition,
sizeBtn,
wxBORDER_SIMPLE);
m_btnRemove = new wxBitmapButton(parent, wxID_REMOVE,
wxArtProvider::GetBitmap("NSRemoveTemplate"),
wxDefaultPosition,
sizeBtn,
wxBORDER_SIMPLE);
// Under OS X the space to the right of the buttons is actually
// occupied by an inactive gradient button, so create one.
m_btnPlaceholder = new wxButton(parent, wxID_ANY, "",
wxDefaultPosition,
sizeBtn,
wxBORDER_SIMPLE);
m_btnPlaceholder->Disable();
// We need to lay out our windows manually under OS X as it is the only
// way to achieve the required, for the correct look, overlap between
// their borders -- sizers would never allow this.
parent->Bind(wxEVT_SIZE, &wxAddRemoveImpl::OnSize, this);
// We also have to ensure that the window with the items doesn't have
// any border as it wouldn't look correctly if it did.
long style = ctrlItems->GetWindowStyle();
style &= ~wxBORDER_MASK;
style |= wxBORDER_SIMPLE;
ctrlItems->SetWindowStyle(style);
SetUpEvents();
}
// As we don't use sizers, we also need to compute our best size ourselves.
virtual wxSize GetBestClientSize() const wxOVERRIDE
{
wxSize size = m_ctrlItems->GetBestSize();
const wxSize sizeBtn = m_btnAdd->GetSize();
size.y += sizeBtn.y;
size.IncTo(wxSize(3*sizeBtn.x, -1));
return size;
}
private:
void OnSize(wxSizeEvent& event)
{
const wxSize size = event.GetSize();
const wxSize sizeBtn = m_btnAdd->GetSize();
const int yBtn = size.y - sizeBtn.y;
// There is a vertical overlap which hides the items control bottom
// border.
m_ctrlItems->SetSize(0, 0, size.x, yBtn + 2);
// And there is also a horizontal 1px overlap between the buttons
// themselves, so subtract 1 from the next button position.
int x = 0;
m_btnAdd->Move(x, yBtn);
x += sizeBtn.x - 1;
m_btnRemove->Move(x, yBtn);
x += sizeBtn.x - 1;
// The last one needs to be resized to take up all the remaining space.
m_btnPlaceholder->SetSize(x, yBtn, size.x - x, sizeBtn.y);
}
wxWindow* m_ctrlItems;
wxButton* /* const */ m_btnPlaceholder;
};
#endif // _WX_OSX_PRIVATE_ADDREMOVECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/private/timer.h | #if 1 // revert to wxOSX_USE_COCOA_OR_IPHONE in case of problems
#include "wx/osx/core/private/timer.h"
#endif
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/private/print.h | #include "wx/osx/carbon/private/print.h"
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/iphone/private.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/iphone/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: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_IPHONE_H_
#define _WX_PRIVATE_IPHONE_H_
#ifdef __OBJC__
#import <UIKit/UIKit.h>
#endif
#include <CoreText/CTFont.h>
#include <CoreText/CTStringAttributes.h>
#include <CoreText/CTLine.h>
#if wxUSE_GUI
typedef CGRect WXRect;
OSStatus WXDLLIMPEXP_CORE wxMacDrawCGImage(
CGContextRef inContext,
const CGRect * inBounds,
CGImageRef inImage) ;
WX_UIImage WXDLLIMPEXP_CORE wxOSXGetUIImageFromCGImage( CGImageRef image );
wxBitmap WXDLLIMPEXP_CORE wxOSXCreateSystemBitmap(const wxString& id, const wxString &client, const wxSize& size);
class WXDLLIMPEXP_CORE wxWidgetIPhoneImpl : public wxWidgetImpl
{
public :
wxWidgetIPhoneImpl( wxWindowMac* peer , WXWidget w, bool isRootControl = false, bool isUserPane = false ) ;
wxWidgetIPhoneImpl() ;
~wxWidgetIPhoneImpl();
void Init();
virtual bool IsVisible() const ;
virtual void SetVisibility( bool visible );
virtual void Raise();
virtual void Lower();
virtual void ScrollRect( const wxRect *rect, int dx, int dy );
virtual WXWidget GetWXWidget() const { return m_osxView; }
virtual void SetBackgroundColour( const wxColour& col ) ;
virtual bool SetBackgroundStyle(wxBackgroundStyle style) ;
virtual void GetContentArea( int &left , int &top , int &width , int &height ) const;
virtual void Move(int x, int y, int width, int height);
virtual void GetPosition( int &x, int &y ) const;
virtual void GetSize( int &width, int &height ) const;
virtual void SetControlSize( wxWindowVariant variant );
virtual double GetContentScaleFactor() const ;
virtual void SetNeedsDisplay( const wxRect* where = NULL );
virtual bool GetNeedsDisplay() const;
virtual bool CanFocus() const;
// return true if successful
virtual bool SetFocus();
virtual bool HasFocus() const;
void RemoveFromParent();
void Embed( wxWidgetImpl *parent );
void SetDefaultButton( bool isDefault );
void PerformClick();
virtual void SetLabel(const wxString& title, wxFontEncoding encoding);
void SetCursor( const wxCursor & cursor );
void CaptureMouse();
void ReleaseMouse();
wxInt32 GetValue() const;
void SetValue( wxInt32 v );
virtual wxBitmap GetBitmap() const;
virtual void SetBitmap( const wxBitmap& bitmap );
virtual void SetBitmapPosition( wxDirection dir );
void SetupTabs( const wxNotebook ¬ebook );
void GetBestRect( wxRect *r ) const;
bool IsEnabled() const;
void Enable( bool enable );
bool ButtonClickDidStateChange() { return true ;}
void SetMinimum( wxInt32 v );
void SetMaximum( wxInt32 v );
wxInt32 GetMinimum() const;
wxInt32 GetMaximum() const;
void PulseGauge();
void SetScrollThumb( wxInt32 value, wxInt32 thumbSize );
void SetFont( const wxFont & font , const wxColour& foreground , long windowStyle, bool ignoreBlack = true );
void InstallEventHandler( WXWidget control = NULL );
bool EnableTouchEvents(int WXUNUSED(eventsMask)) { return false; }
virtual void DoNotifyFocusEvent(bool receivedFocus, wxWidgetImpl* otherWindow);
// thunk connected calls
virtual void drawRect(CGRect* rect, WXWidget slf, void* _cmd);
virtual void touchEvent(WX_NSSet touches, WX_UIEvent event, WXWidget slf, void* _cmd);
virtual bool becomeFirstResponder(WXWidget slf, void* _cmd);
virtual bool resignFirstResponder(WXWidget slf, void* _cmd);
// action
virtual void controlAction(void* sender, wxUint32 controlEvent, WX_UIEvent rawEvent);
virtual void controlTextDidChange();
protected:
WXWidget m_osxView;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxWidgetIPhoneImpl);
};
class wxNonOwnedWindowIPhoneImpl : public wxNonOwnedWindowImpl
{
public :
wxNonOwnedWindowIPhoneImpl( wxNonOwnedWindow* nonownedwnd) ;
wxNonOwnedWindowIPhoneImpl();
virtual ~wxNonOwnedWindowIPhoneImpl();
virtual void WillBeDestroyed() ;
void Create( wxWindow* parent, const wxPoint& pos, const wxSize& size,
long style, long extraStyle, const wxString& name ) ;
void Create( wxWindow* parent, WXWindow nativeWindow );
WXWindow GetWXWindow() const;
void Raise();
void Lower();
bool Show(bool show);
bool ShowWithEffect(bool show, wxShowEffect effect, unsigned timeout);
void Update();
bool SetTransparent(wxByte alpha);
bool SetBackgroundColour(const wxColour& col );
void SetExtraStyle( long exStyle );
bool SetBackgroundStyle(wxBackgroundStyle style);
bool CanSetTransparent();
void MoveWindow(int x, int y, int width, int height);
void GetPosition( int &x, int &y ) const;
void GetSize( int &width, int &height ) const;
void GetContentArea( int &left , int &top , int &width , int &height ) const;
bool SetShape(const wxRegion& region);
virtual void SetTitle( const wxString& title, wxFontEncoding encoding ) ;
// Title bar buttons don't exist in iOS.
virtual bool EnableCloseButton(bool WXUNUSED(enable)) { return false; }
virtual bool EnableMaximizeButton(bool WXUNUSED(enable)) { return false; }
virtual bool EnableMinimizeButton(bool WXUNUSED(enable)) { return false; }
virtual bool IsMaximized() const;
virtual bool IsIconized() const;
virtual void Iconize( bool iconize );
virtual void Maximize(bool maximize);
virtual bool IsFullScreen() const;
virtual bool EnableFullScreenView(bool enable);
virtual bool ShowFullScreen(bool show, long style);
virtual void RequestUserAttention(int flags);
virtual void ScreenToWindow( int *x, int *y );
virtual void WindowToScreen( int *x, int *y );
// FIXME: Does iPhone have a concept of inactive windows?
virtual bool IsActive() { return true; }
wxNonOwnedWindow* GetWXPeer() { return m_wxPeer; }
virtual bool InitialShowEventSent() { return m_initialShowSent; }
protected :
WX_UIWindow m_macWindow;
void * m_macFullScreenData ;
bool m_initialShowSent;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxNonOwnedWindowIPhoneImpl);
};
#ifdef __OBJC__
WXDLLIMPEXP_CORE CGRect wxToNSRect( UIView* parent, const wxRect& r );
WXDLLIMPEXP_CORE wxRect wxFromNSRect( UIView* parent, const CGRect& rect );
WXDLLIMPEXP_CORE CGPoint wxToNSPoint( UIView* parent, const wxPoint& p );
WXDLLIMPEXP_CORE wxPoint wxFromNSPoint( UIView* parent, const CGPoint& p );
CGRect WXDLLIMPEXP_CORE wxOSXGetFrameForControl( wxWindowMac* window , const wxPoint& pos , const wxSize &size ,
bool adjustForOrigin = true );
@interface wxUIButton : UIButton
{
}
@end
@interface wxUIView : UIView
{
}
@end // wxUIView
void WXDLLIMPEXP_CORE wxOSXIPhoneClassAddWXMethods(Class c);
#endif
#endif // wxUSE_GUI
#endif
// _WX_PRIVATE_IPHONE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/iphone/chkconf.h | /*
* Name: wx/osx/iphone/chkconf.h
* Purpose: Compiler-specific configuration checking
* Author: Stefan Csomor
* Modified by:
* Created: 2008-07-30
* Copyright: (c) Stefan Csomor
* Licence: wxWindows licence
*/
#ifndef _WX_OSX_IPHONE_CHKCONF_H_
#define _WX_OSX_IPHONE_CHKCONF_H_
/*
* text rendering system
*/
/* we have different options and we turn on all that make sense
* under a certain platform
*/
#define wxHAS_OPENGL_ES
#define wxOSX_USE_QUICKTIME 0
#define wxOSX_USE_AUDIOTOOLBOX 1
/*
* turning off capabilities that don't work under iphone yet
*/
#if wxUSE_MIMETYPE
#undef wxUSE_MIMETYPE
#define wxUSE_MIMETYPE 0
#endif
#if wxUSE_MDI
#undef wxUSE_MDI
#define wxUSE_MDI 0
#endif
#if wxUSE_MDI_ARCHITECTURE
#undef wxUSE_MDI_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 0
#endif
#if wxUSE_DRAG_AND_DROP
#undef wxUSE_DRAG_AND_DROP
#define wxUSE_DRAG_AND_DROP 0
#endif
#if wxUSE_TASKBARICON
#undef wxUSE_TASKBARICON
#define wxUSE_TASKBARICON 0
#endif
#if wxUSE_TOOLTIPS
#undef wxUSE_TOOLTIPS
#define wxUSE_TOOLTIPS 0
#endif
#if wxUSE_DATAVIEWCTRL
#undef wxUSE_DATAVIEWCTRL
#define wxUSE_DATAVIEWCTRL 0
#endif
#if wxUSE_TREELISTCTRL
#undef wxUSE_TREELISTCTRL
#define wxUSE_TREELISTCTRL 0
#endif
#if wxUSE_DRAG_AND_DROP
#undef wxUSE_DRAG_AND_DROP
#define wxUSE_DRAG_AND_DROP 0
#endif
#if wxUSE_TASKBARICON
#undef wxUSE_TASKBARICON
#define wxUSE_TASKBARICON 0
#endif
#define wxUSE_BUTTON 1
#if wxUSE_CARET
#undef wxUSE_CARET
#define wxUSE_CARET 0
#endif
#if wxUSE_CHOICE
#undef wxUSE_CHOICE
#define wxUSE_CHOICE 0
#endif
#if wxUSE_COMBOBOX
#undef wxUSE_COMBOBOX
#define wxUSE_COMBOBOX 0
#endif
#ifndef __WXUNIVERSAL__
#undef wxUSE_SCROLLBAR
#define wxUSE_SCROLLBAR 0
#endif
#undef wxUSE_STATUSBAR
#undef wxUSE_NATIVE_STATUSBAR
#undef wxUSE_ABOUTDLG
#undef wxUSE_STATLINE
#undef wxUSE_COLLPANE
#undef wxUSE_STATBMP
#undef wxUSE_STATBOX
#undef wxUSE_RADIOBTN
#undef wxUSE_RADIOBOX
#undef wxUSE_TOGGLEBTN
#define wxUSE_STATUSBAR 0
#define wxUSE_NATIVE_STATUSBAR 0
#define wxUSE_ABOUTDLG 0
#define wxUSE_STATLINE 0
#define wxUSE_COLLPANE 0
#define wxUSE_STATBMP 0
#define wxUSE_STATBOX 0
#define wxUSE_RADIOBTN 0
#define wxUSE_RADIOBOX 0
#define wxUSE_TOGGLEBTN 0
#undef wxUSE_HTML
#define wxUSE_HTML 0
#undef wxUSE_RICHTEXT
#define wxUSE_RICHTEXT 0
#undef wxUSE_ACTIVITYINDICATOR
#undef wxUSE_ADDREMOVECTRL
#undef wxUSE_ANIMATIONCTRL
#undef wxUSE_CALENDARCTRL
#undef wxUSE_COMBOCTRL
#undef wxUSE_ODCOMBOBOX
#undef wxUSE_BITMAPCOMBOBOX
#undef wxUSE_BMPBUTTON
#undef wxUSE_CHECKLISTBOX
#undef wxUSE_GRID
#undef wxUSE_LISTBOX
#undef wxUSE_LISTCTRL
#undef wxUSE_NOTEBOOK
#undef wxUSE_SPINBTN
#undef wxUSE_SPINCTRL
#undef wxUSE_TREECTRL
#undef wxUSE_DATEPICKCTRL
#undef wxUSE_DATAVIEWCTRL
#undef wxUSE_EDITABLELISTBOX
#undef wxUSE_FILEPICKERCTRL
#undef wxUSE_DIRPICKERCTRL
#undef wxUSE_FILECTRL
#undef wxUSE_COLOURPICKERCTRL
#undef wxUSE_FONTPICKERCTRL
#undef wxUSE_DEBUGREPORT
#undef wxUSE_HYPERLINKCTRL
#undef wxUSE_STC
#undef wxUSE_AUI
#undef wxUSE_BUSYINFO
#undef wxUSE_SEARCHCTRL
#define wxUSE_ACTIVITYINDICATOR 0
#define wxUSE_ADDREMOVECTRL 0
#define wxUSE_ANIMATIONCTRL 0
#define wxUSE_CALENDARCTRL 0
#define wxUSE_COMBOCTRL 0
#define wxUSE_ODCOMBOBOX 0
#define wxUSE_BITMAPCOMBOBOX 0
#define wxUSE_BMPBUTTON 0
#define wxUSE_CHECKLISTBOX 0
#define wxUSE_GRID 0
#define wxUSE_LISTBOX 0
#define wxUSE_LISTCTRL 0
#define wxUSE_NOTEBOOK 0
#define wxUSE_SPINBTN 0
#define wxUSE_SPINCTRL 0
#define wxUSE_TREECTRL 0
#define wxUSE_DATEPICKCTRL 0
#define wxUSE_DATAVIEWCTRL 0
#define wxUSE_EDITABLELISTBOX 0
#define wxUSE_FILEPICKERCTRL 0
#define wxUSE_DIRPICKERCTRL 0
#define wxUSE_FILECTRL 0
#define wxUSE_COLOURPICKERCTRL 0
#define wxUSE_FONTPICKERCTRL 0
#define wxUSE_DEBUGREPORT 0
#define wxUSE_HYPERLINKCTRL 0
#define wxUSE_STC 0
#define wxUSE_AUI 0
#define wxUSE_BUSYINFO 0
#define wxUSE_SEARCHCTRL 0
#undef wxUSE_LOGWINDOW
#undef wxUSE_LOG_DIALOG
#undef wxUSE_LISTBOOK
#undef wxUSE_CHOICEBOOK
#undef wxUSE_TREEBOOK
#undef wxUSE_TOOLBOOK
#undef wxUSE_CHOICEDLG
#undef wxUSE_HELP
#undef wxUSE_PROGRESSDLG
#undef wxUSE_FONTDLG
#undef wxUSE_FILEDLG
#undef wxUSE_CHOICEDLG
#undef wxUSE_NUMBERDLG
#undef wxUSE_TEXTDLG
#undef wxUSE_DIRDLG
#undef wxUSE_STARTUP_TIPS
#undef wxUSE_WIZARDDLG
#undef wxUSE_TOOLBAR_NATIVE
#undef wxUSE_FINDREPLDLG
#undef wxUSE_TASKBARICON
#undef wxUSE_REARRANGECTRL
#define wxUSE_LOGWINDOW 0
#define wxUSE_LOG_DIALOG 0
#define wxUSE_LISTBOOK 0
#define wxUSE_CHOICEBOOK 0
#define wxUSE_TREEBOOK 0
#define wxUSE_TOOLBOOK 0
#define wxUSE_CHOICEDLG 0
#define wxUSE_HELP 0
#define wxUSE_PROGRESSDLG 0
#define wxUSE_FONTDLG 0
#define wxUSE_FILEDLG 0
#define wxUSE_CHOICEDLG 0
#define wxUSE_NUMBERDLG 0
#define wxUSE_TEXTDLG 0
#define wxUSE_DIRDLG 0
#define wxUSE_STARTUP_TIPS 0
#define wxUSE_WIZARDDLG 0
#define wxUSE_TOOLBAR_NATIVE 0
#define wxUSE_FINDREPLDLG 0
#define wxUSE_TASKBARICON 0
#define wxUSE_REARRANGECTRL 0
#if wxUSE_WXHTML_HELP
#undef wxUSE_WXHTML_HELP
#define wxUSE_WXHTML_HELP 0
#endif
#if wxUSE_DOC_VIEW_ARCHITECTURE
#undef wxUSE_DOC_VIEW_ARCHITECTURE
#define wxUSE_DOC_VIEW_ARCHITECTURE 0
#endif
#if wxUSE_PRINTING_ARCHITECTURE
#undef wxUSE_PRINTING_ARCHITECTURE
#define wxUSE_PRINTING_ARCHITECTURE 0
#endif
#if wxUSE_MENUS
#undef wxUSE_MENUS
#define wxUSE_MENUS 0
#endif
/*
#if wxUSE_POPUPWIN
#undef wxUSE_POPUPWIN
#define wxUSE_POPUPWIN 0
#endif
#if wxUSE_COMBOBOX
#undef wxUSE_COMBOBOX
#define wxUSE_COMBOBOX 0
#endif
#if wxUSE_CALENDARCTRL
#undef wxUSE_CALENDARCTRL
#define wxUSE_CALENDARCTRL 0
#endif
*/
#if wxUSE_CLIPBOARD
#undef wxUSE_CLIPBOARD
#define wxUSE_CLIPBOARD 0
#endif // wxUSE_CLIPBOARD
/*
#if wxUSE_GLCANVAS
#undef wxUSE_GLCANVAS
#define wxUSE_GLCANVAS 0
#endif // wxUSE_GLCANVAS
*/
#if wxUSE_COLOURDLG
#undef wxUSE_COLOURDLG
#define wxUSE_COLOURDLG 0
#endif // wxUSE_COLOURDLG
// iphone has a toolbar that is a regular UIView
#ifdef wxOSX_USE_NATIVE_TOOLBAR
#if wxOSX_USE_NATIVE_TOOLBAR
#undef wxOSX_USE_NATIVE_TOOLBAR
#define wxOSX_USE_NATIVE_TOOLBAR 0
#endif
#else
#define wxOSX_USE_NATIVE_TOOLBAR 0
#endif
#if wxUSE_RIBBON
#undef wxUSE_RIBBON
#define wxUSE_RIBBON 0
#endif
#if wxUSE_INFOBAR
#undef wxUSE_INFOBAR
#define wxUSE_INFOBAR 0
#endif
#if wxUSE_FILE_HISTORY
#undef wxUSE_FILE_HISTORY
#define wxUSE_FILE_HISTORY 0
#endif
#if wxUSE_NOTIFICATION_MESSAGE
#undef wxUSE_NOTIFICATION_MESSAGE
#define wxUSE_NOTIFICATION_MESSAGE 0
#endif
#undef wxUSE_PREFERENCES_EDITOR
#define wxUSE_PREFERENCES_EDITOR 0
#if wxUSE_PROPGRID
#undef wxUSE_PROPGRID
#define wxUSE_PROPGRID 0
#endif
#if wxUSE_WEBKIT
#undef wxUSE_WEBKIT
#define wxUSE_WEBKIT 0
#endif
#if wxUSE_DATAOBJ
#undef wxUSE_DATAOBJ
#define wxUSE_DATAOBJ 0
#endif
#if wxUSE_UIACTIONSIMULATOR
#undef wxUSE_UIACTIONSIMULATOR
#define wxUSE_UIACTIONSIMULATOR 0
#endif
#if wxUSE_RICHMSGDLG
#undef wxUSE_RICHMSGDLG
#define wxUSE_RICHMSGDLG 0
#endif
#if wxUSE_RICHTEXT
#undef wxUSE_RICHTEXT
#define wxUSE_RICHTEXT 0
#endif
#if wxUSE_TIMEPICKCTRL
#undef wxUSE_TIMEPICKCTRL
#define wxUSE_TIMEPICKCTRL 0
#endif
#if wxUSE_RICHTOOLTIP
#undef wxUSE_RICHTOOLTIP
#define wxUSE_RICHTOOLTIP 0
#endif
#if wxUSE_WEBVIEW
#undef wxUSE_WEBVIEW
#define wxUSE_WEBVIEW 0
#endif
#if wxUSE_SECRETSTORE
#undef wxUSE_SECRETSTORE
#define wxUSE_SECRETSTORE 0
#endif
// IconRef datatype does not exist on iOS
#undef wxOSX_USE_ICONREF
#define wxOSX_USE_ICONREF 0
#endif
/* _WX_OSX_IPHONE_CHKCONF_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/iphone/private/textimpl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/iphone/private/textimpl.h
// Purpose: textcontrol implementation classes that have to be exposed
// Author: Stefan Csomor
// Modified by:
// Created: 03/02/99
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_COCOA_PRIVATE_TEXTIMPL_H_
#define _WX_OSX_COCOA_PRIVATE_TEXTIMPL_H_
#include "wx/combobox.h"
#include "wx/osx/private.h"
// implementation exposed, so that search control can pull it
class wxUITextFieldControl : public wxWidgetIPhoneImpl, public wxTextWidgetImpl
{
public :
wxUITextFieldControl( wxTextCtrl *wxPeer, UITextField* w );
virtual ~wxUITextFieldControl();
virtual wxString GetStringValue() const ;
virtual void SetStringValue( const wxString &str) ;
virtual void Copy() ;
virtual void Cut() ;
virtual void Paste() ;
virtual bool CanPaste() const ;
virtual void SetEditable(bool editable) ;
virtual void GetSelection( long* from, long* to) const ;
virtual void SetSelection( long from , long to );
virtual void WriteText(const wxString& str) ;
virtual bool HasOwnContextMenu() const { return true; }
virtual wxSize GetBestSize() const;
virtual bool SetHint(const wxString& hint);
virtual void controlAction(WXWidget slf, void* _cmd, void *sender);
protected :
UITextField* m_textField;
NSObject<UITextFieldDelegate>* m_delegate;
long m_selStart;
long m_selEnd;
};
class wxUITextViewControl : public wxWidgetIPhoneImpl, public wxTextWidgetImpl
{
public:
wxUITextViewControl( wxTextCtrl *wxPeer, UITextView* w );
virtual ~wxUITextViewControl();
virtual wxString GetStringValue() const ;
virtual void SetStringValue( const wxString &str) ;
virtual void Copy() ;
virtual void Cut() ;
virtual void Paste() ;
virtual bool CanPaste() const ;
virtual void SetEditable(bool editable) ;
virtual void GetSelection( long* from, long* to) const ;
virtual void SetSelection( long from , long to );
virtual void WriteText(const wxString& str) ;
virtual void SetFont( const wxFont & font , const wxColour& foreground , long windowStyle, bool ignoreBlack = true );
virtual bool GetStyle(long position, wxTextAttr& style);
virtual void SetStyle(long start, long end, const wxTextAttr& style);
virtual bool CanFocus() const;
virtual bool HasOwnContextMenu() const { return true; }
virtual void CheckSpelling(bool check);
virtual wxSize GetBestSize() const;
protected:
NSObject<UITextViewDelegate>* m_delegate;
UITextView* m_textView;
};
#if 0
class wxNSComboBoxControl : public wxUITextFieldControl, public wxComboWidgetImpl
{
public :
wxNSComboBoxControl( wxWindow *wxPeer, WXWidget w );
virtual ~wxNSComboBoxControl();
virtual int GetSelectedItem() const;
virtual void SetSelectedItem(int item);
virtual int GetNumberOfItems() const;
virtual void InsertItem(int pos, const wxString& item);
virtual void RemoveItem(int pos);
virtual void Clear();
virtual wxString GetStringAtIndex(int pos) const;
virtual int FindString(const wxString& text) const;
private:
NSComboBox* m_comboBox;
};
#endif
#endif // _WX_OSX_COCOA_PRIVATE_TEXTIMPL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/stdpaths.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/stdpaths.h
// Purpose: wxStandardPaths for Cocoa
// Author: Tobias Taschner
// Created: 2015-09-09
// Copyright: (c) 2015 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COCOA_STDPATHS_H_
#define _WX_COCOA_STDPATHS_H_
// ----------------------------------------------------------------------------
// wxStandardPaths
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStandardPaths : public wxStandardPathsBase
{
public:
virtual ~wxStandardPaths();
// implement base class pure virtuals
virtual wxString GetExecutablePath() const wxOVERRIDE;
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
virtual wxString GetDataDir() const wxOVERRIDE;
virtual wxString GetLocalDataDir() const wxOVERRIDE;
virtual wxString GetUserDataDir() const wxOVERRIDE;
virtual wxString GetPluginsDir() const wxOVERRIDE;
virtual wxString GetResourcesDir() const wxOVERRIDE;
virtual wxString
GetLocalizedResourcesDir(const wxString& lang,
ResourceCat category = ResourceCat_None) const wxOVERRIDE;
virtual wxString GetUserDir(Dir userDir) const wxOVERRIDE;
virtual wxString MakeConfigFileName(const wxString& basename,
ConfigFileConv conv = ConfigFileConv_Ext
) const wxOVERRIDE;
protected:
// Ctor is protected, use wxStandardPaths::Get() instead of instantiating
// objects of this class directly.
wxStandardPaths();
};
#endif // _WX_COCOA_STDPATHS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/evtloop.h
// Purpose: declaration of wxGUIEventLoop for wxOSX/Cocoa
// Author: Vadim Zeitlin
// Created: 2008-12-28
// Copyright: (c) 2006 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_COCOA_EVTLOOP_H_
#define _WX_OSX_COCOA_EVTLOOP_H_
class WXDLLIMPEXP_BASE wxGUIEventLoop : public wxCFEventLoop
{
public:
wxGUIEventLoop();
~wxGUIEventLoop();
void BeginModalSession( wxWindow* modalWindow );
void EndModalSession();
virtual void WakeUp();
void OSXUseLowLevelWakeup(bool useIt)
{ m_osxLowLevelWakeUp = useIt ; }
protected:
virtual int DoDispatchTimeout(unsigned long timeout);
virtual void OSXDoRun();
virtual void OSXDoStop();
virtual CFRunLoopRef CFGetCurrentRunLoop() const;
void* m_modalSession;
wxWindow* m_modalWindow;
WXWindow m_dummyWindow;
int m_modalNestedLevel;
bool m_osxLowLevelWakeUp;
};
#endif // _WX_OSX_COCOA_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/dataview.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/dataview.h
// Purpose: wxDataViewCtrl native implementation header for carbon
// Author:
// Copyright: (c) 2009
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DATAVIEWCTRL_COCOOA_H_
#define _WX_DATAVIEWCTRL_COCOOA_H_
#include "wx/defs.h"
#import <Cocoa/Cocoa.h>
#include "wx/osx/core/dataview.h"
#include "wx/osx/private.h"
// Forward declaration
class wxCocoaDataViewControl;
/*
Dramatis personae:
[vertical arrows indicate inheritance, horizontal -- aggregation]
wxWindow ---> wxWidgetCocoaImpl wxDataViewWidgetImpl NSOutlineView
| \ / |
| \ / |
| \ / |
v \/ \/ v
wxDataViewCtrl -------> wxCocoaDataViewControl <-------> wxCocoaOutlineView
The right most classes are Objective-C only and can't be used from (pure)
C++ code.
*/
// ============================================================================
// wxPointerObject: simply stores a pointer, without taking its ownership
// ============================================================================
// Two pointer objects are equal if the containing pointers are equal. This
// means also that the hash value of a pointer object depends only on the
// stored pointer.
@interface wxPointerObject : NSObject
{
void* pointer;
}
-(id) initWithPointer:(void*)initPointer;
-(void*) pointer;
-(void) setPointer:(void*)newPointer;
@end
// ============================================================================
// wxSortDescriptorObject: helper class to use native sorting facilities
// ============================================================================
@interface wxSortDescriptorObject : NSSortDescriptor<NSCopying>
{
wxDataViewColumn* columnPtr; // pointer to the sorting column
wxDataViewModel* modelPtr; // pointer to model
}
-(id)
initWithModelPtr:(wxDataViewModel*)initModelPtr
sortingColumnPtr:(wxDataViewColumn*)initColumnPtr
ascending:(BOOL)sortAscending;
-(wxDataViewColumn*) columnPtr;
-(wxDataViewModel*) modelPtr;
-(void) setColumnPtr:(wxDataViewColumn*)newColumnPtr;
-(void) setModelPtr:(wxDataViewModel*)newModelPtr;
@end
// ============================================================================
// wxDataViewColumnNativeData: extra data for wxDataViewColumn
// ============================================================================
class wxDataViewColumnNativeData
{
public:
wxDataViewColumnNativeData() : m_NativeColumnPtr(NULL)
{
}
wxDataViewColumnNativeData(NSTableColumn* initNativeColumnPtr)
: m_NativeColumnPtr(initNativeColumnPtr)
{
}
NSTableColumn* GetNativeColumnPtr() const
{
return m_NativeColumnPtr;
}
void SetNativeColumnPtr(NSTableColumn* newNativeColumnPtr)
{
m_NativeColumnPtr = newNativeColumnPtr;
}
private:
// not owned by us
NSTableColumn* m_NativeColumnPtr;
};
// ============================================================================
// wxDataViewRendererNativeData: extra data for wxDataViewRenderer
// ============================================================================
class wxDataViewRendererNativeData
{
public:
wxDataViewRendererNativeData()
: m_Object(NULL), m_ColumnCell(NULL), m_ItemCell(NULL)
{
Init();
}
wxDataViewRendererNativeData(NSCell* initColumnCell)
: m_Object(NULL), m_ColumnCell([initColumnCell retain]), m_ItemCell(NULL)
{
Init();
}
wxDataViewRendererNativeData(NSCell* initColumnCell, id initObject)
: m_Object([initObject retain]), m_ColumnCell([initColumnCell retain]), m_ItemCell(NULL)
{
Init();
}
~wxDataViewRendererNativeData()
{
[m_ColumnCell release];
[m_Object release];
[m_origFont release];
[m_origTextColour release];
}
NSCell* GetColumnCell() const { return m_ColumnCell; }
NSTableColumn* GetColumnPtr() const { return m_TableColumnPtr; }
id GetItem() const { return m_Item; }
NSCell* GetItemCell() const { return m_ItemCell; }
id GetObject() const { return m_Object; }
void SetColumnCell(NSCell* newCell)
{
[newCell retain];
[m_ColumnCell release];
m_ColumnCell = newCell;
}
void SetColumnPtr(NSTableColumn* newColumnPtr)
{
m_TableColumnPtr = newColumnPtr;
}
void SetItem(id newItem)
{
m_Item = newItem;
}
void SetItemCell(NSCell* newCell)
{
m_ItemCell = newCell;
}
void SetObject(id newObject)
{
[newObject retain];
[m_Object release];
m_Object = newObject;
}
// The original cell font and text colour stored here are NULL by default
// and are only initialized to the values retrieved from the cell when we
// change them from wxCocoaOutlineView:willDisplayCell:forTableColumn:item:
// which calls our SaveOriginalXXX() methods before changing the cell
// attributes.
//
// This allows us to avoid doing anything for the columns without any
// attributes but still be able to restore the correct attributes for the
// ones that do.
NSFont *GetOriginalFont() const { return m_origFont; }
NSColor *GetOriginalTextColour() const { return m_origTextColour; }
void SaveOriginalFont(NSFont *font)
{
m_origFont = [font retain];
}
void SaveOriginalTextColour(NSColor *textColour)
{
m_origTextColour = [textColour retain];
}
// The ellipsization mode which we need to set for each cell being rendered.
void SetEllipsizeMode(wxEllipsizeMode mode) { m_ellipsizeMode = mode; }
wxEllipsizeMode GetEllipsizeMode() const { return m_ellipsizeMode; }
// Set the line break mode for the given cell using our m_ellipsizeMode
void ApplyLineBreakMode(NSCell *cell);
// Does the rendered use a font that the control can't override?
void SetHasCustomFont(bool has) { m_hasCustomFont = has; }
bool HasCustomFont() const { return m_hasCustomFont; }
private:
// common part of all ctors
void Init();
id m_Item; // item NOT owned by renderer
// object that can be used by renderer for storing special data (owned by
// renderer)
id m_Object;
NSCell* m_ColumnCell; // column's cell is owned by renderer
NSCell* m_ItemCell; // item's cell is NOT owned by renderer
NSTableColumn* m_TableColumnPtr; // column NOT owned by renderer
// we own those if they're non-NULL
NSFont *m_origFont;
NSColor *m_origTextColour;
wxEllipsizeMode m_ellipsizeMode;
bool m_hasCustomFont;
};
// ============================================================================
// wxCocoaOutlineDataSource
// ============================================================================
// This class implements the data source delegate for the outline view.
// As only an informal protocol exists this class inherits from NSObject only.
//
// As mentioned in the documentation for NSOutlineView the native control does
// not own any data. Therefore, it has to be done by the data source.
// Unfortunately, wxWidget's data source is a C++ data source but
// NSOutlineDataSource requires objects as data. Therefore, the data (or better
// the native item objects) have to be stored additionally in the native data
// source.
// NSOutlineView requires quick access to the item objects and quick linear
// access to an item's children. This requires normally a hash type of storage
// for the item object itself and an array structure for each item's children.
// This means that basically two times the whole structure of wxWidget's model
// class has to be stored.
// This implementation is using a compromise: all items that are in use by the
// control are stored in a set (from there they can be easily retrieved) and
// owned by the set. Furthermore, children of the last parent are stored
// in a linear list.
//
@interface wxCocoaOutlineDataSource : NSObject <NSOutlineViewDataSource>
{
// descriptors specifying the sorting (currently the array only holds one
// object only)
NSArray* sortDescriptors;
NSMutableArray* children; // buffered children
NSMutableSet* items; // stores all items that are in use by the control
wxCocoaDataViewControl* implementation;
wxDataViewModel* model;
// parent of the buffered children; the object is owned
wxPointerObject* currentParentItem;
}
// methods of informal protocol:
-(BOOL)
outlineView:(NSOutlineView*)outlineView
acceptDrop:(id<NSDraggingInfo>)info
item:(id)item
childIndex:(NSInteger)index;
-(id)
outlineView:(NSOutlineView*)outlineView
child:(NSInteger)index
ofItem:(id)item;
-(id)
outlineView:(NSOutlineView*)outlineView
objectValueForTableColumn:(NSTableColumn*)tableColumn
byItem:(id)item;
-(BOOL)
outlineView:(NSOutlineView*)outlineView
isItemExpandable:(id)item;
-(NSInteger)
outlineView:(NSOutlineView*)outlineView
numberOfChildrenOfItem:(id)item;
-(NSDragOperation)
outlineView:(NSOutlineView*)outlineView
validateDrop:(id<NSDraggingInfo>)info
proposedItem:(id)item
proposedChildIndex:(NSInteger)index;
-(BOOL)
outlineView:(NSOutlineView*)outlineView
writeItems:(NSArray*)items
toPasteboard:(NSPasteboard*)pasteboard;
// buffer for items handling
-(void) addToBuffer:(wxPointerObject*)item;
-(void) clearBuffer;
// returns the item in the buffer that has got the same pointer as "item",
// if such an item does not exist nil is returned
-(wxPointerObject*) getDataViewItemFromBuffer:(const wxDataViewItem&)item;
-(wxPointerObject*) getItemFromBuffer:(wxPointerObject*)item;
-(BOOL) isInBuffer:(wxPointerObject*)item;
-(void) removeFromBuffer:(wxPointerObject*)item;
// buffered children handling
-(void) clearChildren;
-(wxPointerObject*) getChild:(NSUInteger)index;
-(NSUInteger) getChildCount;
// buffer handling
-(void) clearBuffers;
// sorting
-(NSArray*) sortDescriptors;
-(void) setSortDescriptors:(NSArray*)newSortDescriptors;
// access to wxWidgets variables
-(wxPointerObject*) currentParentItem;
-(wxCocoaDataViewControl*) implementation;
-(wxDataViewModel*) model;
-(void) setCurrentParentItem:(wxPointerObject*)newCurrentParentItem;
-(void) setImplementation:(wxCocoaDataViewControl*)newImplementation;
-(void) setModel:(wxDataViewModel*)newModel;
// other methods
-(void)
bufferItem:(wxPointerObject*)parentItem
withChildren:(wxDataViewItemArray*)dataViewChildrenPtr;
@end
// ============================================================================
// wxCustomCell: used for custom renderers
// ============================================================================
@interface wxCustomCell : NSTextFieldCell
{
}
-(NSSize) cellSize;
@end
// ============================================================================
// wxImageCell: used for bitmap renderer
// ============================================================================
@interface wxImageCell : NSImageCell
{
}
-(NSSize) cellSize;
@end
// ============================================================================
// NSTextFieldCell customized to allow vertical alignment
// ============================================================================
@interface wxTextFieldCell : NSTextFieldCell
{
@private
int alignment_;
BOOL adjustRect_;
}
-(void) setWXAlignment:(int)alignment;
@end
// ============================================================================
// wxImageTextCell
// ============================================================================
//
// As the native cocoa environment does not have a cell displaying an icon/
// image and text at the same time, it has to be implemented by the user.
// This implementation follows the implementation of Chuck Pisula in Apple's
// DragNDropOutline sample application.
// Although in wxDataViewCtrl icons are used on OSX icons do not exist for
// display. Therefore, the cell is also called wxImageTextCell.
// Instead of displaying images of any size (which is possible) this cell uses
// a fixed size for displaying the image. Larger images are scaled to fit
// into their reserved space. Smaller or not existing images use the fixed
// reserved size and are scaled if necessary.
//
@interface wxImageTextCell : wxTextFieldCell
{
@private
CGFloat xImageShift; // shift for the image in x-direction from border
CGFloat spaceImageText; // space between image and text
NSImage* image; // the image itself
NSSize imageSize; // largest size of the image; default size is (16, 16)
// the text alignment is used to align the whole cell (image and text)
NSTextAlignment cellAlignment;
}
-(NSTextAlignment) alignment;
-(void) setAlignment:(NSTextAlignment)newAlignment;
-(NSImage*) image;
-(void) setImage:(NSImage*)newImage;
-(NSSize) imageSize;
-(void) setImageSize:(NSSize) newImageSize;
-(NSSize) cellSize;
@end
// ============================================================================
// wxCocoaOutlineView
// ============================================================================
@interface wxCocoaOutlineView : NSOutlineView <NSOutlineViewDelegate>
{
@private
// column and row of the cell being edited or -1 if none
int currentlyEditedColumn,
currentlyEditedRow;
wxCocoaDataViewControl* implementation;
}
-(wxCocoaDataViewControl*) implementation;
-(void) setImplementation:(wxCocoaDataViewControl*) newImplementation;
@end
// ============================================================================
// wxCocoaDataViewControl
// ============================================================================
// This is the internal interface class between wxDataViewCtrl (wxWidget) and
// the native source view (Mac OS X cocoa).
class wxCocoaDataViewControl : public wxWidgetCocoaImpl,
public wxDataViewWidgetImpl
{
public:
// constructors / destructor
wxCocoaDataViewControl(wxWindow* peer,
const wxPoint& pos,
const wxSize& size,
long style);
virtual ~wxCocoaDataViewControl();
wxDataViewCtrl* GetDataViewCtrl() const
{
return static_cast<wxDataViewCtrl*>(GetWXPeer());
}
// column related methods (inherited from wxDataViewWidgetImpl)
virtual bool ClearColumns();
virtual bool DeleteColumn(wxDataViewColumn* columnPtr);
virtual void DoSetExpanderColumn(wxDataViewColumn const* columnPtr);
virtual wxDataViewColumn* GetColumn(unsigned int pos) const;
virtual int GetColumnPosition(wxDataViewColumn const* columnPtr) const;
virtual bool InsertColumn(unsigned int pos, wxDataViewColumn* columnPtr);
virtual void FitColumnWidthToContent(unsigned int pos);
// item related methods (inherited from wxDataViewWidgetImpl)
virtual bool Add(const wxDataViewItem& parent, const wxDataViewItem& item);
virtual bool Add(const wxDataViewItem& parent,
const wxDataViewItemArray& items);
virtual void Collapse(const wxDataViewItem& item);
virtual void EnsureVisible(const wxDataViewItem& item,
wxDataViewColumn const* columnPtr);
virtual unsigned int GetCount() const;
virtual int GetCountPerPage() const;
virtual wxRect GetRectangle(const wxDataViewItem& item,
wxDataViewColumn const* columnPtr);
virtual wxDataViewItem GetTopItem() const;
virtual bool IsExpanded(const wxDataViewItem& item) const;
virtual bool Reload();
virtual bool Remove(const wxDataViewItem& parent,
const wxDataViewItem& item);
virtual bool Remove(const wxDataViewItem& parent,
const wxDataViewItemArray& item);
virtual bool Update(const wxDataViewColumn* columnPtr);
virtual bool Update(const wxDataViewItem& parent,
const wxDataViewItem& item);
virtual bool Update(const wxDataViewItem& parent,
const wxDataViewItemArray& items);
// model related methods
virtual bool AssociateModel(wxDataViewModel* model);
//
// selection related methods (inherited from wxDataViewWidgetImpl)
//
virtual wxDataViewItem GetCurrentItem() const;
virtual void SetCurrentItem(const wxDataViewItem& item);
virtual wxDataViewColumn *GetCurrentColumn() const;
virtual int GetSelectedItemsCount() const;
virtual int GetSelections(wxDataViewItemArray& sel) const;
virtual bool IsSelected(const wxDataViewItem& item) const;
virtual void Select(const wxDataViewItem& item);
virtual void SelectAll();
virtual void Unselect(const wxDataViewItem& item);
virtual void UnselectAll();
//
// sorting related methods
//
virtual wxDataViewColumn* GetSortingColumn () const;
virtual void Resort();
//
// other methods (inherited from wxDataViewWidgetImpl)
//
virtual void DoSetIndent(int indent);
virtual void DoExpand(const wxDataViewItem& item);
virtual void HitTest(const wxPoint& point,
wxDataViewItem& item,
wxDataViewColumn*& columnPtr) const;
virtual void SetRowHeight(int height);
virtual void SetRowHeight(const wxDataViewItem& item, unsigned int height);
virtual void OnSize();
virtual void StartEditor( const wxDataViewItem & item, unsigned int column );
// drag & drop helper methods
wxDataFormat GetDnDDataFormat(wxDataObjectComposite* dataObjects);
wxDataObjectComposite* GetDnDDataObjects(NSData* dataObject) const;
// Cocoa-specific helpers
id GetItemAtRow(int row) const;
virtual void SetFont(const wxFont& font, const wxColour& foreground, long windowStyle, bool ignoreBlack = true);
private:
void InitOutlineView(long style);
int GetDefaultRowHeight() const;
wxCocoaOutlineDataSource* m_DataSource;
wxCocoaOutlineView* m_OutlineView;
};
#endif // _WX_DATAVIEWCTRL_COCOOA_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/private.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/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: Stefan Csomor
// Modified by:
// Created: 1998-01-01
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_COCOA_H_
#define _WX_PRIVATE_COCOA_H_
#include <ApplicationServices/ApplicationServices.h>
#ifdef __OBJC__
#import <Cocoa/Cocoa.h>
#endif
//
// shared between Cocoa and Carbon
//
// bring in theming types without pulling in the headers
#if wxUSE_GUI
typedef SInt16 ThemeBrush;
CGColorRef WXDLLIMPEXP_CORE wxMacCreateCGColorFromHITheme( ThemeBrush brush ) ;
OSStatus WXDLLIMPEXP_CORE wxMacDrawCGImage(
CGContextRef inContext,
const CGRect * inBounds,
CGImageRef inImage) ;
void WXDLLIMPEXP_CORE wxOSXDrawNSImage(
CGContextRef inContext,
const CGRect * inBounds,
WX_NSImage inImage) ;
WX_NSImage WXDLLIMPEXP_CORE wxOSXGetSystemImage(const wxString& name);
WX_NSImage WXDLLIMPEXP_CORE wxOSXGetNSImageFromCGImage( CGImageRef image, double scale = 1.0, bool isTemplate = false);
WX_NSImage WXDLLIMPEXP_CORE wxOSXGetNSImageFromIconRef( WXHICON iconref );
WX_NSImage WXDLLIMPEXP_CORE wxOSXGetIconForType(OSType type );
void WXDLLIMPEXP_CORE wxOSXSetImageSize(WX_NSImage image, CGFloat width, CGFloat height);
wxBitmap WXDLLIMPEXP_CORE wxOSXCreateSystemBitmap(const wxString& id, const wxString &client, const wxSize& size);
WXWindow WXDLLIMPEXP_CORE wxOSXGetMainWindow();
WXWindow WXDLLIMPEXP_CORE wxOSXGetKeyWindow();
class WXDLLIMPEXP_FWD_CORE wxDialog;
class WXDLLIMPEXP_CORE wxWidgetCocoaImpl : public wxWidgetImpl
{
public :
wxWidgetCocoaImpl( wxWindowMac* peer , WXWidget w, bool isRootControl = false, bool isUserPane = false ) ;
wxWidgetCocoaImpl() ;
~wxWidgetCocoaImpl();
void Init();
virtual bool IsVisible() const ;
virtual void SetVisibility(bool);
// we provide a static function which can be reused from
// wxNonOwnedWindowCocoaImpl too
static bool ShowViewOrWindowWithEffect(wxWindow *win,
bool show,
wxShowEffect effect,
unsigned timeout);
virtual bool ShowWithEffect(bool show,
wxShowEffect effect,
unsigned timeout);
virtual void Raise();
virtual void Lower();
virtual void ScrollRect( const wxRect *rect, int dx, int dy );
virtual WXWidget GetWXWidget() const { return m_osxView; }
virtual void SetBackgroundColour(const wxColour&);
virtual bool SetBackgroundStyle(wxBackgroundStyle style);
virtual void GetContentArea( int &left , int &top , int &width , int &height ) const;
virtual void Move(int x, int y, int width, int height);
virtual void GetPosition( int &x, int &y ) const;
virtual void GetSize( int &width, int &height ) const;
virtual void SetControlSize( wxWindowVariant variant );
virtual void SetNeedsDisplay( const wxRect* where = NULL );
virtual bool GetNeedsDisplay() const;
virtual void SetDrawingEnabled(bool enabled);
virtual bool CanFocus() const;
// return true if successful
virtual bool SetFocus();
virtual bool HasFocus() const;
void RemoveFromParent();
void Embed( wxWidgetImpl *parent );
void SetDefaultButton( bool isDefault );
void PerformClick();
virtual void SetLabel(const wxString& title, wxFontEncoding encoding);
void SetCursor( const wxCursor & cursor );
void CaptureMouse();
void ReleaseMouse();
#if wxUSE_DRAG_AND_DROP
void SetDropTarget(wxDropTarget* target);
#endif
wxInt32 GetValue() const;
void SetValue( wxInt32 v );
wxBitmap GetBitmap() const;
void SetBitmap( const wxBitmap& bitmap );
void SetBitmapPosition( wxDirection dir );
void SetupTabs( const wxNotebook ¬ebook );
void GetBestRect( wxRect *r ) const;
bool IsEnabled() const;
void Enable( bool enable );
bool ButtonClickDidStateChange() { return true ;}
void SetMinimum( wxInt32 v );
void SetMaximum( wxInt32 v );
wxInt32 GetMinimum() const;
wxInt32 GetMaximum() const;
void PulseGauge();
void SetScrollThumb( wxInt32 value, wxInt32 thumbSize );
void SetFont( const wxFont & font , const wxColour& foreground , long windowStyle, bool ignoreBlack = true );
void SetToolTip( wxToolTip* tooltip );
void InstallEventHandler( WXWidget control = NULL );
bool EnableTouchEvents(int eventsMask);
virtual bool ShouldHandleKeyNavigation(const wxKeyEvent &event) const;
bool DoHandleKeyNavigation(const wxKeyEvent &event);
virtual bool DoHandleMouseEvent(NSEvent *event);
virtual bool DoHandleKeyEvent(NSEvent *event);
virtual bool DoHandleCharEvent(NSEvent *event, NSString *text);
virtual void DoNotifyFocusSet();
virtual void DoNotifyFocusLost();
virtual void DoNotifyFocusEvent(bool receivedFocus, wxWidgetImpl* otherWindow);
virtual void SetupKeyEvent(wxKeyEvent &wxevent, NSEvent * nsEvent, NSString* charString = NULL);
virtual void SetupMouseEvent(wxMouseEvent &wxevent, NSEvent * nsEvent);
void SetupCoordinates(wxCoord &x, wxCoord &y, NSEvent *nsEvent);
virtual bool SetupCursor(NSEvent* event);
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_10
virtual void PanGestureEvent(NSPanGestureRecognizer *panGestureRecognizer);
virtual void ZoomGestureEvent(NSMagnificationGestureRecognizer *magnificationGestureRecognizer);
virtual void RotateGestureEvent(NSRotationGestureRecognizer *rotationGestureRecognizer);
virtual void LongPressEvent(NSPressGestureRecognizer *pressGestureRecognizer);
virtual void TouchesBegan(NSEvent *event);
virtual void TouchesMoved(NSEvent *event);
virtual void TouchesEnded(NSEvent *event);
#endif // MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_10
#if !wxOSX_USE_NATIVE_FLIPPED
void SetFlipped(bool flipped);
virtual bool IsFlipped() const { return m_isFlipped; }
#endif
virtual double GetContentScaleFactor() const;
// cocoa thunk connected calls
#if wxUSE_DRAG_AND_DROP
virtual unsigned int draggingEntered(void* sender, WXWidget slf, void* _cmd);
virtual void draggingExited(void* sender, WXWidget slf, void* _cmd);
virtual unsigned int draggingUpdated(void* sender, WXWidget slf, void* _cmd);
virtual bool performDragOperation(void* sender, WXWidget slf, void* _cmd);
#endif
virtual void mouseEvent(WX_NSEvent event, WXWidget slf, void* _cmd);
virtual void cursorUpdate(WX_NSEvent event, WXWidget slf, void* _cmd);
virtual void keyEvent(WX_NSEvent event, WXWidget slf, void* _cmd);
virtual void insertText(NSString* text, WXWidget slf, void* _cmd);
virtual void doCommandBySelector(void* sel, WXWidget slf, void* _cmd);
virtual bool performKeyEquivalent(WX_NSEvent event, WXWidget slf, void* _cmd);
virtual bool acceptsFirstResponder(WXWidget slf, void* _cmd);
virtual bool becomeFirstResponder(WXWidget slf, void* _cmd);
virtual bool resignFirstResponder(WXWidget slf, void* _cmd);
#if !wxOSX_USE_NATIVE_FLIPPED
virtual bool isFlipped(WXWidget slf, void* _cmd);
#endif
virtual void drawRect(void* rect, WXWidget slf, void* _cmd);
virtual void controlAction(WXWidget slf, void* _cmd, void* sender);
virtual void controlDoubleAction(WXWidget slf, void* _cmd, void *sender);
// for wxTextCtrl-derived classes, put here since they don't all derive
// from the same pimpl class.
virtual void controlTextDidChange();
protected:
WXWidget m_osxView;
NSEvent* m_lastKeyDownEvent;
#if !wxOSX_USE_NATIVE_FLIPPED
bool m_isFlipped;
#endif
// if it the control has an editor, that editor will already send some
// events, don't resend them
bool m_hasEditor;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxWidgetCocoaImpl);
};
DECLARE_WXCOCOA_OBJC_CLASS( wxNSWindow );
class wxNonOwnedWindowCocoaImpl : public wxNonOwnedWindowImpl
{
public :
wxNonOwnedWindowCocoaImpl( wxNonOwnedWindow* nonownedwnd) ;
wxNonOwnedWindowCocoaImpl();
virtual ~wxNonOwnedWindowCocoaImpl();
virtual void WillBeDestroyed() wxOVERRIDE;
void Create( wxWindow* parent, const wxPoint& pos, const wxSize& size,
long style, long extraStyle, const wxString& name ) wxOVERRIDE;
void Create( wxWindow* parent, WXWindow nativeWindow );
WXWindow GetWXWindow() const wxOVERRIDE;
void Raise() wxOVERRIDE;
void Lower() wxOVERRIDE;
bool Show(bool show) wxOVERRIDE;
virtual bool ShowWithEffect(bool show,
wxShowEffect effect,
unsigned timeout) wxOVERRIDE;
void Update() wxOVERRIDE;
bool SetTransparent(wxByte alpha) wxOVERRIDE;
bool SetBackgroundColour(const wxColour& col ) wxOVERRIDE;
void SetExtraStyle( long exStyle ) wxOVERRIDE;
void SetWindowStyleFlag( long style ) wxOVERRIDE;
bool SetBackgroundStyle(wxBackgroundStyle style) wxOVERRIDE;
bool CanSetTransparent() wxOVERRIDE;
void MoveWindow(int x, int y, int width, int height) wxOVERRIDE;
void GetPosition( int &x, int &y ) const wxOVERRIDE;
void GetSize( int &width, int &height ) const wxOVERRIDE;
void GetContentArea( int &left , int &top , int &width , int &height ) const wxOVERRIDE;
bool SetShape(const wxRegion& region) wxOVERRIDE;
virtual void SetTitle( const wxString& title, wxFontEncoding encoding ) wxOVERRIDE;
virtual bool EnableCloseButton(bool enable) wxOVERRIDE;
virtual bool EnableMaximizeButton(bool enable) wxOVERRIDE;
virtual bool EnableMinimizeButton(bool enable) wxOVERRIDE;
virtual bool IsMaximized() const wxOVERRIDE;
virtual bool IsIconized() const wxOVERRIDE;
virtual void Iconize( bool iconize ) wxOVERRIDE;
virtual void Maximize(bool maximize) wxOVERRIDE;
virtual bool IsFullScreen() const wxOVERRIDE;
bool EnableFullScreenView(bool enable) wxOVERRIDE;
virtual bool ShowFullScreen(bool show, long style) wxOVERRIDE;
virtual void ShowWithoutActivating() wxOVERRIDE;
virtual void RequestUserAttention(int flags) wxOVERRIDE;
virtual void ScreenToWindow( int *x, int *y ) wxOVERRIDE;
virtual void WindowToScreen( int *x, int *y ) wxOVERRIDE;
virtual bool IsActive() wxOVERRIDE;
virtual void SetModified(bool modified) wxOVERRIDE;
virtual bool IsModified() const wxOVERRIDE;
virtual void SetRepresentedFilename(const wxString& filename) wxOVERRIDE;
wxNonOwnedWindow* GetWXPeer() { return m_wxPeer; }
CGWindowLevel GetWindowLevel() const wxOVERRIDE { return m_macWindowLevel; }
void RestoreWindowLevel() wxOVERRIDE;
static WX_NSResponder GetNextFirstResponder() ;
static WX_NSResponder GetFormerFirstResponder() ;
protected :
CGWindowLevel m_macWindowLevel;
WXWindow m_macWindow;
void * m_macFullScreenData ;
private:
void SetUpForModalParent();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxNonOwnedWindowCocoaImpl);
};
DECLARE_WXCOCOA_OBJC_CLASS( wxNSButton );
class wxButtonCocoaImpl : public wxWidgetCocoaImpl, public wxButtonImpl
{
public:
wxButtonCocoaImpl(wxWindowMac *wxpeer, wxNSButton *v);
virtual void SetBitmap(const wxBitmap& bitmap);
#if wxUSE_MARKUP
virtual void SetLabelMarkup(const wxString& markup);
#endif // wxUSE_MARKUP
void SetPressedBitmap( const wxBitmap& bitmap );
void GetLayoutInset(int &left , int &top , int &right, int &bottom) const;
void SetAcceleratorFromLabel(const wxString& label);
NSButton *GetNSButton() const;
};
#ifdef __OBJC__
typedef NSRect WXRect;
typedef void (*wxOSX_TextEventHandlerPtr)(NSView* self, SEL _cmd, NSString *event);
typedef void (*wxOSX_EventHandlerPtr)(NSView* self, SEL _cmd, NSEvent *event);
typedef BOOL (*wxOSX_PerformKeyEventHandlerPtr)(NSView* self, SEL _cmd, NSEvent *event);
typedef BOOL (*wxOSX_FocusHandlerPtr)(NSView* self, SEL _cmd);
WXDLLIMPEXP_CORE NSScreen* wxOSXGetMenuScreen();
WXDLLIMPEXP_CORE NSRect wxToNSRect( NSView* parent, const wxRect& r );
WXDLLIMPEXP_CORE wxRect wxFromNSRect( NSView* parent, const NSRect& rect );
WXDLLIMPEXP_CORE NSPoint wxToNSPoint( NSView* parent, const wxPoint& p );
WXDLLIMPEXP_CORE wxPoint wxFromNSPoint( NSView* parent, const NSPoint& p );
NSRect WXDLLIMPEXP_CORE wxOSXGetFrameForControl( wxWindowMac* window , const wxPoint& pos , const wxSize &size ,
bool adjustForOrigin = true );
WXDLLIMPEXP_CORE NSView* wxOSXGetViewFromResponder( NSResponder* responder );
// used for many wxControls
@interface wxNSButton : NSButton
{
NSTrackingRectTag rectTag;
}
@end
@interface wxNSBox : NSBox
{
}
@end
@interface wxNSTextFieldEditor : NSTextView
{
NSEvent* lastKeyDownEvent;
NSTextField* textField;
}
- (void) setTextField:(NSTextField*) field;
@end
@interface wxNSTextField : NSTextField <NSTextFieldDelegate>
{
wxNSTextFieldEditor* fieldEditor;
}
- (wxNSTextFieldEditor*) fieldEditor;
- (void) setFieldEditor:(wxNSTextFieldEditor*) fieldEditor;
@end
@interface wxNSSecureTextField : NSSecureTextField <NSTextFieldDelegate>
{
}
@end
@interface wxNSTextView : NSTextView <NSTextViewDelegate>
{
}
- (void)textDidChange:(NSNotification *)aNotification;
- (void)changeColor:(id)sender;
@end
@interface wxNSComboBox : NSComboBox
{
wxNSTextFieldEditor* fieldEditor;
}
- (wxNSTextFieldEditor*) fieldEditor;
- (void) setFieldEditor:(wxNSTextFieldEditor*) fieldEditor;
@end
@interface wxNSMenu : NSMenu
{
wxMenuImpl* impl;
}
- (void) setImplementation:(wxMenuImpl*) item;
- (wxMenuImpl*) implementation;
@end
@interface wxNSMenuItem : NSMenuItem
{
wxMenuItemImpl* impl;
}
- (void) setImplementation:(wxMenuItemImpl*) item;
- (wxMenuItemImpl*) implementation;
- (void)clickedAction:(id)sender;
- (BOOL)validateMenuItem:(NSMenuItem *)menuItem;
@end
// this enum declares which methods should not be overridden in the native view classes
enum wxOSXSkipOverrides {
wxOSXSKIP_NONE = 0x0,
wxOSXSKIP_DRAW = 0x1
};
void WXDLLIMPEXP_CORE wxOSXCocoaClassAddWXMethods(Class c, wxOSXSkipOverrides skipFlags = wxOSXSKIP_NONE);
/*
We need this for ShowModal, as the sheet just disables the parent window and
returns control to the app, whereas we don't want to return from ShowModal
until the sheet has been dismissed.
*/
@interface ModalDialogDelegate : NSObject
{
BOOL sheetFinished;
int resultCode;
wxDialog* impl;
}
- (void)setImplementation: (wxDialog *)dialog;
- (BOOL)finished;
- (int)code;
- (void)waitForSheetToFinish;
- (void)sheetDidEnd:(NSWindow *)sheet returnCode:(int)returnCode contextInfo:(void *)contextInfo;
@end
// This interface must be exported in shared 64 bit multilib build but
// using WXEXPORT with Objective C interfaces doesn't work with old (4.0.1)
// gcc when using 10.4 SDK. It does work with newer gcc even in 32 bit
// builds but seems to be unnecessary there so to avoid the expense of a
// configure check verifying if this does work or not with the current
// compiler we just only use it for 64 bit builds where this is always
// supported.
//
// NB: Currently this is the only place where we need to export an
// interface but if we need to do it elsewhere we should define a
// WXEXPORT_OBJC macro once and reuse it in all places it's needed
// instead of duplicating this preprocessor check.
#ifdef __LP64__
WXEXPORT
#endif // 64 bit builds
@interface wxNSAppController : NSObject <NSApplicationDelegate>
{
}
@end
#endif // __OBJC__
// NSCursor
WX_NSCursor wxMacCocoaCreateStockCursor( int cursor_type );
WX_NSCursor wxMacCocoaCreateCursorFromCGImage( CGImageRef cgImageRef, float hotSpotX, float hotSpotY );
void wxMacCocoaSetCursor( WX_NSCursor cursor );
void wxMacCocoaHideCursor();
void wxMacCocoaShowCursor();
typedef struct tagClassicCursor
{
wxUint16 bits[16];
wxUint16 mask[16];
wxInt16 hotspot[2];
}ClassicCursor;
const short kwxCursorBullseye = 0;
const short kwxCursorBlank = 1;
const short kwxCursorPencil = 2;
const short kwxCursorMagnifier = 3;
const short kwxCursorNoEntry = 4;
const short kwxCursorPaintBrush = 5;
const short kwxCursorPointRight = 6;
const short kwxCursorPointLeft = 7;
const short kwxCursorQuestionArrow = 8;
const short kwxCursorRightArrow = 9;
const short kwxCursorSizeNS = 10;
const short kwxCursorSize = 11;
const short kwxCursorSizeNESW = 12;
const short kwxCursorSizeNWSE = 13;
const short kwxCursorRoller = 14;
const short kwxCursorWatch = 15;
const short kwxCursorLast = kwxCursorWatch;
// exposing our fallback cursor map
extern ClassicCursor gMacCursors[];
extern NSLayoutManager* gNSLayoutManager;
// NSString<->wxString
wxString wxStringWithNSString(NSString *nsstring);
NSString* wxNSStringWithWxString(const wxString &wxstring);
// helper class for setting the current appearance to the
// effective appearance and restore when exiting scope
class WXDLLIMPEXP_CORE wxOSXEffectiveAppearanceSetter
{
public:
wxOSXEffectiveAppearanceSetter();
~wxOSXEffectiveAppearanceSetter();
private:
void * formerAppearance;
};
#endif // wxUSE_GUI
#endif
// _WX_PRIVATE_COCOA_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/chkconf.h | /*
* Name: wx/osx/cocoa/chkconf.h
* Purpose: Compiler-specific configuration checking
* Author: Stefan Csomor
* Modified by:
* Created: 2008-07-30
* Copyright: (c) Stefan Csomor
* Licence: wxWindows licence
*/
#ifndef _WX_OSX_COCOA_CHKCONF_H_
#define _WX_OSX_COCOA_CHKCONF_H_
/*
* native (1) or emulated (0) toolbar
*/
#ifndef wxOSX_USE_NATIVE_TOOLBAR
#define wxOSX_USE_NATIVE_TOOLBAR 1
#endif
/*
* leave is isFlipped and don't override
*/
#ifndef wxOSX_USE_NATIVE_FLIPPED
#define wxOSX_USE_NATIVE_FLIPPED 1
#endif
/*
* Audio System
*/
#define wxOSX_USE_QUICKTIME 0
#define wxOSX_USE_AUDIOTOOLBOX 1
/*
Use the more efficient FSEvents API instead of kqueue
events for file system watcher since that version introduced a flag that
allows watching files as well as sub directories.
*/
#define wxHAVE_FSEVENTS_FILE_NOTIFICATIONS 1
/*
* turn off old style icon format if not asked for
*/
#ifndef wxOSX_USE_ICONREF
#define wxOSX_USE_ICONREF 0
#endif
/*
* turning off capabilities that don't work under cocoa yet
*/
#endif
/* _WX_MAC_CHKCONF_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/private/date.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/private/date.h
// Purpose: NSDate-related helpers
// Author: Vadim Zeitlin
// Created: 2011-12-19
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_COCOA_PRIVATE_DATE_H_
#define _WX_OSX_COCOA_PRIVATE_DATE_H_
#include "wx/datetime.h"
namespace wxOSXImpl
{
// Functions to convert between NSDate and wxDateTime.
// Returns an NSDate corresponding to the given wxDateTime which can be invalid
// (in which case nil is returned).
inline NSDate* NSDateFromWX(const wxDateTime& dt)
{
if ( !dt.IsValid() )
return nil;
// Get the internal representation as a double used by NSDate.
double ticks = dt.GetValue().ToDouble();
// wxDateTime uses milliseconds while NSDate uses (fractional) seconds.
return [NSDate dateWithTimeIntervalSince1970:ticks/1000.];
}
// Returns wxDateTime corresponding to the given NSDate (which may be nil).
inline wxDateTime NSDateToWX(const NSDate* d)
{
if ( !d )
return wxDefaultDateTime;
// Reverse everything done above.
wxLongLong ll;
ll.Assign([d timeIntervalSince1970]*1000);
wxDateTime dt(ll);
return dt;
}
} // namespace wxOSXImpl
#endif // _WX_OSX_COCOA_PRIVATE_DATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/private/textimpl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/private/textimpl.h
// Purpose: textcontrol implementation classes that have to be exposed
// Author: Stefan Csomor
// Modified by:
// Created: 03/02/99
// Copyright: (c) Stefan Csomor
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_COCOA_PRIVATE_TEXTIMPL_H_
#define _WX_OSX_COCOA_PRIVATE_TEXTIMPL_H_
#include "wx/combobox.h"
#include "wx/osx/private.h"
@class wxTextEntryFormatter;
class wxNSTextBase : public wxWidgetCocoaImpl, public wxTextWidgetImpl
{
public :
wxNSTextBase( wxTextCtrl *text, WXWidget w )
: wxWidgetCocoaImpl(text, w),
wxTextWidgetImpl(text)
{
}
wxNSTextBase( wxWindow *wxPeer, wxTextEntry *entry, WXWidget w )
: wxWidgetCocoaImpl(wxPeer, w),
wxTextWidgetImpl(entry)
{
}
virtual ~wxNSTextBase() { }
virtual bool ShouldHandleKeyNavigation(const wxKeyEvent &event) const wxOVERRIDE;
};
// implementation exposed, so that search control can pull it
class wxNSTextFieldControl : public wxNSTextBase
{
public :
// wxNSTextFieldControl must always be associated with a wxTextEntry. If
// it's associated with a wxTextCtrl then we can get the associated entry
// from it but otherwise the second ctor should be used to explicitly pass
// us the entry.
wxNSTextFieldControl( wxTextCtrl *text, WXWidget w );
wxNSTextFieldControl( wxWindow *wxPeer, wxTextEntry *entry, WXWidget w );
virtual ~wxNSTextFieldControl();
virtual bool CanClipMaxLength() const wxOVERRIDE { return true; }
virtual void SetMaxLength(unsigned long len) wxOVERRIDE;
virtual bool CanForceUpper() wxOVERRIDE { return true; }
virtual void ForceUpper() wxOVERRIDE;
virtual wxString GetStringValue() const wxOVERRIDE ;
virtual void SetStringValue( const wxString &str) wxOVERRIDE ;
virtual void Copy() wxOVERRIDE ;
virtual void Cut() wxOVERRIDE ;
virtual void Paste() wxOVERRIDE ;
virtual bool CanPaste() const wxOVERRIDE ;
virtual void SetEditable(bool editable) wxOVERRIDE ;
virtual long GetLastPosition() const wxOVERRIDE;
virtual void GetSelection( long* from, long* to) const wxOVERRIDE ;
virtual void SetSelection( long from , long to ) wxOVERRIDE;
virtual bool PositionToXY(long pos, long *x, long *y) const wxOVERRIDE;
virtual long XYToPosition(long x, long y) const wxOVERRIDE;
virtual void ShowPosition(long pos) wxOVERRIDE;
virtual void WriteText(const wxString& str) wxOVERRIDE ;
virtual bool HasOwnContextMenu() const wxOVERRIDE { return true; }
virtual bool SetHint(const wxString& hint) wxOVERRIDE;
virtual void SetJustification() wxOVERRIDE;
virtual void controlAction(WXWidget slf, void* _cmd, void *sender) wxOVERRIDE;
virtual bool becomeFirstResponder(WXWidget slf, void *_cmd) wxOVERRIDE;
virtual bool resignFirstResponder(WXWidget slf, void *_cmd) wxOVERRIDE;
virtual void SetInternalSelection( long from , long to );
virtual void UpdateInternalSelectionFromEditor( wxNSTextFieldEditor* editor);
protected :
NSTextField* m_textField;
long m_selStart;
long m_selEnd;
private:
// Common part of both ctors.
void Init(WXWidget w);
// Get our formatter, creating it if necessary.
wxTextEntryFormatter* GetFormatter();
};
class wxNSTextViewControl : public wxNSTextBase
{
public:
wxNSTextViewControl( wxTextCtrl *wxPeer, WXWidget w, long style );
virtual ~wxNSTextViewControl();
virtual void insertText(NSString* text, WXWidget slf, void *_cmd) wxOVERRIDE;
virtual wxString GetStringValue() const wxOVERRIDE ;
virtual void SetStringValue( const wxString &str) wxOVERRIDE ;
virtual void Copy() wxOVERRIDE ;
virtual void Cut() wxOVERRIDE ;
virtual void Paste() wxOVERRIDE ;
virtual bool CanPaste() const wxOVERRIDE ;
virtual void SetEditable(bool editable) wxOVERRIDE ;
virtual long GetLastPosition() const wxOVERRIDE;
virtual void GetSelection( long* from, long* to) const wxOVERRIDE ;
virtual void SetSelection( long from , long to ) wxOVERRIDE;
virtual bool PositionToXY(long pos, long *x, long *y) const wxOVERRIDE;
virtual long XYToPosition(long x, long y) const wxOVERRIDE;
virtual void ShowPosition(long pos) wxOVERRIDE;
virtual void WriteText(const wxString& str) wxOVERRIDE ;
virtual void SetFont( const wxFont & font , const wxColour& foreground , long windowStyle, bool ignoreBlack = true ) wxOVERRIDE;
virtual bool GetStyle(long position, wxTextAttr& style) wxOVERRIDE;
virtual void SetStyle(long start, long end, const wxTextAttr& style) wxOVERRIDE;
virtual bool CanFocus() const wxOVERRIDE;
virtual bool HasOwnContextMenu() const wxOVERRIDE { return true; }
virtual void CheckSpelling(bool check) wxOVERRIDE;
virtual void EnableAutomaticQuoteSubstitution(bool enable) wxOVERRIDE;
virtual void EnableAutomaticDashSubstitution(bool enable) wxOVERRIDE;
virtual wxSize GetBestSize() const wxOVERRIDE;
virtual void SetJustification() wxOVERRIDE;
virtual void controlTextDidChange() wxOVERRIDE;
protected:
void DoUpdateTextStyle();
NSScrollView* m_scrollView;
NSTextView* m_textView;
bool m_useCharWrapping;
};
class wxNSComboBoxControl : public wxNSTextFieldControl, public wxComboWidgetImpl
{
public :
wxNSComboBoxControl( wxComboBox *wxPeer, WXWidget w );
virtual ~wxNSComboBoxControl();
virtual int GetSelectedItem() const;
virtual void SetSelectedItem(int item);
virtual int GetNumberOfItems() const;
virtual void InsertItem(int pos, const wxString& item);
virtual void RemoveItem(int pos);
virtual void Clear();
virtual wxString GetStringAtIndex(int pos) const;
virtual int FindString(const wxString& text) const;
virtual void Popup();
virtual void Dismiss();
virtual void SetEditable(bool editable);
virtual void mouseEvent(WX_NSEvent event, WXWidget slf, void *_cmd);
private:
NSComboBox* m_comboBox;
};
#endif // _WX_OSX_COCOA_PRIVATE_TEXTIMPL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/private/overlay.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/private/overlay.h
// Purpose: wxOverlayImpl declaration
// Author: Stefan Csomor
// Modified by:
// Created: 2006-10-20
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_COCOA_PRIVATE_OVERLAY_H_
#define _WX_OSX_COCOA_PRIVATE_OVERLAY_H_
#include "wx/osx/private.h"
#include "wx/toplevel.h"
#include "wx/graphics.h"
class wxOverlayImpl
{
public:
wxOverlayImpl() ;
~wxOverlayImpl() ;
// clears the overlay without restoring the former state
// to be done eg when the window content has been changed and repainted
void Reset();
// returns true if it has been setup
bool IsOk();
void Init( wxDC* dc, int x , int y , int width , int height );
void BeginDrawing( wxDC* dc);
void EndDrawing( wxDC* dc);
void Clear( wxDC* dc);
private:
void CreateOverlayWindow( wxDC* dc );
WXWindow m_overlayWindow;
WXWindow m_overlayParentWindow;
CGContextRef m_overlayContext ;
// we store the window in case we would have to issue a Refresh()
wxWindow* m_window ;
int m_x ;
int m_y ;
int m_width ;
int m_height ;
} ;
#endif // _WX_MAC_CARBON_PRIVATE_OVERLAY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/osx/cocoa/private/markuptoattr.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/cocoa/private/markuptoattr.h
// Purpose: Class to convert markup to Cocoa attributed strings.
// Author: Vadim Zeitlin
// Created: 2011-02-22
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_COCOA_PRIVATE_MARKUPTOATTR_H_
#define _WX_OSX_COCOA_PRIVATE_MARKUPTOATTR_H_
#include "wx/private/markupparserattr.h"
// ----------------------------------------------------------------------------
// wxMarkupToAttrString: create NSAttributedString from markup.
// ----------------------------------------------------------------------------
class wxMarkupToAttrStringBase : public wxMarkupParserAttrOutput
{
protected:
// We don't care about the original colours because we never use them but
// we do need the correct initial font as we apply modifiers (e.g. create a
// font larger than it) to it and so it must be valid.
wxMarkupToAttrStringBase(const wxFont& font)
: wxMarkupParserAttrOutput(font, wxColour(), wxColour()),
m_attrString(NULL)
{}
void Parse(const wxFont& font, const wxString& markup)
{
const wxCFStringRef label(PrepareText(wxMarkupParser::Strip(markup)));
m_attrString = [[NSMutableAttributedString alloc]
initWithString: label.AsNSString()];
m_pos = 0;
[m_attrString beginEditing];
// First thing we do is change the default string font: as mentioned in
// Apple documentation, attributed strings use "Helvetica 12" font by
// default which is different from the system "Lucida Grande" font. So
// we need to explicitly change the font for the entire string.
[m_attrString addAttribute:NSFontAttributeName
value:font.OSXGetNSFont()
range:NSMakeRange(0, [m_attrString length])];
// Now translate the markup tags to corresponding attributes.
wxMarkupParser parser(*this);
parser.Parse(markup);
[m_attrString endEditing];
}
~wxMarkupToAttrStringBase()
{
if ( m_attrString )
[m_attrString release];
}
// prepare text chunk for display, e.g. strip mnemonics from it
virtual wxString PrepareText(const wxString& text) = 0;
public:
// Accessor for the users of this class.
//
// We keep ownership of the returned string.
NSMutableAttributedString *GetNSAttributedString() const
{
return m_attrString;
}
// Implement base class pure virtual methods to process markup tags.
virtual void OnText(const wxString& text)
{
m_pos += PrepareText(text).length();
}
virtual void OnAttrStart(const Attr& WXUNUSED(attr))
{
// Just remember the starting position of the range, we can't really
// set the attribute until we find the end of it.
m_rangeStarts.push(m_pos);
}
virtual void OnAttrEnd(const Attr& attr)
{
unsigned start = m_rangeStarts.top();
m_rangeStarts.pop();
const NSRange range = NSMakeRange(start, m_pos - start);
[m_attrString addAttribute:NSFontAttributeName
value:attr.font.OSXGetNSFont()
range:range];
if ( attr.foreground.IsOk() )
{
[m_attrString addAttribute:NSForegroundColorAttributeName
value:attr.foreground.OSXGetNSColor()
range:range];
}
if ( attr.background.IsOk() )
{
[m_attrString addAttribute:NSBackgroundColorAttributeName
value:attr.background.OSXGetNSColor()
range:range];
}
}
private:
// The attributed string we're building.
NSMutableAttributedString *m_attrString;
// The current position in the output string.
unsigned m_pos;
// The positions of starting ranges.
wxStack<unsigned> m_rangeStarts;
};
// for use with labels with mnemonics
class wxMarkupToAttrString : public wxMarkupToAttrStringBase
{
public:
wxMarkupToAttrString(const wxFont& font, const wxString& markup)
: wxMarkupToAttrStringBase(font)
{
Parse(font, markup);
}
protected:
virtual wxString PrepareText(const wxString& text)
{
return wxControl::RemoveMnemonics(text);
}
wxDECLARE_NO_COPY_CLASS(wxMarkupToAttrString);
};
// for raw markup with no mnemonics
class wxItemMarkupToAttrString : public wxMarkupToAttrStringBase
{
public:
wxItemMarkupToAttrString(const wxFont& font, const wxString& markup)
: wxMarkupToAttrStringBase(font)
{
Parse(font, markup);
}
protected:
virtual wxString PrepareText(const wxString& text)
{
return text;
}
wxDECLARE_NO_COPY_CLASS(wxItemMarkupToAttrString);
};
#endif // _WX_OSX_COCOA_PRIVATE_MARKUPTOATTR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/dcclient.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/dcclient.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDCCLIENTH__
#define __GTKDCCLIENTH__
#include "wx/gtk1/dc.h"
#include "wx/window.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxWindowDCImpl;
class WXDLLIMPEXP_FWD_CORE wxPaintDCImpl;
class WXDLLIMPEXP_FWD_CORE wxClientDCImpl;
//-----------------------------------------------------------------------------
// wxWindowDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDCImpl : public wxGTKDCImpl
{
public:
wxWindowDCImpl(wxDC *owner);
wxWindowDCImpl(wxDC *owner, wxWindow *win);
virtual ~wxWindowDCImpl();
virtual bool CanDrawBitmap() const { return true; }
virtual bool CanGetTextExtent() const { return true; }
protected:
virtual void DoGetSize(int *width, int *height) const;
virtual bool DoFloodFill( wxCoord x, wxCoord y, const wxColour& col, wxFloodFillStyle style=wxFLOOD_SURFACE );
virtual bool DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const;
virtual void DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 );
virtual void DoCrossHair( wxCoord x, wxCoord y );
virtual void DoDrawArc( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc );
virtual void DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord width, wxCoord height,
double sa, double ea );
virtual void DoDrawPoint( wxCoord x, wxCoord y );
virtual void DoDrawLines(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset);
virtual void DoDrawPolygon(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
virtual void DoDrawRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
virtual void DoDrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius = 20.0 );
virtual void DoDrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
virtual void DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y );
virtual void DoDrawBitmap( const wxBitmap &bitmap, wxCoord x, wxCoord y,
bool useMask = false );
virtual bool DoBlit( wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
wxDC *source, wxCoord xsrc, wxCoord ysrc,
wxRasterOperationMode logical_func = wxCOPY, bool useMask = false,
wxCoord xsrcMask = -1, wxCoord ysrcMask = -1 );
virtual void DoDrawText( const wxString &text, wxCoord x, wxCoord y );
virtual void DoDrawRotatedText(const wxString& text, wxCoord x, wxCoord y,
double angle);
virtual void DoGetTextExtent( const wxString &string,
wxCoord *width, wxCoord *height,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
const wxFont *theFont = NULL) const;
public:
virtual wxCoord GetCharWidth() const;
virtual wxCoord GetCharHeight() const;
virtual void Clear();
virtual void SetFont( const wxFont &font );
virtual void SetPen( const wxPen &pen );
virtual void SetBrush( const wxBrush &brush );
virtual void SetBackground( const wxBrush &brush );
virtual void SetLogicalFunction( wxRasterOperationMode function );
virtual void SetTextForeground( const wxColour &col );
virtual void SetTextBackground( const wxColour &col );
virtual void SetBackgroundMode( int mode );
virtual void SetPalette( const wxPalette& palette );
virtual void DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height );
virtual void DestroyClippingRegion();
virtual void DoSetDeviceClippingRegion( const wxRegion ®ion );
// Resolution in pixels per logical inch
virtual wxSize GetPPI() const;
virtual int GetDepth() const;
virtual GdkWindow* GetGDKWindow() const { return m_window; }
// implementation
// --------------
GdkWindow *m_window;
GdkGC *m_penGC;
GdkGC *m_brushGC;
GdkGC *m_textGC;
GdkGC *m_bgGC;
GdkColormap *m_cmap;
bool m_isMemDC;
bool m_isScreenDC;
wxWindow *m_owner;
wxRegion m_currentClippingRegion;
wxRegion m_paintClippingRegion;
void SetUpDC();
void Destroy();
virtual void ComputeScaleAndOrigin();
GdkWindow *GetWindow() { return m_window; }
private:
wxDECLARE_DYNAMIC_CLASS(wxWindowDCImpl);
};
//-----------------------------------------------------------------------------
// wxClientDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
{
public:
wxClientDCImpl(wxDC *owner) : wxWindowDCImpl(owner) { }
wxClientDCImpl(wxDC *owner, wxWindow *win);
protected:
virtual void DoGetSize(int *width, int *height) const;
private:
wxDECLARE_DYNAMIC_CLASS(wxClientDCImpl);
};
//-----------------------------------------------------------------------------
// wxPaintDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
{
public:
wxPaintDCImpl(wxDC *owner) : wxClientDCImpl(owner) { }
wxPaintDCImpl(wxDC *owner, wxWindow *win);
private:
wxDECLARE_DYNAMIC_CLASS(wxPaintDCImpl);
};
#endif // __GTKDCCLIENTH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/font.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/font.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKFONTH__
#define __GTKFONTH__
#include "wx/hash.h"
// ----------------------------------------------------------------------------
// classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxDC;
class WXDLLIMPEXP_FWD_CORE wxPaintDC;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxFont;
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFont : public wxFontBase
{
public:
// ctors and such
wxFont() { }
wxFont(const wxFontInfo& info)
{
Create(info.GetPointSize(),
info.GetFamily(),
info.GetStyle(),
info.GetWeight(),
info.IsUnderlined(),
info.GetFaceName(),
info.GetEncoding());
if ( info.IsUsingSizeInPixels() )
SetPixelSize(info.GetPixelSize());
}
wxFont(const wxString& fontname)
{
Create(fontname);
}
wxFont(const wxNativeFontInfo& info);
wxFont(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(size, family, style, weight, underlined, face, encoding);
}
wxFont(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(10, family, style, weight, underlined, face, encoding);
SetPixelSize(pixelSize);
}
bool Create(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
// wxGTK-specific
bool Create(const wxString& fontname);
virtual ~wxFont();
// implement base class pure virtuals
virtual float GetFractionalPointSize() const;
virtual wxFontStyle GetStyle() const;
virtual int GetNumericWeight() const;
virtual wxString GetFaceName() const;
virtual bool GetUnderlined() const;
virtual wxFontEncoding GetEncoding() const;
virtual const wxNativeFontInfo *GetNativeFontInfo() const;
virtual bool IsFixedWidth() const;
virtual void SetFractionalPointSize(float pointSize);
virtual void SetFamily(wxFontFamily family);
virtual void SetStyle(wxFontStyle style);
virtual void SetNumericWeight(int weight);
virtual bool SetFaceName( const wxString& faceName );
virtual void SetUnderlined( bool underlined );
virtual void SetEncoding(wxFontEncoding encoding);
wxDECLARE_COMMON_FONT_METHODS();
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants")
wxFont(int size,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(size, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight, underlined, face, encoding);
}
// implementation from now on
void Unshare();
GdkFont* GetInternalFont(float scale = 1.0) const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const;
virtual void DoSetNativeFontInfo( const wxNativeFontInfo& info );
virtual wxFontFamily DoGetFamily() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxFont);
};
#endif // __GTKFONTH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/app.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKAPPH__
#define __GTKAPPH__
#include "wx/frame.h"
#include "wx/icon.h"
#include "wx/strconv.h"
typedef struct _GdkVisual GdkVisual;
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxApp;
class WXDLLIMPEXP_FWD_BASE wxLog;
//-----------------------------------------------------------------------------
// wxApp
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxApp: public wxAppBase
{
public:
wxApp();
virtual ~wxApp();
/* override for altering the way wxGTK initializes the GUI
* (palette/visual/colorcube). under wxMSW, OnInitGui() does nothing by
* default. when overriding this method, the code in it is likely to be
* platform dependent, otherwise use OnInit(). */
virtual bool OnInitGui();
// override base class (pure) virtuals
virtual void WakeUpIdle();
virtual bool Initialize(int& argc, wxChar **argv);
virtual void CleanUp();
static bool InitialzeVisual();
virtual void OnAssertFailure(const wxChar *file,
int line,
const wxChar *func,
const wxChar *cond,
const wxChar *msg);
bool IsInAssert() const { return m_isInAssert; }
int m_idleTag;
void RemoveIdleTag();
unsigned char *m_colorCube;
// Used by the wxGLApp and wxGLCanvas class for GL-based X visual
// selection.
void *m_glVisualInfo; // this is actually an XVisualInfo*
void *m_glFBCInfo; // this is actually an GLXFBConfig*
// This returns the current visual: either that used by wxRootWindow
// or the XVisualInfo* for SGI.
GdkVisual *GetGdkVisual();
private:
// true if we're inside an assert modal dialog
bool m_isInAssert;
wxDECLARE_DYNAMIC_CLASS(wxApp);
};
#endif // __GTKAPPH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/dcmemory.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/dcmemory.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKDCMEMORYH__
#define __GTKDCMEMORYH__
#include "wx/dcmemory.h"
#include "wx/gtk1/dcclient.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxMemoryDCImpl;
//-----------------------------------------------------------------------------
// wxMemoryDCImpl
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMemoryDCImpl : public wxWindowDCImpl
{
public:
wxMemoryDCImpl(wxMemoryDC *owner)
: wxWindowDCImpl(owner)
{
Init();
}
wxMemoryDCImpl(wxMemoryDC *owner, wxBitmap& bitmap)
: wxWindowDCImpl(owner)
{
Init();
DoSelect(bitmap);
}
wxMemoryDCImpl(wxMemoryDC *owner, wxDC *dc);
virtual ~wxMemoryDCImpl();
virtual void DoSelect(const wxBitmap& bitmap);
virtual void DoGetSize( int *width, int *height ) const;
// these get reimplemented for mono-bitmaps to behave
// more like their Win32 couterparts. They now interpret
// wxWHITE, wxWHITE_BRUSH and wxWHITE_PEN as drawing 0
// and everything else as drawing 1.
virtual void SetPen( const wxPen &pen );
virtual void SetBrush( const wxBrush &brush );
virtual void SetBackground( const wxBrush &brush );
virtual void SetTextForeground( const wxColour &col );
virtual void SetTextBackground( const wxColour &col );
// implementation
wxBitmap m_selected;
private:
void Init();
wxDECLARE_DYNAMIC_CLASS(wxMemoryDCImpl);
};
#endif // __GTKDCMEMORYH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/toplevel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/toplevel.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKTOPLEVELH__
#define __GTKTOPLEVELH__
//-----------------------------------------------------------------------------
// wxTopLevelWindowGTK
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindowGTK : public wxTopLevelWindowBase
{
public:
// construction
wxTopLevelWindowGTK() { Init(); }
wxTopLevelWindowGTK(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual ~wxTopLevelWindowGTK();
// implement base class pure virtuals
virtual void Maximize(bool maximize = true);
virtual bool IsMaximized() const;
virtual void Iconize(bool iconize = true);
virtual bool IsIconized() const;
virtual void SetIcons(const wxIconBundle& icons);
virtual void Restore();
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL);
virtual bool IsFullScreen() const { return m_fsIsShowing; }
virtual bool SetShape(const wxRegion& region);
virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO);
virtual void SetWindowStyleFlag( long style );
virtual bool Show(bool show = true);
virtual void Raise();
virtual bool IsActive();
virtual void SetTitle( const wxString &title );
virtual wxString GetTitle() const { return m_title; }
// Experimental, to allow help windows to be
// viewable from within modal dialogs
virtual void AddGrab();
virtual void RemoveGrab();
virtual bool IsGrabbed() const { return m_grabbed; }
// implementation from now on
// --------------------------
// move the window to the specified location and resize it: this is called
// from both DoSetSize() and DoSetClientSize()
virtual void DoMoveWindow(int x, int y, int width, int height);
// GTK callbacks
virtual void GtkOnSize( int x, int y, int width, int height );
virtual void OnInternalIdle();
// do *not* call this to iconize the frame, this is a private function!
void SetIconizeState(bool iconic);
int m_miniEdge,
m_miniTitle;
GtkWidget *m_mainWidget;
bool m_insertInClientArea; /* not from within OnCreateXXX */
bool m_fsIsShowing; /* full screen */
long m_fsSaveGdkFunc, m_fsSaveGdkDecor;
long m_fsSaveFlag;
wxRect m_fsSaveFrame;
// m_windowStyle translated to GDK's terms
long m_gdkFunc,
m_gdkDecor;
// private gtk_timeout_add result for mimicing wxUSER_ATTENTION_INFO and
// wxUSER_ATTENTION_ERROR difference, -2 for no hint, -1 for ERROR hint, rest for GtkTimeout handle.
int m_urgency_hint;
protected:
// common part of all ctors
void Init();
// override wxWindow methods to take into account tool/menu/statusbars
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual void DoSetClientSize(int width, int height);
virtual void DoGetClientSize( int *width, int *height ) const;
wxString m_title;
// is the frame currently iconized?
bool m_isIconized;
// is the frame currently grabbed explicitly
// by the application?
bool m_grabbed;
};
#endif // __GTKTOPLEVELH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/tooltip.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/tooltip.h
// Purpose: wxToolTip class
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKTOOLTIPH__
#define __GTKTOOLTIPH__
#include "wx/defs.h"
#include "wx/string.h"
#include "wx/object.h"
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxToolTip;
class WXDLLIMPEXP_FWD_CORE wxWindow;
//-----------------------------------------------------------------------------
// wxToolTip
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxToolTip : public wxObject
{
public:
// globally change the tooltip parameters
static void Enable( bool flag );
static void SetDelay( long msecs );
// set the delay after which the tooltip disappears or how long the tooltip remains visible
static void SetAutoPop(long msecs);
// set the delay between subsequent tooltips to appear
static void SetReshow(long msecs);
wxToolTip( const wxString &tip );
// get/set the tooltip text
void SetTip( const wxString &tip );
wxString GetTip() const { return m_text; }
wxWindow *GetWindow() const { return m_window; }
bool IsOk() const { return m_window != NULL; }
// implementation
void Apply( wxWindow *win );
private:
wxString m_text;
wxWindow *m_window;
wxDECLARE_ABSTRACT_CLASS(wxToolTip);
};
#endif // __GTKTOOLTIPH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/stattext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/stattext.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKSTATICTEXTH__
#define __GTKSTATICTEXTH__
//-----------------------------------------------------------------------------
// wxStaticText
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxStaticText : public wxStaticTextBase
{
public:
wxStaticText();
wxStaticText(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticTextNameStr );
bool Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos = wxDefaultPosition,
const wxSize &size = wxDefaultSize,
long style = 0,
const wxString &name = wxStaticTextNameStr );
virtual wxString GetLabel() const;
virtual void SetLabel( const wxString &label );
virtual bool SetFont( const wxFont &font );
virtual bool SetForegroundColour( const wxColour& colour );
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO);
virtual wxSize DoGetBestSize() const;
wxDECLARE_DYNAMIC_CLASS(wxStaticText);
};
#endif // __GTKSTATICTEXTH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/radiobut.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/radiobut.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKRADIOBUTTONH__
#define __GTKRADIOBUTTONH__
//-----------------------------------------------------------------------------
// wxRadioButton
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioButton: public wxControl
{
public:
wxRadioButton() { }
wxRadioButton( wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr )
{
Create( parent, id, label, pos, size, style, validator, name );
}
bool Create( wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr );
virtual void SetLabel(const wxString& label);
virtual void SetValue(bool val);
virtual bool GetValue() const;
virtual bool Enable( bool enable = TRUE );
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation
virtual bool IsRadioButton() const { return TRUE; }
void DoApplyWidgetStyle(GtkRcStyle *style);
bool IsOwnGtkWindow( GdkWindow *window );
void OnInternalIdle();
bool m_blockEvent;
protected:
virtual wxSize DoGetBestSize() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioButton);
};
#endif // __GTKRADIOBUTTONH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/radiobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/radiobox.h
// Purpose:
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_RADIOBOX_H_
#define _WX_GTK_RADIOBOX_H_
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// wxRadioBox
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioBox : public wxControl,
public wxRadioBoxBase
{
public:
// ctors and dtor
wxRadioBox() { Init(); }
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0,
const wxString choices[] = (const wxString *) NULL,
int majorDim = 1,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
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 = 1,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
Create( parent, id, title, pos, size, choices, majorDim, style, val, name );
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0,
const wxString choices[] = (const wxString *) NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
virtual ~wxRadioBox();
// implement wxItemContainerImmutable methods
virtual unsigned int GetCount() const;
virtual wxString GetString(unsigned int n) const;
virtual void SetString(unsigned int n, const wxString& s);
virtual void SetSelection(int n);
virtual int GetSelection() const;
// implement wxRadioBoxBase methods
virtual bool Show(unsigned int n, bool show = true);
virtual bool Enable(unsigned int n, bool enable = true);
virtual bool IsItemEnabled(unsigned int n) const;
virtual bool IsItemShown(unsigned int n) const;
// override some base class methods to operate on radiobox itself too
virtual bool Show( bool show = true );
virtual bool Enable( bool enable = true );
virtual void SetLabel( const wxString& label );
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation
// --------------
void SetFocus();
void GtkDisableEvents();
void GtkEnableEvents();
bool IsOwnGtkWindow( GdkWindow *window );
void DoApplyWidgetStyle(GtkRcStyle *style);
#if wxUSE_TOOLTIPS
void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );
#endif // wxUSE_TOOLTIPS
virtual void OnInternalIdle();
bool m_hasFocus,
m_lostFocus;
wxList m_boxes;
protected:
// common part of all ctors
void Init();
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
};
#endif // _WX_GTK_RADIOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/checklst.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/checklst.h
// Purpose: wxCheckListBox class
// Author: Robert Roebling
// Modified by:
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef __GTKCHECKLISTH__
#define __GTKCHECKLISTH__
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
// there is no "right" choice of the checkbox indicators, so allow the user to
// define them himself if he wants
#ifndef wxCHECKLBOX_CHECKED
#define wxCHECKLBOX_CHECKED wxT('x')
#define wxCHECKLBOX_UNCHECKED wxT(' ')
#define wxCHECKLBOX_STRING wxT("[ ] ")
#endif
//-----------------------------------------------------------------------------
// wxCheckListBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
public:
wxCheckListBox();
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString *choices = (const wxString *)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 IsChecked(unsigned int index) const;
void Check(unsigned int index, bool check = true);
int GetItemHeight() const;
private:
wxDECLARE_DYNAMIC_CLASS(wxCheckListBox);
};
#endif //__GTKCHECKLISTH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/listbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/listbox.h
// Purpose: wxListBox class declaration
// Author: Robert Roebling
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTKLISTBOXH__
#define __GTKLISTBOXH__
#include "wx/list.h"
typedef struct _GtkList GtkList;
class WXDLLIMPEXP_FWD_BASE wxSortedArrayString;
//-----------------------------------------------------------------------------
// wxListBox
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxListBox : public wxListBoxBase
{
public:
// ctors and such
wxListBox();
wxListBox( wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr )
{
#if wxUSE_CHECKLISTBOX
m_hasCheckBoxes = false;
#endif // wxUSE_CHECKLISTBOX
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 )
{
#if wxUSE_CHECKLISTBOX
m_hasCheckBoxes = false;
#endif // wxUSE_CHECKLISTBOX
Create(parent, id, pos, size, choices, style, validator, name);
}
virtual ~wxListBox();
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = (const wxString *) NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// implement base class pure virtuals
virtual void DoClear();
virtual void DoDeleteOneItem(unsigned int n);
virtual unsigned int GetCount() const;
virtual wxString GetString(unsigned int n) const;
virtual void SetString(unsigned int n, const wxString& s);
virtual int FindString(const wxString& s, bool bCase = false) const;
virtual bool IsSelected(int n) const;
virtual void DoSetSelection(int n, bool select);
virtual int GetSelection() const;
virtual int GetSelections(wxArrayInt& aSelections) const;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual void DoSetFirstItem(int n);
virtual void DoSetItemClientData(unsigned int n, void* clientData);
virtual void* DoGetItemClientData(unsigned int n) const;
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// implementation from now on
void GtkAddItem( const wxString &item, int pos=-1 );
int GtkGetIndex( GtkWidget *item ) const;
GtkWidget *GetConnectWidget();
bool IsOwnGtkWindow( GdkWindow *window );
void DoApplyWidgetStyle(GtkRcStyle *style);
void OnInternalIdle();
#if wxUSE_TOOLTIPS
void ApplyToolTip( GtkTooltips *tips, const wxChar *tip );
#endif // wxUSE_TOOLTIPS
GtkList *m_list;
wxList m_clientList;
#if wxUSE_CHECKLISTBOX
bool m_hasCheckBoxes;
#endif // wxUSE_CHECKLISTBOX
int m_prevSelection;
bool m_blockEvent;
virtual void FixUpMouseEvent(GtkWidget *widget, wxCoord& x, wxCoord& y);
protected:
virtual wxSize DoGetBestSize() const;
// return the string label for the given item
wxString GetRealLabel(struct _GList *item) const;
// Widgets that use the style->base colour for the BG colour should
// override this and return true.
virtual bool UseGTKStyleBase() const { return true; }
private:
// this array is only used for controls with wxCB_SORT style, so only
// allocate it if it's needed (hence using pointer)
wxSortedArrayString *m_strings;
wxDECLARE_DYNAMIC_CLASS(wxListBox);
};
#endif // __GTKLISTBOXH__
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Win32/include/wx/gtk1/fontdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk1/fontdlg.h
// Purpose: wxFontDialog
// Author: Robert Roebling
// Created:
// Copyright: (c) Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef __GTK_FONTDLGH__
#define __GTK_FONTDLGH__
//-----------------------------------------------------------------------------
// wxFontDialog
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFontDialog : public wxFontDialogBase
{
public:
wxFontDialog() : wxFontDialogBase() { /* must be Create()d later */ }
wxFontDialog(wxWindow *parent)
: wxFontDialogBase(parent) { Create(parent); }
wxFontDialog(wxWindow *parent, const wxFontData& data)
: wxFontDialogBase(parent, data) { Create(parent, data); }
virtual ~wxFontDialog();
// implementation only
void SetChosenFont(const char *name);
protected:
// create the GTK dialog
virtual bool DoCreate(wxWindow *parent);
private:
wxDECLARE_DYNAMIC_CLASS(wxFontDialog);
};
#endif
| h |
Subsets and Splits