repo_name
stringclasses 10
values | file_path
stringlengths 29
222
| content
stringlengths 24
926k
| extention
stringclasses 5
values |
|---|---|---|---|
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/apptbase.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/apptbase.h
// Purpose: declaration of wxAppTraits for Unix systems
// Author: Vadim Zeitlin
// Modified by:
// Created: 23.06.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_APPTBASE_H_
#define _WX_UNIX_APPTBASE_H_
#include "wx/evtloop.h"
#include "wx/evtloopsrc.h"
class wxExecuteData;
class wxFDIOManager;
class wxEventLoopSourcesManagerBase;
// ----------------------------------------------------------------------------
// wxAppTraits: the Unix version adds extra hooks needed by Unix code
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxAppTraits : public wxAppTraitsBase
{
public:
// wxExecute() support methods
// ---------------------------
// Wait for the process termination and return its exit code or -1 on error.
//
// Notice that this is only used when execData.flags contains wxEXEC_SYNC
// and does not contain wxEXEC_NOEVENTS, i.e. when we need to really wait
// until the child process exit and dispatch the events while doing it.
virtual int WaitForChild(wxExecuteData& execData);
#if wxUSE_SOCKETS
// return a pointer to the object which should be used to integrate
// monitoring of the file descriptors to the event loop (currently this is
// used for the sockets only but should be used for arbitrary event loop
// sources in the future)
//
// this object may be different for the console and GUI applications
//
// the pointer is not deleted by the caller as normally it points to a
// static variable
virtual wxFDIOManager *GetFDIOManager();
#endif // wxUSE_SOCKETS
#if wxUSE_CONSOLE_EVENTLOOP && wxUSE_EVENTLOOP_SOURCE
// Return a non-NULL pointer to the object responsible for managing the
// event loop sources in this kind of application.
virtual wxEventLoopSourcesManagerBase* GetEventLoopSourcesManager();
#endif // wxUSE_CONSOLE_EVENTLOOP && wxUSE_CONSOLE_EVENTLOOP
protected:
// Wait for the process termination by running the given event loop until
// this happens.
//
// This is used by the public WaitForChild() after creating the event loop
// of the appropriate kind.
int RunLoopUntilChildExit(wxExecuteData& execData, wxEventLoopBase& loop);
};
#endif // _WX_UNIX_APPTBASE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/tls.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/tls.h
// Purpose: Pthreads implementation of wxTlsValue<>
// Author: Vadim Zeitlin
// Created: 2008-08-08
// Copyright: (c) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_TLS_H_
#define _WX_UNIX_TLS_H_
#include <pthread.h>
// ----------------------------------------------------------------------------
// wxTlsKey is a helper class encapsulating the TLS value index
// ----------------------------------------------------------------------------
class wxTlsKey
{
public:
// ctor allocates a new key and possibly registering a destructor function
// for it
wxTlsKey(wxTlsDestructorFunction destructor)
{
m_destructor = destructor;
if ( pthread_key_create(&m_key, destructor) != 0 )
m_key = 0;
}
// return true if the key was successfully allocated
bool IsOk() const { return m_key != 0; }
// get the key value, there is no error return
void *Get() const
{
return pthread_getspecific(m_key);
}
// change the key value, return true if ok
bool Set(void *value)
{
void *old = Get();
if ( old )
m_destructor(old);
return pthread_setspecific(m_key, value) == 0;
}
// free the key
~wxTlsKey()
{
if ( IsOk() )
pthread_key_delete(m_key);
}
private:
wxTlsDestructorFunction m_destructor;
pthread_key_t m_key;
wxDECLARE_NO_COPY_CLASS(wxTlsKey);
};
#endif // _WX_UNIX_TLS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/taskbarx11.h | /////////////////////////////////////////////////////////////////////////
// File: wx/unix/taskbarx11.h
// Purpose: Defines wxTaskBarIcon class for most common X11 desktops
// Author: Vaclav Slavik
// Modified by:
// Created: 04/04/2003
// Copyright: (c) Vaclav Slavik, 2003
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_TASKBAR_H_
#define _WX_UNIX_TASKBAR_H_
class WXDLLIMPEXP_FWD_CORE wxTaskBarIconArea;
class WXDLLIMPEXP_CORE wxTaskBarIcon: public wxTaskBarIconBase
{
public:
wxTaskBarIcon();
virtual ~wxTaskBarIcon();
// Accessors:
bool IsOk() const;
bool IsIconInstalled() const;
// Operations:
bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxEmptyString) wxOVERRIDE;
bool RemoveIcon() wxOVERRIDE;
bool PopupMenu(wxMenu *menu) wxOVERRIDE;
protected:
wxTaskBarIconArea *m_iconWnd;
private:
void OnDestroy(wxWindowDestroyEvent&);
wxDECLARE_DYNAMIC_CLASS(wxTaskBarIcon);
};
#endif // _WX_UNIX_TASKBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/chkconf.h | /*
* Name: wx/unix/chkconf.h
* Purpose: Unix-specific config settings consistency checks
* Author: Vadim Zeitlin
* Created: 2007-07-14
* Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
* Licence: wxWindows licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#if wxUSE_CONSOLE_EVENTLOOP
# if !wxUSE_SELECT_DISPATCHER && !wxUSE_EPOLL_DISPATCHER
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxSelect/EpollDispatcher needed for console event loop"
# else
# undef wxUSE_SELECT_DISPATCHER
# define wxUSE_SELECT_DISPATCHER 1
# endif
# endif
#endif /* wxUSE_CONSOLE_EVENTLOOP */
#if wxUSE_FSWATCHER
# if !defined(wxHAS_INOTIFY) && !defined(wxHAS_KQUEUE)
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxFileSystemWatcher requires either inotify() or kqueue()"
# else
# undef wxUSE_FSWATCHER
# define wxUSE_FSWATCHER 0
# endif
# endif
#endif /* wxUSE_FSWATCHER */
#if wxUSE_GSTREAMER
# if !wxUSE_THREADS
# ifdef wxABORT_ON_CONFIG_ERROR
# error "GStreamer requires threads"
# else
# undef wxUSE_GSTREAMER
# define wxUSE_GSTREAMER 0
# endif
# endif
#endif /* wxUSE_GSTREAMER */
#ifndef wxUSE_XTEST
# ifdef wxABORT_ON_CONFIG_ERROR
# error "wxUSE_XTEST must be defined, please read comment near the top of this file."
# else
# define wxUSE_XTEST 0
# endif
#endif /* !defined(wxUSE_XTEST) */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/mimetype.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/mimetype.h
// Purpose: classes and functions to manage MIME types
// Author: Vadim Zeitlin
// Modified by:
// Created: 23.09.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence (part of wxExtra library)
/////////////////////////////////////////////////////////////////////////////
#ifndef _MIMETYPE_IMPL_H
#define _MIMETYPE_IMPL_H
#include "wx/mimetype.h"
#if wxUSE_MIMETYPE
class wxMimeTypeCommands;
WX_DEFINE_ARRAY_PTR(wxMimeTypeCommands *, wxMimeCommandsArray);
// this is the real wxMimeTypesManager for Unix
class WXDLLIMPEXP_BASE wxMimeTypesManagerImpl
{
public:
// ctor and dtor
wxMimeTypesManagerImpl();
virtual ~wxMimeTypesManagerImpl();
// load all data into memory - done when it is needed for the first time
void Initialize(int mailcapStyles = wxMAILCAP_ALL,
const wxString& extraDir = wxEmptyString);
// and delete the data here
void ClearData();
// implement containing class functions
wxFileType *GetFileTypeFromExtension(const wxString& ext);
wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
size_t EnumAllFileTypes(wxArrayString& mimetypes);
void AddFallback(const wxFileTypeInfo& filetype);
// add information about the given mimetype
void AddMimeTypeInfo(const wxString& mimetype,
const wxString& extensions,
const wxString& description);
void AddMailcapInfo(const wxString& strType,
const wxString& strOpenCmd,
const wxString& strPrintCmd,
const wxString& strTest,
const wxString& strDesc);
// add a new record to the user .mailcap/.mime.types files
wxFileType *Associate(const wxFileTypeInfo& ftInfo);
// remove association
bool Unassociate(wxFileType *ft);
// accessors
// get the string containing space separated extensions for the given
// file type
wxString GetExtension(size_t index) { return m_aExtensions[index]; }
protected:
void InitIfNeeded();
wxArrayString m_aTypes, // MIME types
m_aDescriptions, // descriptions (just some text)
m_aExtensions, // space separated list of extensions
m_aIcons; // Icon filenames
// verb=command pairs for this file type
wxMimeCommandsArray m_aEntries;
// are we initialized?
bool m_initialized;
wxString GetCommand(const wxString &verb, size_t nIndex) const;
// Read XDG *.desktop file
void LoadXDGApp(const wxString& filename);
// Scan XDG directory
void LoadXDGAppsFilesFromDir(const wxString& dirname);
// Load XDG globs files
void LoadXDGGlobs(const wxString& filename);
// functions used to do associations
virtual int AddToMimeData(const wxString& strType,
const wxString& strIcon,
wxMimeTypeCommands *entry,
const wxArrayString& strExtensions,
const wxString& strDesc,
bool replaceExisting = true);
virtual bool DoAssociation(const wxString& strType,
const wxString& strIcon,
wxMimeTypeCommands *entry,
const wxArrayString& strExtensions,
const wxString& strDesc);
virtual wxString GetIconFromMimeType(const wxString& mime);
// give it access to m_aXXX variables
friend class WXDLLIMPEXP_FWD_BASE wxFileTypeImpl;
};
class WXDLLIMPEXP_BASE wxFileTypeImpl
{
public:
// initialization functions
// this is used to construct a list of mimetypes which match;
// if built with GetFileTypeFromMimetype index 0 has the exact match and
// index 1 the type / * match
// if built with GetFileTypeFromExtension, index 0 has the mimetype for
// the first extension found, index 1 for the second and so on
void Init(wxMimeTypesManagerImpl *manager, size_t index)
{ m_manager = manager; m_index.Add(index); }
// accessors
bool GetExtensions(wxArrayString& extensions);
bool GetMimeType(wxString *mimeType) const
{ *mimeType = m_manager->m_aTypes[m_index[0]]; return true; }
bool GetMimeTypes(wxArrayString& mimeTypes) const;
bool GetIcon(wxIconLocation *iconLoc) const;
bool GetDescription(wxString *desc) const
{ *desc = m_manager->m_aDescriptions[m_index[0]]; return true; }
bool GetOpenCommand(wxString *openCmd,
const wxFileType::MessageParameters& params) const
{
*openCmd = GetExpandedCommand(wxT("open"), params);
return (! openCmd -> IsEmpty() );
}
bool GetPrintCommand(wxString *printCmd,
const wxFileType::MessageParameters& params) const
{
*printCmd = GetExpandedCommand(wxT("print"), params);
return (! printCmd -> IsEmpty() );
}
// return the number of commands defined for this file type, 0 if none
size_t GetAllCommands(wxArrayString *verbs, wxArrayString *commands,
const wxFileType::MessageParameters& params) const;
// remove the record for this file type
// probably a mistake to come here, use wxMimeTypesManager.Unassociate (ft) instead
bool Unassociate(wxFileType *ft)
{
return m_manager->Unassociate(ft);
}
// set an arbitrary command, ask confirmation if it already exists and
// overwriteprompt is TRUE
bool SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt = true);
bool SetDefaultIcon(const wxString& strIcon = wxEmptyString, int index = 0);
wxString
GetExpandedCommand(const wxString & verb,
const wxFileType::MessageParameters& params) const;
private:
wxMimeTypesManagerImpl *m_manager;
wxArrayInt m_index; // in the wxMimeTypesManagerImpl arrays
};
#endif // wxUSE_MIMETYPE
#endif // _MIMETYPE_IMPL_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/fswatcher_kqueue.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/fswatcher_kqueue.h
// Purpose: wxKqueueFileSystemWatcher
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FSWATCHER_KQUEUE_H_
#define _WX_FSWATCHER_KQUEUE_H_
#include "wx/defs.h"
#if wxUSE_FSWATCHER
class WXDLLIMPEXP_BASE wxKqueueFileSystemWatcher :
public wxFileSystemWatcherBase
{
public:
wxKqueueFileSystemWatcher();
wxKqueueFileSystemWatcher(const wxFileName& path,
int events = wxFSW_EVENT_ALL);
virtual ~wxKqueueFileSystemWatcher();
protected:
bool Init();
};
#endif
#endif /* _WX_FSWATCHER_OSX_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/displayx11.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/displayx11.h
// Purpose: Helper functions used by wxX11 and wxGTK ports
// Author: Vadim Zeitlin
// Created: 2018-10-04 (extracted from src/unix/displayx11.cpp)
// Copyright: (c) 2002-2018 wxWindows team
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_DISPLAYX11_H_
#define _WX_UNIX_PRIVATE_DISPLAYX11_H_
#include "wx/defs.h"
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#if wxUSE_DISPLAY
#include "wx/log.h"
#include "wx/translation.h"
#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
#include <X11/extensions/xf86vmode.h>
//
// See (http://www.xfree86.org/4.2.0/XF86VidModeDeleteModeLine.3.html) for more
// info about xf86 video mode extensions
//
//free private data common to x (usually s3) servers
#define wxClearXVM(vm) if(vm.privsize) XFree(vm.c_private)
// Correct res rate from GLFW
#define wxCRR2(v,dc) (int) (((1000.0f * (float) dc) /*PIXELS PER SECOND */) / ((float) v.htotal * v.vtotal /*PIXELS PER FRAME*/) + 0.5f)
#define wxCRR(v) wxCRR2(v,v.dotclock)
#define wxCVM2(v, dc, display, nScreen) wxVideoMode(v.hdisplay, v.vdisplay, DefaultDepth(display, nScreen), wxCRR2(v,dc))
#define wxCVM(v, display, nScreen) wxCVM2(v, v.dotclock, display, nScreen)
wxArrayVideoModes wxXF86VidMode_GetModes(const wxVideoMode& mode, Display* display, int nScreen)
{
XF86VidModeModeInfo** ppXModes; //Enumerated Modes (Don't forget XFree() :))
int nNumModes; //Number of modes enumerated....
wxArrayVideoModes Modes; //modes to return...
if (XF86VidModeGetAllModeLines(display, nScreen, &nNumModes, &ppXModes))
{
for (int i = 0; i < nNumModes; ++i)
{
XF86VidModeModeInfo& info = *ppXModes[i];
const wxVideoMode vm = wxCVM(info, display, nScreen);
if (vm.Matches(mode))
{
Modes.Add(vm);
}
wxClearXVM(info);
// XFree(ppXModes[i]); //supposed to free?
}
XFree(ppXModes);
}
else //OOPS!
{
wxLogSysError(_("Failed to enumerate video modes"));
}
return Modes;
}
wxVideoMode wxXF86VidMode_GetCurrentMode(Display* display, int nScreen)
{
XF86VidModeModeLine VM;
int nDotClock;
if ( !XF86VidModeGetModeLine(display, nScreen, &nDotClock, &VM) )
return wxVideoMode();
wxClearXVM(VM);
return wxCVM2(VM, nDotClock, display, nScreen);
}
bool wxXF86VidMode_ChangeMode(const wxVideoMode& mode, Display* display, int nScreen)
{
XF86VidModeModeInfo** ppXModes; //Enumerated Modes (Don't forget XFree() :))
int nNumModes; //Number of modes enumerated....
if(!XF86VidModeGetAllModeLines(display, nScreen, &nNumModes, &ppXModes))
{
wxLogSysError(_("Failed to change video mode"));
return false;
}
bool bRet = false;
if (mode == wxDefaultVideoMode)
{
bRet = XF86VidModeSwitchToMode(display, nScreen, ppXModes[0]) != 0;
for (int i = 0; i < nNumModes; ++i)
{
wxClearXVM((*ppXModes[i]));
// XFree(ppXModes[i]); //supposed to free?
}
}
else
{
for (int i = 0; i < nNumModes; ++i)
{
if (!bRet &&
ppXModes[i]->hdisplay == mode.GetWidth() &&
ppXModes[i]->vdisplay == mode.GetHeight() &&
wxCRR((*ppXModes[i])) == mode.GetRefresh())
{
//switch!
bRet = XF86VidModeSwitchToMode(display, nScreen, ppXModes[i]) != 0;
}
wxClearXVM((*ppXModes[i]));
// XFree(ppXModes[i]); //supposed to free?
}
}
XFree(ppXModes);
return bRet;
}
#else // !HAVE_X11_EXTENSIONS_XF86VMODE_H
wxArrayVideoModes wxX11_GetModes(const wxDisplayImpl* impl, const wxVideoMode& modeMatch, Display* display)
{
int count_return;
int* depths = XListDepths(display, 0, &count_return);
wxArrayVideoModes modes;
if ( depths )
{
const wxRect rect = impl->GetGeometry();
for ( int x = 0; x < count_return; ++x )
{
wxVideoMode mode(rect.width, rect.height, depths[x]);
if ( mode.Matches(modeMatch) )
{
modes.Add(mode);
}
}
XFree(depths);
}
return modes;
}
#endif // !HAVE_X11_EXTENSIONS_XF86VMODE_H
#endif // wxUSE_DISPLAY
void wxGetWorkAreaX11(Screen* screen, int& x, int& y, int& width, int& height)
{
Display* display = DisplayOfScreen(screen);
Atom property = XInternAtom(display, "_NET_WORKAREA", true);
if (property)
{
Atom actual_type;
int actual_format;
unsigned long nitems;
unsigned long bytes_after;
unsigned char* data = NULL;
Status status = XGetWindowProperty(
display, RootWindowOfScreen(screen), property,
0, 4, false, XA_CARDINAL,
&actual_type, &actual_format, &nitems, &bytes_after, &data);
if (status == Success && actual_type == XA_CARDINAL &&
actual_format == 32 && nitems == 4)
{
const long* p = (long*)data;
x = p[0];
y = p[1];
width = p[2];
height = p[3];
}
if (data)
XFree(data);
}
}
#endif // _WX_UNIX_PRIVATE_DISPLAYX11_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/wakeuppipe.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/wakeuppipe.h
// Purpose: Helper class allowing to wake up the main thread.
// Author: Vadim Zeitlin
// Created: 2013-06-09 (extracted from src/unix/evtloopunix.cpp)
// Copyright: (c) 2013 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_WAKEUPPIPE_H_
#define _WX_UNIX_PRIVATE_WAKEUPPIPE_H_
#include "wx/unix/pipe.h"
#include "wx/evtloopsrc.h"
// ----------------------------------------------------------------------------
// wxWakeUpPipe: allows to wake up the event loop by writing to it
// ----------------------------------------------------------------------------
// This class is not MT-safe, see wxWakeUpPipeMT below for a wake up pipe
// usable from other threads.
class wxWakeUpPipe : public wxEventLoopSourceHandler
{
public:
// Create and initialize the pipe.
//
// It's the callers responsibility to add the read end of this pipe,
// returned by GetReadFd(), to the code blocking on input.
wxWakeUpPipe();
// Wake up the blocking operation involving this pipe.
//
// It simply writes to the write end of the pipe.
//
// As indicated by its name, this method does no locking and so can be
// called only from the main thread.
void WakeUpNoLock();
// Same as WakeUp() but without locking.
// Return the read end of the pipe.
int GetReadFd() { return m_pipe[wxPipe::Read]; }
// Implement wxEventLoopSourceHandler pure virtual methods
virtual void OnReadWaiting() wxOVERRIDE;
virtual void OnWriteWaiting() wxOVERRIDE { }
virtual void OnExceptionWaiting() wxOVERRIDE { }
private:
wxPipe m_pipe;
// This flag is set to true after writing to the pipe and reset to false
// after reading from it in the main thread. Having it allows us to avoid
// overflowing the pipe with too many writes if the main thread can't keep
// up with reading from it.
bool m_pipeIsEmpty;
};
// ----------------------------------------------------------------------------
// wxWakeUpPipeMT: thread-safe version of wxWakeUpPipe
// ----------------------------------------------------------------------------
// This class can be used from multiple threads, i.e. its WakeUp() can be
// called concurrently.
class wxWakeUpPipeMT : public wxWakeUpPipe
{
#if wxUSE_THREADS
public:
wxWakeUpPipeMT() { }
// Thread-safe wrapper around WakeUpNoLock(): can be called from another
// thread to wake up the main one.
void WakeUp()
{
wxCriticalSectionLocker lock(m_pipeLock);
WakeUpNoLock();
}
virtual void OnReadWaiting() wxOVERRIDE
{
wxCriticalSectionLocker lock(m_pipeLock);
wxWakeUpPipe::OnReadWaiting();
}
private:
// Protects access to m_pipeIsEmpty.
wxCriticalSection m_pipeLock;
#endif // wxUSE_THREADS
};
#endif // _WX_UNIX_PRIVATE_WAKEUPPIPE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/epolldispatcher.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/epolldispatcher.h
// Purpose: wxEpollDispatcher class
// Authors: Lukasz Michalski
// Created: April 2007
// Copyright: (c) Lukasz Michalski
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_EPOLLDISPATCHER_H_
#define _WX_PRIVATE_EPOLLDISPATCHER_H_
#include "wx/defs.h"
#ifdef wxUSE_EPOLL_DISPATCHER
#include "wx/private/fdiodispatcher.h"
struct epoll_event;
class WXDLLIMPEXP_BASE wxEpollDispatcher : public wxFDIODispatcher
{
public:
// create a new instance of this class, can return NULL if
// epoll() is not supported on this system
//
// the caller should delete the returned pointer
static wxEpollDispatcher *Create();
virtual ~wxEpollDispatcher();
// implement base class pure virtual methods
virtual bool RegisterFD(int fd, wxFDIOHandler* handler, int flags = wxFDIO_ALL) wxOVERRIDE;
virtual bool ModifyFD(int fd, wxFDIOHandler* handler, int flags = wxFDIO_ALL) wxOVERRIDE;
virtual bool UnregisterFD(int fd) wxOVERRIDE;
virtual bool HasPending() const wxOVERRIDE;
virtual int Dispatch(int timeout = TIMEOUT_INFINITE) wxOVERRIDE;
private:
// ctor is private, use Create()
wxEpollDispatcher(int epollDescriptor);
// common part of HasPending() and Dispatch(): calls epoll_wait() with the
// given timeout
int DoPoll(epoll_event *events, int numEvents, int timeout) const;
int m_epollDescriptor;
};
#endif // wxUSE_EPOLL_DISPATCHER
#endif // _WX_PRIVATE_SOCKETEVTDISPATCH_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/executeiohandler.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/executeiohandler.h
// Purpose: IO handler class for the FD used by wxExecute() under Unix
// Author: Rob Bresalier, Vadim Zeitlin
// Created: 2013-01-06
// Copyright: (c) 2013 Rob Bresalier, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_EXECUTEIOHANDLER_H_
#define _WX_UNIX_PRIVATE_EXECUTEIOHANDLER_H_
#include "wx/private/streamtempinput.h"
// This class handles IO events on the pipe FD connected to the child process
// stdout/stderr and is used by wxExecute().
//
// Currently it can derive from either wxEventLoopSourceHandler or
// wxFDIOHandler depending on the kind of dispatcher/event loop it is used
// with. In the future, when we get rid of wxFDIOHandler entirely, it will
// derive from wxEventLoopSourceHandler only.
template <class T>
class wxExecuteIOHandlerBase : public T
{
public:
wxExecuteIOHandlerBase(int fd, wxStreamTempInputBuffer& buf)
: m_fd(fd),
m_buf(buf)
{
m_callbackDisabled = false;
}
// Called when the associated descriptor is available for reading.
virtual void OnReadWaiting() wxOVERRIDE
{
// Sync process, process all data coming at us from the pipe so that
// the pipe does not get full and cause a deadlock situation.
m_buf.Update();
if ( m_buf.Eof() )
DisableCallback();
}
// These methods are never called as we only monitor the associated FD for
// reading, but we still must implement them as they're pure virtual in the
// base class.
virtual void OnWriteWaiting() wxOVERRIDE { }
virtual void OnExceptionWaiting() wxOVERRIDE { }
// Disable any future calls to our OnReadWaiting(), can be called when
// we're sure that no more input is forthcoming.
void DisableCallback()
{
if ( !m_callbackDisabled )
{
m_callbackDisabled = true;
DoDisable();
}
}
protected:
const int m_fd;
private:
virtual void DoDisable() = 0;
wxStreamTempInputBuffer& m_buf;
// If true, DisableCallback() had been already called.
bool m_callbackDisabled;
wxDECLARE_NO_COPY_CLASS(wxExecuteIOHandlerBase);
};
// This is the version used with wxFDIODispatcher, which must be passed to the
// ctor in order to register this handler with it.
class wxExecuteFDIOHandler : public wxExecuteIOHandlerBase<wxFDIOHandler>
{
public:
wxExecuteFDIOHandler(wxFDIODispatcher& dispatcher,
int fd,
wxStreamTempInputBuffer& buf)
: wxExecuteIOHandlerBase<wxFDIOHandler>(fd, buf),
m_dispatcher(dispatcher)
{
dispatcher.RegisterFD(fd, this, wxFDIO_INPUT);
}
virtual ~wxExecuteFDIOHandler()
{
DisableCallback();
}
private:
virtual void DoDisable() wxOVERRIDE
{
m_dispatcher.UnregisterFD(m_fd);
}
wxFDIODispatcher& m_dispatcher;
wxDECLARE_NO_COPY_CLASS(wxExecuteFDIOHandler);
};
// And this is the version used with an event loop. As AddSourceForFD() is
// static, we don't require passing the event loop to the ctor but an event
// loop must be running to handle our events.
class wxExecuteEventLoopSourceHandler
: public wxExecuteIOHandlerBase<wxEventLoopSourceHandler>
{
public:
wxExecuteEventLoopSourceHandler(int fd, wxStreamTempInputBuffer& buf)
: wxExecuteIOHandlerBase<wxEventLoopSourceHandler>(fd, buf)
{
m_source = wxEventLoop::AddSourceForFD(fd, this, wxEVENT_SOURCE_INPUT);
}
virtual ~wxExecuteEventLoopSourceHandler()
{
DisableCallback();
}
private:
virtual void DoDisable() wxOVERRIDE
{
delete m_source;
m_source = NULL;
}
wxEventLoopSource* m_source;
wxDECLARE_NO_COPY_CLASS(wxExecuteEventLoopSourceHandler);
};
#endif // _WX_UNIX_PRIVATE_EXECUTEIOHANDLER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/fswatcher_inotify.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/fswatcher_inotify.h
// Purpose: File system watcher impl classes
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef WX_UNIX_PRIVATE_FSWATCHER_INOTIFY_H_
#define WX_UNIX_PRIVATE_FSWATCHER_INOTIFY_H_
#include "wx/filename.h"
#include "wx/evtloopsrc.h"
// ============================================================================
// wxFSWatcherEntry implementation & helper declarations
// ============================================================================
class wxFSWatcherImplUNIX;
class wxFSWatchEntry : public wxFSWatchInfo
{
public:
wxFSWatchEntry(const wxFSWatchInfo& winfo) :
wxFSWatchInfo(winfo)
{
}
int GetWatchDescriptor() const
{
return m_wd;
}
void SetWatchDescriptor(int wd)
{
m_wd = wd;
}
private:
int m_wd;
wxDECLARE_NO_COPY_CLASS(wxFSWatchEntry);
};
// ============================================================================
// wxFSWSourceHandler helper class
// ============================================================================
class wxFSWatcherImplUnix;
/**
* Handler for handling i/o from inotify descriptor
*/
class wxFSWSourceHandler : public wxEventLoopSourceHandler
{
public:
wxFSWSourceHandler(wxFSWatcherImplUnix* service) :
m_service(service)
{ }
virtual void OnReadWaiting() wxOVERRIDE;
virtual void OnWriteWaiting() wxOVERRIDE;
virtual void OnExceptionWaiting() wxOVERRIDE;
protected:
wxFSWatcherImplUnix* m_service;
};
#endif /* WX_UNIX_PRIVATE_FSWATCHER_INOTIFY_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/timer.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/timer.h
// Purpose: wxTimer for wxBase (unix)
// Author: Lukasz Michalski
// Created: 15/01/2005
// Copyright: (c) Lukasz Michalski
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_TIMER_H_
#define _WX_UNIX_PRIVATE_TIMER_H_
#if wxUSE_TIMER
#include "wx/private/timer.h"
// the type used for milliseconds is large enough for microseconds too but
// introduce a synonym for it to avoid confusion
typedef wxMilliClock_t wxUsecClock_t;
// ----------------------------------------------------------------------------
// wxTimer implementation class for Unix platforms
// ----------------------------------------------------------------------------
// NB: we have to export at least this symbol from the shared library, because
// it's used by wxDFB's wxCore
class WXDLLIMPEXP_BASE wxUnixTimerImpl : public wxTimerImpl
{
public:
wxUnixTimerImpl(wxTimer *timer);
virtual ~wxUnixTimerImpl();
virtual bool IsRunning() const wxOVERRIDE;
virtual bool Start(int milliseconds = -1, bool oneShot = false) wxOVERRIDE;
virtual void Stop() wxOVERRIDE;
// for wxTimerScheduler only: resets the internal flag indicating that the
// timer is running
void MarkStopped()
{
wxASSERT_MSG( m_isRunning, wxT("stopping non-running timer?") );
m_isRunning = false;
}
private:
bool m_isRunning;
};
// ----------------------------------------------------------------------------
// wxTimerSchedule: information about a single timer, used by wxTimerScheduler
// ----------------------------------------------------------------------------
struct wxTimerSchedule
{
wxTimerSchedule(wxUnixTimerImpl *timer, wxUsecClock_t expiration)
: m_timer(timer),
m_expiration(expiration)
{
}
// the timer itself (we don't own this pointer)
wxUnixTimerImpl *m_timer;
// the time of its next expiration, in usec
wxUsecClock_t m_expiration;
};
// the linked list of all active timers, we keep it sorted by expiration time
WX_DECLARE_LIST(wxTimerSchedule, wxTimerList);
// ----------------------------------------------------------------------------
// wxTimerScheduler: class responsible for updating all timers
// ----------------------------------------------------------------------------
class wxTimerScheduler
{
public:
// get the unique timer scheduler instance
static wxTimerScheduler& Get()
{
if ( !ms_instance )
ms_instance = new wxTimerScheduler;
return *ms_instance;
}
// must be called on shutdown to delete the global timer scheduler
static void Shutdown()
{
if ( ms_instance )
{
delete ms_instance;
ms_instance = NULL;
}
}
// adds timer which should expire at the given absolute time to the list
void AddTimer(wxUnixTimerImpl *timer, wxUsecClock_t expiration);
// remove timer from the list, called automatically from timer dtor
void RemoveTimer(wxUnixTimerImpl *timer);
// the functions below are used by the event loop implementation to monitor
// and notify timers:
// if this function returns true, the time remaining until the next time
// expiration is returned in the provided parameter (always positive or 0)
//
// it returns false if there are no timers
bool GetNext(wxUsecClock_t *remaining) const;
// trigger the timer event for all timers which have expired, return true
// if any did
bool NotifyExpired();
private:
// ctor and dtor are private, this is a singleton class only created by
// Get() and destroyed by Shutdown()
wxTimerScheduler() { }
~wxTimerScheduler();
// add the given timer schedule to the list in the right place
//
// we take ownership of the pointer "s" which must be heap-allocated
void DoAddTimer(wxTimerSchedule *s);
// the list of all currently active timers sorted by expiration
wxTimerList m_timers;
static wxTimerScheduler *ms_instance;
};
#endif // wxUSE_TIMER
#endif // _WX_UNIX_PRIVATE_TIMER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/execute.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/execute.h
// Purpose: private details of wxExecute() implementation
// Author: Vadim Zeitlin
// Copyright: (c) 1998 Robert Roebling, Julian Smart, Vadim Zeitlin
// (c) 2013 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_EXECUTE_H
#define _WX_UNIX_EXECUTE_H
#include "wx/app.h"
#include "wx/hashmap.h"
#include "wx/process.h"
#if wxUSE_STREAMS
#include "wx/unix/pipe.h"
#include "wx/private/streamtempinput.h"
#endif
class wxEventLoopBase;
// Information associated with a running child process.
class wxExecuteData
{
public:
wxExecuteData()
{
flags =
pid = 0;
exitcode = -1;
process = NULL;
syncEventLoop = NULL;
#if wxUSE_STREAMS
fdOut =
fdErr = wxPipe::INVALID_FD;
#endif // wxUSE_STREAMS
}
// This must be called in the parent process as soon as fork() returns to
// update us with the effective child PID. It also ensures that we handle
// SIGCHLD to be able to detect when this PID exits, so wxTheApp must be
// available.
void OnStart(int pid);
// Called when the child process exits.
void OnExit(int exitcode);
// Return true if we should (or already did) redirect the child IO.
bool IsRedirected() const { return process && process->IsRedirected(); }
// wxExecute() flags
int flags;
// the pid of the child process
int pid;
// The exit code of the process, set once the child terminates.
int exitcode;
// the associated process object or NULL
wxProcess *process;
// Local event loop used to wait for the child process termination in
// synchronous execution case. We can't create it ourselves as its exact
// type depends on the application kind (console/GUI), so we rely on
// wxAppTraits setting up this pointer to point to the appropriate object.
wxEventLoopBase *syncEventLoop;
#if wxUSE_STREAMS
// the input buffer bufOut is connected to stdout, this is why it is
// called bufOut and not bufIn
wxStreamTempInputBuffer bufOut,
bufErr;
// the corresponding FDs, -1 if not redirected
int fdOut,
fdErr;
#endif // wxUSE_STREAMS
private:
// SIGCHLD signal handler that checks whether any of the currently running
// children have exited.
static void OnSomeChildExited(int sig);
// All currently running child processes indexed by their PID.
//
// Notice that the container doesn't own its elements.
WX_DECLARE_HASH_MAP(int, wxExecuteData*, wxIntegerHash, wxIntegerEqual,
ChildProcessesData);
static ChildProcessesData ms_childProcesses;
wxDECLARE_NO_COPY_CLASS(wxExecuteData);
};
#endif // _WX_UNIX_EXECUTE_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/pipestream.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/pipestream.h
// Purpose: Unix wxPipeInputStream and wxPipeOutputStream declarations
// Author: Vadim Zeitlin
// Created: 2013-06-08 (extracted from wx/unix/pipe.h)
// Copyright: (c) 2013 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_PIPESTREAM_H_
#define _WX_UNIX_PRIVATE_PIPESTREAM_H_
#include "wx/wfstream.h"
class wxPipeInputStream : public wxFileInputStream
{
public:
explicit wxPipeInputStream(int fd) : wxFileInputStream(fd) { }
// return true if the pipe is still opened
bool IsOpened() const { return !Eof(); }
// return true if we have anything to read, don't block
virtual bool CanRead() const wxOVERRIDE;
};
class wxPipeOutputStream : public wxFileOutputStream
{
public:
wxPipeOutputStream(int fd) : wxFileOutputStream(fd) { }
// Override the base class version to ignore "pipe full" errors: this is
// not an error for this class.
size_t OnSysWrite(const void *buffer, size_t size) wxOVERRIDE;
};
#endif // _WX_UNIX_PRIVATE_PIPESTREAM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/sockunix.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/sockunix.h
// Purpose: wxSocketImpl implementation for Unix systems
// Authors: Guilhem Lavaux, Vadim Zeitlin
// Created: April 1997
// Copyright: (c) 1997 Guilhem Lavaux
// (c) 2008 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_GSOCKUNX_H_
#define _WX_UNIX_GSOCKUNX_H_
#include <unistd.h>
#include <sys/ioctl.h>
// Under older (Open)Solaris versions FIONBIO is declared in this header only.
// In the newer versions it's included by sys/ioctl.h but it's simpler to just
// include it always instead of testing for whether it is or not.
#ifdef __SOLARIS__
#include <sys/filio.h>
#endif
#include "wx/private/fdiomanager.h"
class wxSocketImplUnix : public wxSocketImpl,
public wxFDIOHandler
{
public:
wxSocketImplUnix(wxSocketBase& wxsocket)
: wxSocketImpl(wxsocket)
{
m_fds[0] =
m_fds[1] = -1;
}
virtual wxSocketError GetLastError() const wxOVERRIDE;
virtual void ReenableEvents(wxSocketEventFlags flags) wxOVERRIDE
{
// enable the notifications about input/output being available again in
// case they were disabled by OnRead/WriteWaiting()
//
// notice that we'd like to enable the events here only if there is
// nothing more left on the socket right now as otherwise we're going
// to get a "ready for whatever" notification immediately (well, during
// the next event loop iteration) and disable the event back again
// which is rather inefficient but unfortunately doing it like this
// doesn't work because the existing code (e.g. src/common/sckipc.cpp)
// expects to keep getting notifications about the data available from
// the socket even if it didn't read all the data the last time, so we
// absolutely have to continue generating them
EnableEvents(flags);
}
// wxFDIOHandler methods
virtual void OnReadWaiting() wxOVERRIDE;
virtual void OnWriteWaiting() wxOVERRIDE;
virtual void OnExceptionWaiting() wxOVERRIDE;
virtual bool IsOk() const wxOVERRIDE { return m_fd != INVALID_SOCKET; }
private:
virtual void DoClose() wxOVERRIDE
{
DisableEvents();
close(m_fd);
}
virtual void UnblockAndRegisterWithEventLoop() wxOVERRIDE
{
int trueArg = 1;
ioctl(m_fd, FIONBIO, &trueArg);
EnableEvents();
}
// enable or disable notifications for socket input/output events
void EnableEvents(int flags = wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG)
{ DoEnableEvents(flags, true); }
void DisableEvents(int flags = wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG)
{ DoEnableEvents(flags, false); }
// really enable or disable socket input/output events
void DoEnableEvents(int flags, bool enable);
protected:
// descriptors for input and output event notification channels associated
// with the socket
int m_fds[2];
private:
// notify the associated wxSocket about a change in socket state and shut
// down the socket if the event is wxSOCKET_LOST
void OnStateChange(wxSocketNotify event);
// check if there is any input available, return 1 if yes, 0 if no or -1 on
// error
int CheckForInput();
// give it access to our m_fds
friend class wxSocketFDBasedManager;
};
// A version of wxSocketManager which uses FDs for socket IO: it is used by
// Unix console applications and some X11-like ports (wxGTK and wxMotif but not
// wxX11 currently) which implement their own port-specific wxFDIOManagers
class wxSocketFDBasedManager : public wxSocketManager
{
public:
wxSocketFDBasedManager()
{
m_fdioManager = NULL;
}
virtual bool OnInit() wxOVERRIDE;
virtual void OnExit() wxOVERRIDE { }
virtual wxSocketImpl *CreateSocket(wxSocketBase& wxsocket) wxOVERRIDE
{
return new wxSocketImplUnix(wxsocket);
}
virtual void Install_Callback(wxSocketImpl *socket_, wxSocketNotify event) wxOVERRIDE;
virtual void Uninstall_Callback(wxSocketImpl *socket_, wxSocketNotify event) wxOVERRIDE;
protected:
// get the FD index corresponding to the given wxSocketNotify
wxFDIOManager::Direction
GetDirForEvent(wxSocketImpl *socket, wxSocketNotify event);
// access the FDs we store
int& FD(wxSocketImplUnix *socket, wxFDIOManager::Direction d)
{
return socket->m_fds[d];
}
wxFDIOManager *m_fdioManager;
wxDECLARE_NO_COPY_CLASS(wxSocketFDBasedManager);
};
#endif /* _WX_UNIX_GSOCKUNX_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/fdiounix.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/fdiounix.h
// Purpose: wxFDIOManagerUnix class used by console Unix applications
// Author: Vadim Zeitlin
// Created: 2009-08-17
// Copyright: (c) 2009 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _UNIX_PRIVATE_FDIOUNIX_H_
#define _UNIX_PRIVATE_FDIOUNIX_H_
#include "wx/private/fdiomanager.h"
// ----------------------------------------------------------------------------
// wxFDIOManagerUnix: implement wxFDIOManager interface using wxFDIODispatcher
// ----------------------------------------------------------------------------
class wxFDIOManagerUnix : public wxFDIOManager
{
public:
virtual int AddInput(wxFDIOHandler *handler, int fd, Direction d) wxOVERRIDE;
virtual void RemoveInput(wxFDIOHandler *handler, int fd, Direction d) wxOVERRIDE;
};
#endif // _UNIX_PRIVATE_FDIOUNIX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/unix/private/fswatcher_kqueue.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/fswatcher_kqueue.h
// Purpose: File system watcher impl classes
// Author: Bartosz Bekier
// Created: 2009-05-26
// Copyright: (c) 2009 Bartosz Bekier <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef WX_UNIX_PRIVATE_FSWATCHER_KQUEUE_H_
#define WX_UNIX_PRIVATE_FSWATCHER_KQUEUE_H_
#include <fcntl.h>
#include <unistd.h>
#include "wx/dir.h"
#include "wx/debug.h"
#include "wx/arrstr.h"
// ============================================================================
// wxFSWatcherEntry implementation & helper declarations
// ============================================================================
class wxFSWatcherImplKqueue;
class wxFSWatchEntryKq : public wxFSWatchInfo
{
public:
struct wxDirState
{
wxDirState(const wxFSWatchInfo& winfo)
{
if (!wxDir::Exists(winfo.GetPath()))
return;
wxDir dir(winfo.GetPath());
wxCHECK_RET( dir.IsOpened(),
wxString::Format("Unable to open dir '%s'", winfo.GetPath()));
wxString filename;
bool ret = dir.GetFirst(&filename);
while (ret)
{
files.push_back(filename);
ret = dir.GetNext(&filename);
}
}
wxSortedArrayString files;
};
wxFSWatchEntryKq(const wxFSWatchInfo& winfo) :
wxFSWatchInfo(winfo), m_lastState(winfo)
{
m_fd = wxOpen(m_path, O_RDONLY, 0);
if (m_fd == -1)
{
wxLogSysError(_("Unable to open path '%s'"), m_path);
}
}
virtual ~wxFSWatchEntryKq()
{
(void) Close();
}
bool Close()
{
if (!IsOk())
return false;
int ret = close(m_fd);
if (ret == -1)
{
wxLogSysError(_("Unable to close path '%s'"), m_path);
}
m_fd = -1;
return ret != -1;
}
bool IsOk() const
{
return m_fd != -1;
}
int GetFileDescriptor() const
{
return m_fd;
}
void RefreshState()
{
m_lastState = wxDirState(*this);
}
const wxDirState& GetLastState() const
{
return m_lastState;
}
private:
int m_fd;
wxDirState m_lastState;
wxDECLARE_NO_COPY_CLASS(wxFSWatchEntryKq);
};
#endif /* WX_UNIX_PRIVATE_FSWATCHER_KQUEUE_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/regconf.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/regconf.h
// Purpose: Registry based implementation of wxConfigBase
// Author: Vadim Zeitlin
// Modified by:
// Created: 27.04.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_REGCONF_H_
#define _WX_MSW_REGCONF_H_
#include "wx/defs.h"
#if wxUSE_CONFIG && wxUSE_REGKEY
#include "wx/msw/registry.h"
#include "wx/object.h"
#include "wx/confbase.h"
#include "wx/buffer.h"
// ----------------------------------------------------------------------------
// wxRegConfig
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxRegConfig : public wxConfigBase
{
public:
// ctor & dtor
// will store data in HKLM\appName and HKCU\appName
wxRegConfig(const wxString& appName = wxEmptyString,
const wxString& vendorName = wxEmptyString,
const wxString& localFilename = wxEmptyString,
const wxString& globalFilename = wxEmptyString,
long style = wxCONFIG_USE_GLOBAL_FILE);
// dtor will save unsaved data
virtual ~wxRegConfig(){}
// implement inherited pure virtual functions
// ------------------------------------------
// path management
virtual void SetPath(const wxString& strPath) wxOVERRIDE;
virtual const wxString& GetPath() const wxOVERRIDE { return m_strPath; }
// entry/subgroup info
// enumerate all of them
virtual bool GetFirstGroup(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextGroup (wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetFirstEntry(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextEntry (wxString& str, long& lIndex) const wxOVERRIDE;
// tests for existence
virtual bool HasGroup(const wxString& strName) const wxOVERRIDE;
virtual bool HasEntry(const wxString& strName) const wxOVERRIDE;
virtual EntryType GetEntryType(const wxString& name) const wxOVERRIDE;
// get number of entries/subgroups in the current group, with or without
// it's subgroups
virtual size_t GetNumberOfEntries(bool bRecursive = false) const wxOVERRIDE;
virtual size_t GetNumberOfGroups(bool bRecursive = false) const wxOVERRIDE;
virtual bool Flush(bool WXUNUSED(bCurrentOnly) = false) wxOVERRIDE { return true; }
// rename
virtual bool RenameEntry(const wxString& oldName, const wxString& newName) wxOVERRIDE;
virtual bool RenameGroup(const wxString& oldName, const wxString& newName) wxOVERRIDE;
// delete
virtual bool DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso = true) wxOVERRIDE;
virtual bool DeleteGroup(const wxString& key) wxOVERRIDE;
virtual bool DeleteAll() wxOVERRIDE;
protected:
// opens the local key creating it if necessary and returns it
wxRegKey& LocalKey() const // must be const to be callable from const funcs
{
wxRegConfig* self = wxConstCast(this, wxRegConfig);
if ( !m_keyLocal.IsOpened() )
{
// create on demand
self->m_keyLocal.Create();
}
return self->m_keyLocal;
}
// implement read/write methods
virtual bool DoReadString(const wxString& key, wxString *pStr) const wxOVERRIDE;
virtual bool DoReadLong(const wxString& key, long *plResult) const wxOVERRIDE;
#if wxUSE_BASE64
virtual bool DoReadBinary(const wxString& key, wxMemoryBuffer* buf) const wxOVERRIDE;
#endif // wxUSE_BASE64
virtual bool DoWriteString(const wxString& key, const wxString& szValue) wxOVERRIDE;
virtual bool DoWriteLong(const wxString& key, long lValue) wxOVERRIDE;
#if wxUSE_BASE64
virtual bool DoWriteBinary(const wxString& key, const wxMemoryBuffer& buf) wxOVERRIDE;
#endif // wxUSE_BASE64
private:
// these keys are opened during all lifetime of wxRegConfig object
wxRegKey m_keyLocalRoot, m_keyLocal,
m_keyGlobalRoot, m_keyGlobal;
// current path (not '/' terminated)
wxString m_strPath;
wxDECLARE_NO_COPY_CLASS(wxRegConfig);
wxDECLARE_ABSTRACT_CLASS(wxRegConfig);
};
#endif // wxUSE_CONFIG && wxUSE_REGKEY
#endif // _WX_MSW_REGCONF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/metafile.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/metafile.h
// Purpose: wxMetaFile, wxMetaFileDC and wxMetaFileDataObject classes
// Author: Julian Smart
// Modified by: VZ 07.01.00: implemented wxMetaFileDataObject
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_METAFIILE_H_
#define _WX_METAFIILE_H_
#include "wx/dc.h"
#include "wx/gdiobj.h"
#if wxUSE_DATAOBJ
#include "wx/dataobj.h"
#endif
// ----------------------------------------------------------------------------
// Metafile and metafile device context classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxMetafile;
class WXDLLIMPEXP_CORE wxMetafileRefData: public wxGDIRefData
{
public:
wxMetafileRefData();
virtual ~wxMetafileRefData();
virtual bool IsOk() const wxOVERRIDE { return m_metafile != 0; }
public:
WXHANDLE m_metafile;
int m_windowsMappingMode;
int m_width, m_height;
friend class WXDLLIMPEXP_FWD_CORE wxMetafile;
};
#define M_METAFILEDATA ((wxMetafileRefData *)m_refData)
class WXDLLIMPEXP_CORE wxMetafile: public wxGDIObject
{
public:
wxMetafile(const wxString& file = wxEmptyString);
virtual ~wxMetafile();
// After this is called, the metafile cannot be used for anything
// since it is now owned by the clipboard.
virtual bool SetClipboard(int width = 0, int height = 0);
virtual bool Play(wxDC *dc);
// set/get the size of metafile for clipboard operations
wxSize GetSize() const { return wxSize(GetWidth(), GetHeight()); }
int GetWidth() const { return M_METAFILEDATA->m_width; }
int GetHeight() const { return M_METAFILEDATA->m_height; }
void SetWidth(int width) { M_METAFILEDATA->m_width = width; }
void SetHeight(int height) { M_METAFILEDATA->m_height = height; }
// Implementation
WXHANDLE GetHMETAFILE() const { return M_METAFILEDATA->m_metafile; }
void SetHMETAFILE(WXHANDLE mf) ;
int GetWindowsMappingMode() const { return M_METAFILEDATA->m_windowsMappingMode; }
void SetWindowsMappingMode(int mm);
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxMetafile);
};
class WXDLLIMPEXP_CORE wxMetafileDCImpl: public wxMSWDCImpl
{
public:
wxMetafileDCImpl(wxDC *owner, const wxString& file = wxEmptyString);
wxMetafileDCImpl(wxDC *owner, const wxString& file,
int xext, int yext, int xorg, int yorg);
virtual ~wxMetafileDCImpl();
virtual wxMetafile *Close();
virtual void SetMapMode(wxMappingMode mode) wxOVERRIDE;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *x, wxCoord *y,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
const wxFont *theFont = NULL) const wxOVERRIDE;
// Implementation
wxMetafile *GetMetaFile() const { return m_metaFile; }
void SetMetaFile(wxMetafile *mf) { m_metaFile = mf; }
int GetWindowsMappingMode() const { return m_windowsMappingMode; }
void SetWindowsMappingMode(int mm) { m_windowsMappingMode = mm; }
protected:
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
int m_windowsMappingMode;
wxMetafile* m_metaFile;
private:
wxDECLARE_CLASS(wxMetafileDCImpl);
wxDECLARE_NO_COPY_CLASS(wxMetafileDCImpl);
};
class WXDLLIMPEXP_CORE wxMetafileDC: public wxDC
{
public:
// Don't supply origin and extent
// Supply them to wxMakeMetaFilePlaceable instead.
wxMetafileDC(const wxString& file)
: wxDC(new wxMetafileDCImpl( this, file ))
{ }
// Supply origin and extent (recommended).
// Then don't need to supply them to wxMakeMetaFilePlaceable.
wxMetafileDC(const wxString& file, int xext, int yext, int xorg, int yorg)
: wxDC(new wxMetafileDCImpl( this, file, xext, yext, xorg, yorg ))
{ }
wxMetafile *GetMetafile() const
{ return ((wxMetafileDCImpl*)m_pimpl)->GetMetaFile(); }
wxMetafile *Close()
{ return ((wxMetafileDCImpl*)m_pimpl)->Close(); }
private:
wxDECLARE_CLASS(wxMetafileDC);
wxDECLARE_NO_COPY_CLASS(wxMetafileDC);
};
/*
* Pass filename of existing non-placeable metafile, and bounding box.
* Adds a placeable metafile header, sets the mapping mode to anisotropic,
* and sets the window origin and extent to mimic the wxMM_TEXT mapping mode.
*
*/
// No origin or extent
bool WXDLLIMPEXP_CORE wxMakeMetafilePlaceable(const wxString& filename, float scale = 1.0);
// Optional origin and extent
bool WXDLLIMPEXP_CORE wxMakeMetaFilePlaceable(const wxString& filename, int x1, int y1, int x2, int y2, float scale = 1.0, bool useOriginAndExtent = true);
// ----------------------------------------------------------------------------
// wxMetafileDataObject is a specialization of wxDataObject for metafile data
// ----------------------------------------------------------------------------
#if wxUSE_DATAOBJ
class WXDLLIMPEXP_CORE wxMetafileDataObject : public wxDataObjectSimple
{
public:
// ctors
wxMetafileDataObject() : wxDataObjectSimple(wxDF_METAFILE)
{ }
wxMetafileDataObject(const wxMetafile& metafile)
: wxDataObjectSimple(wxDF_METAFILE), m_metafile(metafile) { }
// virtual functions which you may override if you want to provide data on
// demand only - otherwise, the trivial default versions will be used
virtual void SetMetafile(const wxMetafile& metafile)
{ m_metafile = metafile; }
virtual wxMetafile GetMetafile() const
{ return m_metafile; }
// implement base class pure virtuals
virtual size_t GetDataSize() const wxOVERRIDE;
virtual bool GetDataHere(void *buf) const wxOVERRIDE;
virtual bool SetData(size_t len, const void *buf) wxOVERRIDE;
protected:
wxMetafile m_metafile;
};
#endif // wxUSE_DATAOBJ
#endif
// _WX_METAFIILE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/webviewhistoryitem_ie.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/webviewhistoryitem.h
// Purpose: wxWebViewHistoryItem header for MSW
// Author: Steven Lamerton
// Copyright: (c) 2011 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WEBVIEWHISTORYITEM_H_
#define _WX_MSW_WEBVIEWHISTORYITEM_H_
#include "wx/setup.h"
#if wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE && defined(__WXMSW__)
class WXDLLIMPEXP_WEBVIEW wxWebViewHistoryItem
{
public:
wxWebViewHistoryItem(const wxString& url, const wxString& title) :
m_url(url), m_title(title) {}
wxString GetUrl() { return m_url; }
wxString GetTitle() { return m_title; }
private:
wxString m_url, m_title;
};
#endif // wxUSE_WEBVIEW && wxUSE_WEBVIEW_IE && defined(__WXMSW__)
#endif // _WX_MSW_WEBVIEWHISTORYITEM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/helpwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpwin.h
// Purpose: Help system: WinHelp implementation
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPWIN_H_
#define _WX_HELPWIN_H_
#include "wx/wx.h"
#if wxUSE_HELP
#include "wx/helpbase.h"
class WXDLLIMPEXP_CORE wxWinHelpController: public wxHelpControllerBase
{
wxDECLARE_DYNAMIC_CLASS(wxWinHelpController);
public:
wxWinHelpController(wxWindow* parentWindow = NULL): wxHelpControllerBase(parentWindow) {}
virtual ~wxWinHelpController() {}
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE;
virtual bool DisplayContents() wxOVERRIDE;
virtual bool DisplaySection(int sectionNo) wxOVERRIDE;
virtual bool DisplaySection(const wxString& section) wxOVERRIDE { return KeywordSearch(section); }
virtual bool DisplayBlock(long blockNo) wxOVERRIDE;
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE;
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE;
virtual bool Quit() wxOVERRIDE;
inline wxString GetHelpFile() const { return m_helpFile; }
protected:
// Append extension if necessary.
wxString GetValidFilename(const wxString& file) const;
private:
wxString m_helpFile;
};
#endif // wxUSE_HELP
#endif
// _WX_HELPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/dcclient.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dcclient.h
// Purpose: wxClientDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCCLIENT_H_
#define _WX_DCCLIENT_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/dc.h"
#include "wx/msw/dc.h"
#include "wx/dcclient.h"
class wxPaintDCInfo;
// ----------------------------------------------------------------------------
// DC classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxWindowDCImpl : public wxMSWDCImpl
{
public:
// default ctor
wxWindowDCImpl( wxDC *owner );
// Create a DC corresponding to the whole window
wxWindowDCImpl( wxDC *owner, wxWindow *win );
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
protected:
// initialize the newly created DC
void InitDC();
wxDECLARE_CLASS(wxWindowDCImpl);
wxDECLARE_NO_COPY_CLASS(wxWindowDCImpl);
};
class WXDLLIMPEXP_CORE wxClientDCImpl : public wxWindowDCImpl
{
public:
// default ctor
wxClientDCImpl( wxDC *owner );
// Create a DC corresponding to the client area of the window
wxClientDCImpl( wxDC *owner, wxWindow *win );
virtual ~wxClientDCImpl();
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
protected:
void InitDC();
wxDECLARE_CLASS(wxClientDCImpl);
wxDECLARE_NO_COPY_CLASS(wxClientDCImpl);
};
class WXDLLIMPEXP_CORE wxPaintDCImpl : public wxClientDCImpl
{
public:
wxPaintDCImpl( wxDC *owner );
// Create a DC corresponding for painting the window in OnPaint()
wxPaintDCImpl( wxDC *owner, wxWindow *win );
virtual ~wxPaintDCImpl();
// find the entry for this DC in the cache (keyed by the window)
static WXHDC FindDCInCache(wxWindow* win);
// This must be called by the code handling WM_PAINT to remove the DC
// cached for this window for the duration of this message processing.
static void EndPaint(wxWindow *win);
protected:
// Find the DC for this window in the cache, return NULL if not found.
static wxPaintDCInfo *FindInCache(wxWindow* win);
wxDECLARE_CLASS(wxPaintDCImpl);
wxDECLARE_NO_COPY_CLASS(wxPaintDCImpl);
};
/*
* wxPaintDCEx
* This class is used when an application sends an HDC with the WM_PAINT
* message. It is used in HandlePaint and need not be used by an application.
*/
class WXDLLIMPEXP_CORE wxPaintDCEx : public wxPaintDC
{
public:
wxPaintDCEx(wxWindow *canvas, WXHDC dc);
wxDECLARE_CLASS(wxPaintDCEx);
wxDECLARE_NO_COPY_CLASS(wxPaintDCEx);
};
#endif
// _WX_DCCLIENT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/setup.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/setup.h
// Purpose: Configuration for the library
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SETUP_H_
#define _WX_SETUP_H_
/* --- start common options --- */
// ----------------------------------------------------------------------------
// global settings
// ----------------------------------------------------------------------------
// define this to 0 when building wxBase library - this can also be done from
// makefile/project file overriding the value here
#ifndef wxUSE_GUI
#define wxUSE_GUI 1
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
// compatibility settings
// ----------------------------------------------------------------------------
// This setting determines the compatibility with 2.8 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_2_8 0
// This setting determines the compatibility with 3.0 API: set it to 0 to
// flag all cases of using deprecated functions.
//
// Default is 1 but please try building your code with 0 as the default will
// change to 0 in the next version and the deprecated functions will disappear
// in the version after it completely.
//
// Recommended setting: 0 (please update your code)
#define WXWIN_COMPATIBILITY_3_0 1
// MSW-only: Set to 0 for accurate dialog units, else 1 for old behaviour when
// default system font is used for wxWindow::GetCharWidth/Height() instead of
// the current font.
//
// Default is 0
//
// Recommended setting: 0
#define wxDIALOG_UNIT_COMPATIBILITY 0
// Provide unsafe implicit conversions in wxString to "const char*" or
// "std::string" (depending on wxUSE_STD_STRING_CONV_IN_WXSTRING value).
//
// Default is 1 but only for compatibility reasons, it is recommended to set
// this to 0 because converting wxString to a narrow (non-Unicode) string may
// fail unless a locale using UTF-8 encoding is used, which is never the case
// under MSW, for example, hence such conversions can result in silent data
// loss.
//
// Recommended setting: 0
#define wxUSE_UNSAFE_WXSTRING_CONV 1
// If set to 1, enables "reproducible builds", i.e. build output should be
// exactly the same if the same build is redone again. As using __DATE__ and
// __TIME__ macros clearly makes the build irreproducible, setting this option
// to 1 disables their use in the library code.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_REPRODUCIBLE_BUILD 0
// ----------------------------------------------------------------------------
// debugging settings
// ----------------------------------------------------------------------------
// wxDEBUG_LEVEL will be defined as 1 in wx/debug.h so normally there is no
// need to define it here. You may do it for two reasons: either completely
// disable/compile out the asserts in release version (then do it inside #ifdef
// NDEBUG) or, on the contrary, enable more asserts, including the usually
// disabled ones, in the debug build (then do it inside #ifndef NDEBUG)
//
// #ifdef NDEBUG
// #define wxDEBUG_LEVEL 0
// #else
// #define wxDEBUG_LEVEL 2
// #endif
// wxHandleFatalExceptions() may be used to catch the program faults at run
// time and, instead of terminating the program with a usual GPF message box,
// call the user-defined wxApp::OnFatalException() function. If you set
// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
//
// This setting is for Win32 only and can only be enabled if your compiler
// supports Win32 structured exception handling (currently only VC++ does)
//
// Default is 1
//
// Recommended setting: 1 if your compiler supports it.
#define wxUSE_ON_FATAL_EXCEPTION 1
// Set this to 1 to be able to generate a human-readable (unlike
// machine-readable minidump created by wxCrashReport::Generate()) stack back
// trace when your program crashes using wxStackWalker
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_STACKWALKER 1
// Set this to 1 to compile in wxDebugReport class which allows you to create
// and optionally upload to your web site a debug report consisting of back
// trace of the crash (if wxUSE_STACKWALKER == 1) and other information.
//
// Default is 1 if supported by the compiler.
//
// Recommended setting: 1, it is compiled into a separate library so there
// is no overhead if you don't use it
#define wxUSE_DEBUGREPORT 1
// Generic comment about debugging settings: they are very useful if you don't
// use any other memory leak detection tools such as Purify/BoundsChecker, but
// are probably redundant otherwise. Also, Visual C++ CRT has the same features
// as wxWidgets memory debugging subsystem built in since version 5.0 and you
// may prefer to use it instead of built in memory debugging code because it is
// faster and more fool proof.
//
// Using VC++ CRT memory debugging is enabled by default in debug build (_DEBUG
// is defined) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
// and if __NO_VC_CRTDBG__ is not defined.
// The rest of the options in this section are obsolete and not supported,
// enable them at your own risk.
// If 1, enables wxDebugContext, for writing error messages to file, etc. If
// __WXDEBUG__ is not defined, will still use the normal memory operators.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_CONTEXT 0
// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
// __WXDEBUG__ is also defined.
//
// WARNING: this code may not work with all architectures, especially if
// alignment is an issue. This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 1 if you are not using a memory debugging tool, else 0
#define wxUSE_MEMORY_TRACING 0
// In debug mode, cause new and delete to be redefined globally.
// If this causes problems (e.g. link errors which is a common problem
// especially if you use another library which also redefines the global new
// and delete), set this to 0.
// This switch is currently ignored for mingw / cygwin
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
// this causes problems (e.g. link errors), set this to 0. You may need to set
// this to 0 if using templates (at least for VC++). This switch is currently
// ignored for MinGW/Cygwin.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_DEBUG_NEW_ALWAYS 0
// ----------------------------------------------------------------------------
// Unicode support
// ----------------------------------------------------------------------------
// These settings are obsolete: the library is always built in Unicode mode
// now, only set wxUSE_UNICODE to 0 to compile legacy code in ANSI mode if
// absolutely necessary -- updating it is strongly recommended as the ANSI mode
// will disappear completely in future wxWidgets releases.
#ifndef wxUSE_UNICODE
#define wxUSE_UNICODE 1
#endif
// wxUSE_WCHAR_T is required by wxWidgets now, don't change.
#define wxUSE_WCHAR_T 1
// ----------------------------------------------------------------------------
// global features
// ----------------------------------------------------------------------------
// Compile library in exception-safe mode? If set to 1, the library will try to
// behave correctly in presence of exceptions (even though it still will not
// use the exceptions itself) and notify the user code about any unhandled
// exceptions. If set to 0, propagation of the exceptions through the library
// code will lead to undefined behaviour -- but the code itself will be
// slightly smaller and faster.
//
// Note that like wxUSE_THREADS this option is automatically set to 0 if
// wxNO_EXCEPTIONS is defined.
//
// Default is 1
//
// Recommended setting: depends on whether you intend to use C++ exceptions
// in your own code (1 if you do, 0 if you don't)
#define wxUSE_EXCEPTIONS 1
// Set wxUSE_EXTENDED_RTTI to 1 to use extended RTTI
//
// Default is 0
//
// Recommended setting: 0 (this is still work in progress...)
#define wxUSE_EXTENDED_RTTI 0
// Support for message/error logging. This includes wxLogXXX() functions and
// wxLog and derived classes. Don't set this to 0 unless you really know what
// you are doing.
//
// Default is 1
//
// Recommended setting: 1 (always)
#define wxUSE_LOG 1
// Recommended setting: 1
#define wxUSE_LOGWINDOW 1
// Recommended setting: 1
#define wxUSE_LOGGUI 1
// Recommended setting: 1
#define wxUSE_LOG_DIALOG 1
// Support for command line parsing using wxCmdLineParser class.
//
// Default is 1
//
// Recommended setting: 1 (can be set to 0 if you don't use the cmd line)
#define wxUSE_CMDLINE_PARSER 1
// Support for multithreaded applications: if 1, compile in thread classes
// (thread.h) and make the library a bit more thread safe. Although thread
// support is quite stable by now, you may still consider recompiling the
// library without it if you have no use for it - this will result in a
// somewhat smaller and faster operation.
//
// Notice that if wxNO_THREADS is defined, wxUSE_THREADS is automatically reset
// to 0 in wx/chkconf.h, so, for example, if you set USE_THREADS to 0 in
// build/msw/config.* file this value will have no effect.
//
// Default is 1
//
// Recommended setting: 0 unless you do plan to develop MT applications
#define wxUSE_THREADS 1
// If enabled, compiles wxWidgets streams classes
//
// wx stream classes are used for image IO, process IO redirection, network
// protocols implementation and much more and so disabling this results in a
// lot of other functionality being lost.
//
// Default is 1
//
// Recommended setting: 1 as setting it to 0 disables many other things
#define wxUSE_STREAMS 1
// Support for positional parameters (e.g. %1$d, %2$s ...) in wxVsnprintf.
// Note that if the system's implementation does not support positional
// parameters, setting this to 1 forces the use of the wxWidgets implementation
// of wxVsnprintf. The standard vsnprintf() supports positional parameters on
// many Unix systems but usually doesn't under Windows.
//
// Positional parameters are very useful when translating a program since using
// them in formatting strings allow translators to correctly reorder the
// translated sentences.
//
// Default is 1
//
// Recommended setting: 1 if you want to support multiple languages
#define wxUSE_PRINTF_POS_PARAMS 1
// Enable the use of compiler-specific thread local storage keyword, if any.
// This is used for wxTLS_XXX() macros implementation and normally should use
// the compiler-provided support as it's simpler and more efficient, but is
// disabled under Windows in wx/msw/chkconf.h as it can't be used if wxWidgets
// is used in a dynamically loaded Win32 DLL (i.e. using LoadLibrary()) under
// XP as this triggers a bug in compiler TLS support that results in crashes
// when any TLS variables are used.
//
// If you're absolutely sure that your build of wxWidgets is never going to be
// used in such situation, either because it's not going to be linked from any
// kind of plugin or because you only target Vista or later systems, you can
// set this to 2 to force the use of compiler TLS even under MSW.
//
// Default is 1 meaning that compiler TLS is used only if it's 100% safe.
//
// Recommended setting: 2 if you want to have maximal performance and don't
// care about the scenario described above.
#define wxUSE_COMPILER_TLS 1
// ----------------------------------------------------------------------------
// Interoperability with the standard library.
// ----------------------------------------------------------------------------
// Set wxUSE_STL to 1 to enable maximal interoperability with the standard
// library, even at the cost of backwards compatibility.
//
// Default is 0
//
// Recommended setting: 0 as the options below already provide a relatively
// good level of interoperability and changing this option arguably isn't worth
// diverging from the official builds of the library.
#define wxUSE_STL 0
// This is not a real option but is used as the default value for
// wxUSE_STD_IOSTREAM, wxUSE_STD_STRING and wxUSE_STD_CONTAINERS_COMPATIBLY.
//
// Set it to 0 if you want to disable the use of all standard classes
// completely for some reason.
#define wxUSE_STD_DEFAULT 1
// Use standard C++ containers where it can be done without breaking backwards
// compatibility.
//
// This provides better interoperability with the standard library, e.g. with
// this option on it's possible to insert std::vector<> into many wxWidgets
// containers directly.
//
// Default is 1.
//
// Recommended setting is 1 unless you want to avoid all dependencies on the
// standard library.
#define wxUSE_STD_CONTAINERS_COMPATIBLY wxUSE_STD_DEFAULT
// Use standard C++ containers to implement wxVector<>, wxStack<>, wxDList<>
// and wxHashXXX<> classes. If disabled, wxWidgets own (mostly compatible but
// usually more limited) implementations are used which allows to avoid the
// dependency on the C++ run-time library.
//
// Default is 0 for compatibility reasons.
//
// Recommended setting: 1 unless compatibility with the official wxWidgets
// build and/or the existing code is a concern.
#define wxUSE_STD_CONTAINERS 0
// Use standard C++ streams if 1 instead of wx streams in some places. If
// disabled, wx streams are used everywhere and wxWidgets doesn't depend on the
// standard streams library.
//
// Notice that enabling this does not replace wx streams with std streams
// everywhere, in a lot of places wx streams are used no matter what.
//
// Default is 1 if compiler supports it.
//
// Recommended setting: 1 if you use the standard streams anyhow and so
// dependency on the standard streams library is not a
// problem
#define wxUSE_STD_IOSTREAM wxUSE_STD_DEFAULT
// Enable minimal interoperability with the standard C++ string class if 1.
// "Minimal" means that wxString can be constructed from std::string or
// std::wstring but can't be implicitly converted to them. You need to enable
// the option below for the latter.
//
// Default is 1 for most compilers.
//
// Recommended setting: 1 unless you want to ensure your program doesn't use
// the standard C++ library at all.
#define wxUSE_STD_STRING wxUSE_STD_DEFAULT
// Make wxString as much interchangeable with std::[w]string as possible, in
// particular allow implicit conversion of wxString to either of these classes.
// This comes at a price (or a benefit, depending on your point of view) of not
// allowing implicit conversion to "const char *" and "const wchar_t *".
//
// Because a lot of existing code relies on these conversions, this option is
// disabled by default but can be enabled for your build if you don't care
// about compatibility.
//
// Default is 0 if wxUSE_STL has its default value or 1 if it is enabled.
//
// Recommended setting: 0 to remain compatible with the official builds of
// wxWidgets.
#define wxUSE_STD_STRING_CONV_IN_WXSTRING wxUSE_STL
// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
// them. Set this option to 1 to use <iostream.h>, 0 to use <iostream>.
//
// Note that newer compilers (including VC++ 7.1 and later) don't support
// wxUSE_IOSTREAMH == 1 and so <iostream> will be used anyhow.
//
// Default is 0.
//
// Recommended setting: 0, only set to 1 if you use a really old compiler
#define wxUSE_IOSTREAMH 0
// ----------------------------------------------------------------------------
// non GUI features selection
// ----------------------------------------------------------------------------
// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
// integer which is implemented in terms of native 64 bit integers if any or
// uses emulation otherwise.
//
// This class is required by wxDateTime and so you should enable it if you want
// to use wxDateTime. For most modern platforms, it will use the native 64 bit
// integers in which case (almost) all of its functions are inline and it
// almost does not take any space, so there should be no reason to switch it
// off.
//
// Recommended setting: 1
#define wxUSE_LONGLONG 1
// Set wxUSE_BASE64 to 1, to compile in Base64 support. This is required for
// storing binary data in wxConfig on most platforms.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_BASE64 1
// Set this to 1 to be able to use wxEventLoop even in console applications
// (i.e. using base library only, without GUI). This is mostly useful for
// processing socket events but is also necessary to use timers in console
// applications
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_CONSOLE_EVENTLOOP 1
// Set wxUSE_(F)FILE to 1 to compile wx(F)File classes. wxFile uses low level
// POSIX functions for file access, wxFFile uses ANSI C stdio.h functions.
//
// Default is 1
//
// Recommended setting: 1 (wxFile is highly recommended as it is required by
// i18n code, wxFileConfig and others)
#define wxUSE_FILE 1
#define wxUSE_FFILE 1
// Use wxFSVolume class providing access to the configured/active mount points
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_FSVOLUME 1
// Use wxSecretStore class for storing passwords using OS-specific facilities.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely disabled if you don't use it)
#define wxUSE_SECRETSTORE 1
// Use wxStandardPaths class which allows to retrieve some standard locations
// in the file system
//
// Default is 1
//
// Recommended setting: 1 (may be disabled to save space, but not much)
#define wxUSE_STDPATHS 1
// use wxTextBuffer class: required by wxTextFile
#define wxUSE_TEXTBUFFER 1
// use wxTextFile class: requires wxFile and wxTextBuffer, required by
// wxFileConfig
#define wxUSE_TEXTFILE 1
// i18n support: _() macro, wxLocale class. Requires wxTextFile.
#define wxUSE_INTL 1
// Provide wxFoo_l() functions similar to standard foo() functions but taking
// an extra locale parameter.
//
// Notice that this is fully implemented only for the systems providing POSIX
// xlocale support or Microsoft Visual C++ >= 8 (which provides proprietary
// almost-equivalent of xlocale functions), otherwise wxFoo_l() functions will
// only work for the current user locale and "C" locale. You can use
// wxHAS_XLOCALE_SUPPORT to test whether the full support is available.
//
// Default is 1
//
// Recommended setting: 1 but may be disabled if you are writing programs
// running only in C locale anyhow
#define wxUSE_XLOCALE 1
// Set wxUSE_DATETIME to 1 to compile the wxDateTime and related classes which
// allow to manipulate dates, times and time intervals.
//
// Requires: wxUSE_LONGLONG
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_DATETIME 1
// Set wxUSE_TIMER to 1 to compile wxTimer class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_TIMER 1
// Use wxStopWatch clas.
//
// Default is 1
//
// Recommended setting: 1 (needed by wxSocket)
#define wxUSE_STOPWATCH 1
// Set wxUSE_FSWATCHER to 1 if you want to enable wxFileSystemWatcher
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FSWATCHER 1
// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
// which allow the application to store its settings in the persistent
// storage. Setting this to 1 will also enable on-demand creation of the
// global config object in wxApp.
//
// See also wxUSE_CONFIG_NATIVE below.
//
// Recommended setting: 1
#define wxUSE_CONFIG 1
// If wxUSE_CONFIG is 1, you may choose to use either the native config
// classes under Windows (using .INI files under Win16 and the registry under
// Win32) or the portable text file format used by the config classes under
// Unix.
//
// Default is 1 to use native classes. Note that you may still use
// wxFileConfig even if you set this to 1 - just the config object created by
// default for the applications needs will be a wxRegConfig or wxIniConfig and
// not wxFileConfig.
//
// Recommended setting: 1
#define wxUSE_CONFIG_NATIVE 1
// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
// to connect/disconnect from the network and be notified whenever the dial-up
// network connection is established/terminated. Requires wxUSE_DYNAMIC_LOADER.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DIALUP_MANAGER 1
// Compile in classes for run-time DLL loading and function calling.
// Required by wxUSE_DIALUP_MANAGER.
//
// This setting is for Win32 only
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DYNLIB_CLASS 1
// experimental, don't use for now
#define wxUSE_DYNAMIC_LOADER 1
// Set to 1 to use socket classes
#define wxUSE_SOCKETS 1
// Set to 1 to use ipv6 socket classes (requires wxUSE_SOCKETS)
//
// Notice that currently setting this option under Windows will result in
// programs which can only run on recent OS versions (with ws2_32.dll
// installed) which is why it is disabled by default.
//
// Default is 1.
//
// Recommended setting: 1 if you need IPv6 support
#define wxUSE_IPV6 0
// Set to 1 to enable virtual file systems (required by wxHTML)
#define wxUSE_FILESYSTEM 1
// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ZIP 1
// Set to 1 to enable virtual archive filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_ARCHIVE 1
// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
#define wxUSE_FS_INET 1
// wxArchive classes for accessing archives such as zip and tar
#define wxUSE_ARCHIVE_STREAMS 1
// Set to 1 to compile wxZipInput/OutputStream classes.
#define wxUSE_ZIPSTREAM 1
// Set to 1 to compile wxTarInput/OutputStream classes.
#define wxUSE_TARSTREAM 1
// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
// wxUSE_LIBPNG
#define wxUSE_ZLIB 1
// Set to 1 if liblzma is available to enable wxLZMA{Input,Output}Stream
// classes.
//
// Notice that if you enable this build option when not using configure or
// CMake, you need to ensure that liblzma headers and libraries are available
// (i.e. by building the library yourself or downloading its binaries) and can
// be found, either by copying them to one of the locations searched by the
// compiler/linker by default (e.g. any of the directories in the INCLUDE or
// LIB environment variables, respectively, when using MSVC) or modify the
// make- or project files to add references to these directories.
//
// Default is 0 under MSW, auto-detected by configure.
//
// Recommended setting: 1 if you need LZMA compression.
#define wxUSE_LIBLZMA 0
// If enabled, the code written by Apple will be used to write, in a portable
// way, float on the disk. See extended.c for the license which is different
// from wxWidgets one.
//
// Default is 1.
//
// Recommended setting: 1 unless you don't like the license terms (unlikely)
#define wxUSE_APPLE_IEEE 1
// Joystick support class
#define wxUSE_JOYSTICK 1
// wxFontEnumerator class
#define wxUSE_FONTENUM 1
// wxFontMapper class
#define wxUSE_FONTMAP 1
// wxMimeTypesManager class
#define wxUSE_MIMETYPE 1
// wxProtocol and related classes: if you want to use either of wxFTP, wxHTTP
// or wxURL you need to set this to 1.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_PROTOCOL 1
// The settings for the individual URL schemes
#define wxUSE_PROTOCOL_FILE 1
#define wxUSE_PROTOCOL_FTP 1
#define wxUSE_PROTOCOL_HTTP 1
// Define this to use wxURL class.
#define wxUSE_URL 1
// Define this to use native platform url and protocol support.
// Currently valid only for MS-Windows.
// Note: if you set this to 1, you can open ftp/http/gopher sites
// and obtain a valid input stream for these sites
// even when you set wxUSE_PROTOCOL_FTP/HTTP to 0.
// Doing so reduces the code size.
//
// This code is experimental and subject to change.
#define wxUSE_URL_NATIVE 0
// Support for wxVariant class used in several places throughout the library,
// notably in wxDataViewCtrl API.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size as much as
// possible in which case setting this to 0 can gain up to 100KB.
#define wxUSE_VARIANT 1
// Support for wxAny class, the successor for wxVariant.
//
// Default is 1.
//
// Recommended setting: 1 unless you want to reduce the library size by a small amount,
// or your compiler cannot for some reason cope with complexity of templates used.
#define wxUSE_ANY 1
// Support for regular expression matching via wxRegEx class: enable this to
// use POSIX regular expressions in your code. You need to compile regex
// library from src/regex to use it under Windows.
//
// Default is 0
//
// Recommended setting: 1 if your compiler supports it, if it doesn't please
// contribute us a makefile for src/regex for it
#define wxUSE_REGEX 1
// wxSystemOptions class
#define wxUSE_SYSTEM_OPTIONS 1
// wxSound class
#define wxUSE_SOUND 1
// Use wxMediaCtrl
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_MEDIACTRL 1
// Use wxWidget's XRC XML-based resource system. Recommended.
//
// Default is 1
//
// Recommended setting: 1 (requires wxUSE_XML)
#define wxUSE_XRC 1
// XML parsing classes. Note that their API will change in the future, so
// using wxXmlDocument and wxXmlNode in your app is not recommended.
//
// Default is the same as wxUSE_XRC, i.e. 1 by default.
//
// Recommended setting: 1 (required by XRC)
#define wxUSE_XML wxUSE_XRC
// Use wxWidget's AUI docking system
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_AUI 1
// Use wxWidget's Ribbon classes for interfaces
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_RIBBON 1
// Use wxPropertyGrid.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_PROPGRID 1
// Use wxStyledTextCtrl, a wxWidgets implementation of Scintilla.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STC 1
// Use wxWidget's web viewing classes
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_WEBVIEW 1
// Use the IE wxWebView backend
//
// Default is 1 on MSW
//
// Recommended setting: 1
#ifdef __WXMSW__
#define wxUSE_WEBVIEW_IE 1
#else
#define wxUSE_WEBVIEW_IE 0
#endif
// Use the WebKit wxWebView backend
//
// Default is 1 on GTK and OSX
//
// Recommended setting: 1
#if (defined(__WXGTK__) && !defined(__WXGTK3__)) || defined(__WXOSX__)
#define wxUSE_WEBVIEW_WEBKIT 1
#else
#define wxUSE_WEBVIEW_WEBKIT 0
#endif
// Use the WebKit2 wxWebView backend
//
// Default is 1 on GTK3
//
// Recommended setting: 1
#if defined(__WXGTK3__)
#define wxUSE_WEBVIEW_WEBKIT2 1
#else
#define wxUSE_WEBVIEW_WEBKIT2 0
#endif
// Enable wxGraphicsContext and related classes for a modern 2D drawing API.
//
// Default is 1 except if you're using a compiler without support for GDI+
// under MSW, i.e. gdiplus.h and related headers (MSVC and MinGW >= 4.8 are
// known to have them). For other compilers (e.g. older mingw32) you may need
// to install the headers (and just the headers) yourself. If you do, change
// the setting below manually.
//
// Recommended setting: 1 if supported by the compilation environment
// Notice that we can't use wxCHECK_VISUALC_VERSION() nor wxCHECK_GCC_VERSION()
// here as this file is included from wx/platform.h before they're defined.
#if defined(_MSC_VER) || \
(defined(__MINGW32__) && (__GNUC__ > 4 || __GNUC_MINOR__ >= 8))
#define wxUSE_GRAPHICS_CONTEXT 1
#else
// Disable support for other Windows compilers, enable it if your compiler
// comes with new enough SDK or you installed the headers manually.
//
// Notice that this will be set by configure under non-Windows platforms
// anyhow so the value there is not important.
#define wxUSE_GRAPHICS_CONTEXT 0
#endif
// Enable wxGraphicsContext implementation using Cairo library.
//
// This is not needed under Windows and detected automatically by configure
// under other systems, however you may set this to 1 manually if you installed
// Cairo under Windows yourself and prefer to use it instead the native GDI+
// implementation.
//
// Default is 0
//
// Recommended setting: 0
#define wxUSE_CAIRO 0
// ----------------------------------------------------------------------------
// Individual GUI controls
// ----------------------------------------------------------------------------
// You must set wxUSE_CONTROLS to 1 if you are using any controls at all
// (without it, wxControl class is not compiled)
//
// Default is 1
//
// Recommended setting: 1 (don't change except for very special programs)
#define wxUSE_CONTROLS 1
// Support markup in control labels, i.e. provide wxControl::SetLabelMarkup().
// Currently markup is supported only by a few controls and only some ports but
// their number will increase with time.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you want to save on code size)
#define wxUSE_MARKUP 1
// wxPopupWindow class is a top level transient window. It is currently used
// to implement wxTipWindow
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0 if you don't wxUSE_TIPWINDOW)
#define wxUSE_POPUPWIN 1
// wxTipWindow allows to implement the custom tooltips, it is used by the
// context help classes. Requires wxUSE_POPUPWIN.
//
// Default is 1
//
// Recommended setting: 1 (may be set to 0)
#define wxUSE_TIPWINDOW 1
// Each of the settings below corresponds to one wxWidgets control. They are
// all switched on by default but may be disabled if you are sure that your
// program (including any standard dialogs it can show!) doesn't need them and
// if you desperately want to save some space. If you use any of these you must
// set wxUSE_CONTROLS as well.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_ACTIVITYINDICATOR 1 // wxActivityIndicator
#define wxUSE_ANIMATIONCTRL 1 // wxAnimationCtrl
#define wxUSE_BANNERWINDOW 1 // wxBannerWindow
#define wxUSE_BUTTON 1 // wxButton
#define wxUSE_BMPBUTTON 1 // wxBitmapButton
#define wxUSE_CALENDARCTRL 1 // wxCalendarCtrl
#define wxUSE_CHECKBOX 1 // wxCheckBox
#define wxUSE_CHECKLISTBOX 1 // wxCheckListBox (requires wxUSE_OWNER_DRAWN)
#define wxUSE_CHOICE 1 // wxChoice
#define wxUSE_COLLPANE 1 // wxCollapsiblePane
#define wxUSE_COLOURPICKERCTRL 1 // wxColourPickerCtrl
#define wxUSE_COMBOBOX 1 // wxComboBox
#define wxUSE_COMMANDLINKBUTTON 1 // wxCommandLinkButton
#define wxUSE_DATAVIEWCTRL 1 // wxDataViewCtrl
#define wxUSE_DATEPICKCTRL 1 // wxDatePickerCtrl
#define wxUSE_DIRPICKERCTRL 1 // wxDirPickerCtrl
#define wxUSE_EDITABLELISTBOX 1 // wxEditableListBox
#define wxUSE_FILECTRL 1 // wxFileCtrl
#define wxUSE_FILEPICKERCTRL 1 // wxFilePickerCtrl
#define wxUSE_FONTPICKERCTRL 1 // wxFontPickerCtrl
#define wxUSE_GAUGE 1 // wxGauge
#define wxUSE_HEADERCTRL 1 // wxHeaderCtrl
#define wxUSE_HYPERLINKCTRL 1 // wxHyperlinkCtrl
#define wxUSE_LISTBOX 1 // wxListBox
#define wxUSE_LISTCTRL 1 // wxListCtrl
#define wxUSE_RADIOBOX 1 // wxRadioBox
#define wxUSE_RADIOBTN 1 // wxRadioButton
#define wxUSE_RICHMSGDLG 1 // wxRichMessageDialog
#define wxUSE_SCROLLBAR 1 // wxScrollBar
#define wxUSE_SEARCHCTRL 1 // wxSearchCtrl
#define wxUSE_SLIDER 1 // wxSlider
#define wxUSE_SPINBTN 1 // wxSpinButton
#define wxUSE_SPINCTRL 1 // wxSpinCtrl
#define wxUSE_STATBOX 1 // wxStaticBox
#define wxUSE_STATLINE 1 // wxStaticLine
#define wxUSE_STATTEXT 1 // wxStaticText
#define wxUSE_STATBMP 1 // wxStaticBitmap
#define wxUSE_TEXTCTRL 1 // wxTextCtrl
#define wxUSE_TIMEPICKCTRL 1 // wxTimePickerCtrl
#define wxUSE_TOGGLEBTN 1 // requires wxButton
#define wxUSE_TREECTRL 1 // wxTreeCtrl
#define wxUSE_TREELISTCTRL 1 // wxTreeListCtrl
// Use a status bar class? Depending on the value of wxUSE_NATIVE_STATUSBAR
// below either wxStatusBar95 or a generic wxStatusBar will be used.
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_STATUSBAR 1
// Two status bar implementations are available under Win32: the generic one
// or the wrapper around native control. For native look and feel the native
// version should be used.
//
// Default is 1 for the platforms where native status bar is supported.
//
// Recommended setting: 1 (there is no advantage in using the generic one)
#define wxUSE_NATIVE_STATUSBAR 1
// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
// classes at all. Otherwise, use the native toolbar class unless
// wxUSE_TOOLBAR_NATIVE is 0.
//
// Default is 1 for all settings.
//
// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE.
#define wxUSE_TOOLBAR 1
#define wxUSE_TOOLBAR_NATIVE 1
// wxNotebook is a control with several "tabs" located on one of its sides. It
// may be used to logically organise the data presented to the user instead of
// putting everything in one huge dialog. It replaces wxTabControl and related
// classes of wxWin 1.6x.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTEBOOK 1
// wxListbook control is similar to wxNotebook but uses wxListCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_LISTBOOK 1
// wxChoicebook control is similar to wxNotebook but uses wxChoice instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CHOICEBOOK 1
// wxTreebook control is similar to wxNotebook but uses wxTreeCtrl instead of
// the tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TREEBOOK 1
// wxToolbook control is similar to wxNotebook but uses wxToolBar instead of
// tabs
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLBOOK 1
// wxTaskBarIcon is a small notification icon shown in the system toolbar or
// dock.
//
// Default is 1.
//
// Recommended setting: 1 (but can be set to 0 if you don't need it)
#define wxUSE_TASKBARICON 1
// wxGrid class
//
// Default is 1, set to 0 to cut down compilation time and binaries size if you
// don't use it.
//
// Recommended setting: 1
//
#define wxUSE_GRID 1
// wxMiniFrame class: a frame with narrow title bar
//
// Default is 1.
//
// Recommended setting: 1 (it doesn't cost almost anything)
#define wxUSE_MINIFRAME 1
// wxComboCtrl and related classes: combobox with custom popup window and
// not necessarily a listbox.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 except for wxUniv where it
// it used by wxComboBox
#define wxUSE_COMBOCTRL 1
// wxOwnerDrawnComboBox is a custom combobox allowing to paint the combobox
// items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0, except where it is
// needed as a base class for generic wxBitmapComboBox.
#define wxUSE_ODCOMBOBOX 1
// wxBitmapComboBox is a combobox that can have images in front of text items.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0
#define wxUSE_BITMAPCOMBOBOX 1
// wxRearrangeCtrl is a wxCheckListBox with two buttons allowing to move items
// up and down in it. It is also used as part of wxRearrangeDialog.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 (currently used only by
// wxHeaderCtrl)
#define wxUSE_REARRANGECTRL 1
// wxAddRemoveCtrl is a composite control containing a control showing some
// items (e.g. wxListBox, wxListCtrl, wxTreeCtrl, wxDataViewCtrl, ...) and "+"/
// "-" buttons allowing to add and remove items to/from the control.
//
// Default is 1.
//
// Recommended setting: 1 but can be safely set to 0 if you don't need it (not
// used by the library itself).
#define wxUSE_ADDREMOVECTRL 1
// ----------------------------------------------------------------------------
// Miscellaneous GUI stuff
// ----------------------------------------------------------------------------
// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
#define wxUSE_ACCEL 1
// Use the standard art provider. The icons returned by this provider are
// embedded into the library as XPMs so disabling it reduces the library size
// somewhat but this should only be done if you use your own custom art
// provider returning the icons or never use any icons not provided by the
// native art provider (which might not be implemented at all for some
// platforms) or by the Tango icons provider (if it's not itself disabled
// below).
//
// Default is 1.
//
// Recommended setting: 1 unless you use your own custom art provider.
#define wxUSE_ARTPROVIDER_STD 1
// Use art provider providing Tango icons: this art provider has higher quality
// icons than the default ones using smaller size XPM icons without
// transparency but the embedded PNG icons add to the library size.
//
// Default is 1 under non-GTK ports. Under wxGTK the native art provider using
// the GTK+ stock icons replaces it so it is normally not necessary.
//
// Recommended setting: 1 but can be turned off to reduce the library size.
#define wxUSE_ARTPROVIDER_TANGO 1
// Hotkey support (currently Windows only)
#define wxUSE_HOTKEY 1
// Use wxCaret: a class implementing a "cursor" in a text control (called caret
// under Windows).
//
// Default is 1.
//
// Recommended setting: 1 (can be safely set to 0, not used by the library)
#define wxUSE_CARET 1
// Use wxDisplay class: it allows enumerating all displays on a system and
// their geometries as well as finding the display on which the given point or
// window lies.
//
// Default is 1.
//
// Recommended setting: 1 if you need it, can be safely set to 0 otherwise
#define wxUSE_DISPLAY 1
// Miscellaneous geometry code: needed for Canvas library
#define wxUSE_GEOMETRY 1
// Use wxImageList. This class is needed by wxNotebook, wxTreeCtrl and
// wxListCtrl.
//
// Default is 1.
//
// Recommended setting: 1 (set it to 0 if you don't use any of the controls
// enumerated above, then this class is mostly useless too)
#define wxUSE_IMAGLIST 1
// Use wxInfoBar class.
//
// Default is 1.
//
// Recommended setting: 1 (but can be disabled without problems as nothing
// depends on it)
#define wxUSE_INFOBAR 1
// Use wxMenu, wxMenuBar, wxMenuItem.
//
// Default is 1.
//
// Recommended setting: 1 (can't be disabled under MSW)
#define wxUSE_MENUS 1
// Use wxNotificationMessage.
//
// wxNotificationMessage allows to show non-intrusive messages to the user
// using balloons, banners, popups or whatever is the appropriate method for
// the current platform.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_NOTIFICATION_MESSAGE 1
// wxPreferencesEditor provides a common API for different ways of presenting
// the standard "Preferences" or "Properties" dialog under different platforms
// (e.g. some use modal dialogs, some use modeless ones; some apply the changes
// immediately while others require an explicit "Apply" button).
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it)
#define wxUSE_PREFERENCES_EDITOR 1
// wxFont::AddPrivateFont() allows to use fonts not installed on the system by
// loading them from font files during run-time.
//
// Default is 1 except under Unix where it will be turned off by configure if
// the required libraries are not available or not new enough.
//
// Recommended setting: 1 (but can be safely disabled if you don't use it and
// want to avoid extra dependencies under Linux, for example).
#define wxUSE_PRIVATE_FONTS 1
// wxRichToolTip is a customizable tooltip class which has more functionality
// than the stock (but native, unlike this class) wxToolTip.
//
// Default is 1.
//
// Recommended setting: 1 (but can be safely set to 0 if you don't need it)
#define wxUSE_RICHTOOLTIP 1
// Use wxSashWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SASH 1
// Use wxSplitterWindow class.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_SPLITTER 1
// Use wxToolTip and wxWindow::Set/GetToolTip() methods.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_TOOLTIPS 1
// wxValidator class and related methods
#define wxUSE_VALIDATORS 1
// Use reference counted ID management: this means that wxWidgets will track
// the automatically allocated ids (those used when you use wxID_ANY when
// creating a window, menu or toolbar item &c) instead of just supposing that
// the program never runs out of them. This is mostly useful only under wxMSW
// where the total ids range is limited to SHRT_MIN..SHRT_MAX and where
// long-running programs can run into problems with ids reuse without this. On
// the other platforms, where the ids have the full int range, this shouldn't
// be necessary.
#ifdef __WXMSW__
#define wxUSE_AUTOID_MANAGEMENT 1
#else
#define wxUSE_AUTOID_MANAGEMENT 0
#endif
// ----------------------------------------------------------------------------
// common dialogs
// ----------------------------------------------------------------------------
// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
// file selector, printer dialog). Switching this off also switches off the
// printing architecture and interactive wxPrinterDC.
//
// Default is 1
//
// Recommended setting: 1 (unless it really doesn't work)
#define wxUSE_COMMON_DIALOGS 1
// wxBusyInfo displays window with message when app is busy. Works in same way
// as wxBusyCursor
#define wxUSE_BUSYINFO 1
// Use single/multiple choice dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_CHOICEDLG 1
// Use colour picker dialog
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_COLOURDLG 1
// wxDirDlg class for getting a directory name from user
#define wxUSE_DIRDLG 1
// TODO: setting to choose the generic or native one
// Use file open/save dialogs.
//
// Default is 1
//
// Recommended setting: 1 (used in many places in the library itself)
#define wxUSE_FILEDLG 1
// Use find/replace dialogs.
//
// Default is 1
//
// Recommended setting: 1 (but may be safely set to 0)
#define wxUSE_FINDREPLDLG 1
// Use font picker dialog
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_FONTDLG 1
// Use wxMessageDialog and wxMessageBox.
//
// Default is 1
//
// Recommended setting: 1 (used in the library itself)
#define wxUSE_MSGDLG 1
// progress dialog class for lengthy operations
#define wxUSE_PROGRESSDLG 1
// Set to 0 to disable the use of the native progress dialog (currently only
// available under MSW and suffering from some bugs there, hence this option).
#define wxUSE_NATIVE_PROGRESSDLG 1
// support for startup tips (wxShowTip &c)
#define wxUSE_STARTUP_TIPS 1
// text entry dialog and wxGetTextFromUser function
#define wxUSE_TEXTDLG 1
// number entry dialog
#define wxUSE_NUMBERDLG 1
// splash screen class
#define wxUSE_SPLASH 1
// wizards
#define wxUSE_WIZARDDLG 1
// Compile in wxAboutBox() function showing the standard "About" dialog.
//
// Default is 1
//
// Recommended setting: 1 but can be set to 0 to save some space if you don't
// use this function
#define wxUSE_ABOUTDLG 1
// wxFileHistory class
//
// Default is 1
//
// Recommended setting: 1
#define wxUSE_FILE_HISTORY 1
// ----------------------------------------------------------------------------
// Metafiles support
// ----------------------------------------------------------------------------
// Windows supports the graphics format known as metafile which, though not
// portable, is widely used under Windows and so is supported by wxWidgets
// (under Windows only, of course). Both the so-called "Window MetaFiles" or
// WMFs, and "Enhanced MetaFiles" or EMFs are supported in wxWin and, by
// default, EMFs will be used. This may be changed by setting
// wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting wxUSE_ENH_METAFILE to 0.
// You may also set wxUSE_METAFILE to 0 to not compile in any metafile
// related classes at all.
//
// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
//
// Recommended setting: default or 0 for everything for portable programs.
#define wxUSE_METAFILE 1
#define wxUSE_ENH_METAFILE 1
#define wxUSE_WIN_METAFILES_ALWAYS 0
// ----------------------------------------------------------------------------
// Big GUI components
// ----------------------------------------------------------------------------
// Set to 0 to disable MDI support.
//
// Requires wxUSE_NOTEBOOK under platforms other than MSW.
//
// Default is 1.
//
// Recommended setting: 1, can be safely set to 0.
#define wxUSE_MDI 1
// Set to 0 to disable document/view architecture
#define wxUSE_DOC_VIEW_ARCHITECTURE 1
// Set to 0 to disable MDI document/view architecture
//
// Requires wxUSE_MDI && wxUSE_DOC_VIEW_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 1
// Set to 0 to disable print/preview architecture code
#define wxUSE_PRINTING_ARCHITECTURE 1
// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
// much more.
//
// Default is 1.
//
// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
// smaller library.
#define wxUSE_HTML 1
// Setting wxUSE_GLCANVAS to 1 enables OpenGL support. You need to have OpenGL
// headers and libraries to be able to compile the library with wxUSE_GLCANVAS
// set to 1 and, under Windows, also to add opengl32.lib and glu32.lib to the
// list of libraries used to link your application (although this is done
// implicitly for Microsoft Visual C++ users).
//
// Default is 1.
//
// Recommended setting: 1 if you intend to use OpenGL, can be safely set to 0
// otherwise.
#define wxUSE_GLCANVAS 1
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 if you want compile a
// smaller library.
#define wxUSE_RICHTEXT 1
// ----------------------------------------------------------------------------
// Data transfer
// ----------------------------------------------------------------------------
// Use wxClipboard class for clipboard copy/paste.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_CLIPBOARD 1
// Use wxDataObject and related classes. Needed for clipboard and OLE drag and
// drop
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DATAOBJ 1
// Use wxDropTarget and wxDropSource classes for drag and drop (this is
// different from "built in" drag and drop in wxTreeCtrl which is always
// available). Requires wxUSE_DATAOBJ.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_DRAG_AND_DROP 1
// Use wxAccessible for enhanced and customisable accessibility.
// Depends on wxUSE_OLE on MSW.
//
// Default is 1 on MSW, 0 elsewhere.
//
// Recommended setting (at present): 1 (MSW-only)
#ifdef __WXMSW__
#define wxUSE_ACCESSIBILITY 1
#else
#define wxUSE_ACCESSIBILITY 0
#endif
// ----------------------------------------------------------------------------
// miscellaneous settings
// ----------------------------------------------------------------------------
// wxSingleInstanceChecker class allows to verify at startup if another program
// instance is running.
//
// Default is 1
//
// Recommended setting: 1 (the class is tiny, disabling it won't save much
// space)
#define wxUSE_SNGLINST_CHECKER 1
#define wxUSE_DRAGIMAGE 1
#define wxUSE_IPC 1
// 0 for no interprocess comms
#define wxUSE_HELP 1
// 0 for no help facility
// Should we use MS HTML help for wxHelpController? If disabled, neither
// wxCHMHelpController nor wxBestHelpController are available.
//
// Default is 1 under MSW, 0 is always used for the other platforms.
//
// Recommended setting: 1, only set to 0 if you have trouble compiling
// wxCHMHelpController (could be a problem with really ancient compilers)
#define wxUSE_MS_HTML_HELP 1
// Use wxHTML-based help controller?
#define wxUSE_WXHTML_HELP 1
#define wxUSE_CONSTRAINTS 1
// 0 for no window layout constraint system
#define wxUSE_SPLINES 1
// 0 for no splines
#define wxUSE_MOUSEWHEEL 1
// Include mouse wheel support
// Compile wxUIActionSimulator class?
#define wxUSE_UIACTIONSIMULATOR 1
// ----------------------------------------------------------------------------
// wxDC classes for various output formats
// ----------------------------------------------------------------------------
// Set to 1 for PostScript device context.
#define wxUSE_POSTSCRIPT 0
// Set to 1 to use font metric files in GetTextExtent
#define wxUSE_AFM_FOR_POSTSCRIPT 1
// Set to 1 to compile in support for wxSVGFileDC, a wxDC subclass which allows
// to create files in SVG (Scalable Vector Graphics) format.
#define wxUSE_SVG 1
// Should wxDC provide SetTransformMatrix() and related methods?
//
// Default is 1 but can be set to 0 if this functionality is not used. Notice
// that currently wxMSW, wxGTK3 support this for wxDC and all platforms support
// this for wxGCDC so setting this to 0 doesn't change much if neither of these
// is used (although it will still save a few bytes probably).
//
// Recommended setting: 1.
#define wxUSE_DC_TRANSFORM_MATRIX 1
// ----------------------------------------------------------------------------
// image format support
// ----------------------------------------------------------------------------
// wxImage supports many different image formats which can be configured at
// compile-time. BMP is always supported, others are optional and can be safely
// disabled if you don't plan to use images in such format sometimes saving
// substantial amount of code in the final library.
//
// Some formats require an extra library which is included in wxWin sources
// which is mentioned if it is the case.
// Set to 1 for wxImage support (recommended).
#define wxUSE_IMAGE 1
// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
#define wxUSE_LIBPNG 1
// Set to 1 for JPEG format support (requires libjpeg)
#define wxUSE_LIBJPEG 1
// Set to 1 for TIFF format support (requires libtiff)
#define wxUSE_LIBTIFF 1
// Set to 1 for TGA format support (loading only)
#define wxUSE_TGA 1
// Set to 1 for GIF format support
#define wxUSE_GIF 1
// Set to 1 for PNM format support
#define wxUSE_PNM 1
// Set to 1 for PCX format support
#define wxUSE_PCX 1
// Set to 1 for IFF format support (Amiga format)
#define wxUSE_IFF 0
// Set to 1 for XPM format support
#define wxUSE_XPM 1
// Set to 1 for MS Icons and Cursors format support
#define wxUSE_ICO_CUR 1
// Set to 1 to compile in wxPalette class
#define wxUSE_PALETTE 1
// ----------------------------------------------------------------------------
// wxUniversal-only options
// ----------------------------------------------------------------------------
// Set to 1 to enable compilation of all themes, this is the default
#define wxUSE_ALL_THEMES 1
// Set to 1 to enable the compilation of individual theme if wxUSE_ALL_THEMES
// is unset, if it is set these options are not used; notice that metal theme
// uses Win32 one
#define wxUSE_THEME_GTK 0
#define wxUSE_THEME_METAL 0
#define wxUSE_THEME_MONO 0
#define wxUSE_THEME_WIN32 0
/* --- end common options --- */
/* --- start MSW options --- */
// ----------------------------------------------------------------------------
// Graphics backends choices for Windows
// ----------------------------------------------------------------------------
// The options here are only taken into account if wxUSE_GRAPHICS_CONTEXT is 1.
// Enable support for GDI+-based implementation of wxGraphicsContext.
//
// Default is 1.
//
// Recommended setting: 1 if you need to support XP, as Direct2D is not
// available there.
#define wxUSE_GRAPHICS_GDIPLUS wxUSE_GRAPHICS_CONTEXT
// Enable support for Direct2D-based implementation of wxGraphicsContext.
//
// Default is 1 for compilers which support it, i.e. VC10+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1 for faster and better quality graphics under Windows
// 7 and later systems (if wxUSE_GRAPHICS_GDIPLUS is also enabled, earlier
// systems will fall back on using GDI+).
#if defined(_MSC_VER) && _MSC_VER >= 1600
#define wxUSE_GRAPHICS_DIRECT2D wxUSE_GRAPHICS_CONTEXT
#else
#define wxUSE_GRAPHICS_DIRECT2D 0
#endif
// ----------------------------------------------------------------------------
// Windows-only settings
// ----------------------------------------------------------------------------
// Set this to 1 for generic OLE support: this is required for drag-and-drop,
// clipboard, OLE Automation. Only set it to 0 if your compiler is very old and
// can't compile/doesn't have the OLE headers.
//
// Default is 1.
//
// Recommended setting: 1
#define wxUSE_OLE 1
// Set this to 1 to enable wxAutomationObject class.
//
// Default is 1.
//
// Recommended setting: 1 if you need to control other applications via OLE
// Automation, can be safely set to 0 otherwise
#define wxUSE_OLE_AUTOMATION 1
// Set this to 1 to enable wxActiveXContainer class allowing to embed OLE
// controls in wx.
//
// Default is 1.
//
// Recommended setting: 1, required by wxMediaCtrl
#define wxUSE_ACTIVEX 1
// Enable WinRT support
//
// Default is 1 for compilers which support it, i.e. VS2012+ currently. If you
// use an earlier MSVC version or another compiler and installed the necessary
// SDK components manually, you need to change this setting.
//
// Recommended setting: 1
#if defined(_MSC_VER) && _MSC_VER >= 1700 && !defined(_USING_V110_SDK71_)
#define wxUSE_WINRT 1
#else
#define wxUSE_WINRT 0
#endif
// wxDC caching implementation
#define wxUSE_DC_CACHEING 1
// Set this to 1 to enable wxDIB class used internally for manipulating
// wxBitmap data.
//
// Default is 1, set it to 0 only if you don't use wxImage neither
//
// Recommended setting: 1 (without it conversion to/from wxImage won't work)
#define wxUSE_WXDIB 1
// Set to 0 to disable PostScript print/preview architecture code under Windows
// (just use Windows printing).
#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
// Set this to 1 to compile in wxRegKey class.
//
// Default is 1
//
// Recommended setting: 1, this is used internally by wx in a few places
#define wxUSE_REGKEY 1
// Set this to 1 to use RICHEDIT controls for wxTextCtrl with style wxTE_RICH
// which allows to put more than ~32Kb of text in it even under Win9x (NT
// doesn't have such limitation).
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1, only set it to 0 if your compiler doesn't have
// or can't compile <richedit.h>
#define wxUSE_RICHEDIT 1
// Set this to 1 to use extra features of richedit v2 and later controls
//
// Default is 1 for compilers which support it
//
// Recommended setting: 1
#define wxUSE_RICHEDIT2 1
// Set this to 1 to enable support for the owner-drawn menu and listboxes. This
// is required by wxUSE_CHECKLISTBOX.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a small library size reduction
#define wxUSE_OWNER_DRAWN 1
// Set this to 1 to enable MSW-specific wxTaskBarIcon::ShowBalloon() method. It
// is required by native wxNotificationMessage implementation.
//
// Default is 1 but disabled in wx/msw/chkconf.h if SDK is too old to contain
// the necessary declarations.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARICON_BALLOONS 1
// Set this to 1 to enable following functionality added in Windows 7: thumbnail
// representations, thumbnail toolbars, notification and status overlays,
// progress indicators and jump lists.
//
// Default is 1.
//
// Recommended setting: 1, set to 0 for a tiny library size reduction
#define wxUSE_TASKBARBUTTON 1
// Set to 1 to compile MS Windows XP theme engine support
#define wxUSE_UXTHEME 1
// Set to 1 to use InkEdit control (Tablet PC), if available
#define wxUSE_INKEDIT 0
// Set to 1 to enable .INI files based wxConfig implementation (wxIniConfig)
//
// Default is 0.
//
// Recommended setting: 0, nobody uses .INI files any more
#define wxUSE_INICONF 0
// ----------------------------------------------------------------------------
// Generic versions of native controls
// ----------------------------------------------------------------------------
// Set this to 1 to be able to use wxDatePickerCtrlGeneric in addition to the
// native wxDatePickerCtrl
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_DATEPICKCTRL_GENERIC 0
// Set this to 1 to be able to use wxTimePickerCtrlGeneric in addition to the
// native wxTimePickerCtrl for the platforms that have the latter (MSW).
//
// Default is 0.
//
// Recommended setting: 0, this is mainly used for testing
#define wxUSE_TIMEPICKCTRL_GENERIC 0
// ----------------------------------------------------------------------------
// Crash debugging helpers
// ----------------------------------------------------------------------------
// Set this to 1 to use dbghelp.dll for providing stack traces in crash
// reports.
//
// Default is 1 if the compiler supports it, 0 for old MinGW.
//
// Recommended setting: 1, there is not much gain in disabling this
#if defined(__VISUALC__) || defined(__MINGW64_TOOLCHAIN__)
#define wxUSE_DBGHELP 1
#else
#define wxUSE_DBGHELP 0
#endif
// Set this to 1 to be able to use wxCrashReport::Generate() to create mini
// dumps of your program when it crashes (or at any other moment)
//
// Default is 1 if supported by the compiler (VC++ and recent BC++ only).
//
// Recommended setting: 1, set to 0 if your programs never crash
#define wxUSE_CRASHREPORT 1
/* --- end MSW options --- */
#endif // _WX_SETUP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/datetimectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/datetimectrl.h
// Purpose: wxDateTimePickerCtrl for Windows.
// Author: Vadim Zeitlin
// Created: 2011-09-22 (extracted from wx/msw/datectrl.h).
// Copyright: (c) 2005-2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DATETIMECTRL_H_
#define _WX_MSW_DATETIMECTRL_H_
#include "wx/intl.h"
// Forward declare a struct from Platform SDK.
struct tagNMDATETIMECHANGE;
// ----------------------------------------------------------------------------
// wxDateTimePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDateTimePickerCtrl : public wxDateTimePickerCtrlBase
{
public:
// set/get the date
virtual void SetValue(const wxDateTime& dt) wxOVERRIDE;
virtual wxDateTime GetValue() const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// Helper for the derived classes Create(): creates a native control with
// the specified attributes.
bool MSWCreateDateTimePicker(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name);
// Notice that the methods below must be overridden in all native MSW
// classes inheriting from this one but they can't be pure virtual because
// the generic implementations, not needing nor able to implement them, is
// also derived from this class currently. The real problem is, of course,
// this wrong class structure because the generic classes also inherit the
// wrong implementations of Set/GetValue() and DoGetBestSize() but as they
// override these methods anyhow, it does work -- but is definitely ugly
// and need to be changed (but how?) in the future.
#if wxUSE_INTL
// Override to return the date/time format used by this control.
virtual wxLocaleInfo MSWGetFormat() const /* = 0 */
{
wxFAIL_MSG( "Unreachable" );
return wxLOCALE_TIME_FMT;
}
#endif // wxUSE_INTL
// Override to indicate whether we can have no date at all.
virtual bool MSWAllowsNone() const /* = 0 */
{
wxFAIL_MSG( "Unreachable" );
return false;
}
// Override to update m_date and send the event when the control contents
// changes, return true if the event was handled.
virtual bool MSWOnDateTimeChange(const tagNMDATETIMECHANGE& dtch) /* = 0 */
{
wxUnusedVar(dtch);
wxFAIL_MSG( "Unreachable" );
return false;
}
// the date currently shown by the control, may be invalid
wxDateTime m_date;
};
#endif // _WX_MSW_DATETIMECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/wrapshl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapshl.h
// Purpose: wrapper class for stuff from shell32.dll
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-10-19
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WRAPSHL_H_
#define _WX_MSW_WRAPSHL_H_
#include "wx/msw/wrapwin.h"
#ifdef __VISUALC__
// Disable a warning that we can do nothing about: we get it for
// shlobj.h at least from 7.1a Windows kit when using VC14.
#pragma warning(push)
// 'typedef ': ignored on left of '' when no variable is declared
#pragma warning(disable:4091)
#endif
#include <shlobj.h>
#ifdef __VISUALC__
#pragma warning(pop)
#endif
#include "wx/msw/winundef.h"
#include "wx/log.h"
// ----------------------------------------------------------------------------
// wxItemIdList implements RAII on top of ITEMIDLIST
// ----------------------------------------------------------------------------
class wxItemIdList
{
public:
// ctor takes ownership of the item and will free it
wxItemIdList(LPITEMIDLIST pidl)
{
m_pidl = pidl;
}
static void Free(LPITEMIDLIST pidl)
{
if ( pidl )
{
LPMALLOC pMalloc;
SHGetMalloc(&pMalloc);
if ( pMalloc )
{
pMalloc->Free(pidl);
pMalloc->Release();
}
else
{
wxLogLastError(wxT("SHGetMalloc"));
}
}
}
~wxItemIdList()
{
Free(m_pidl);
}
// implicit conversion to LPITEMIDLIST
operator LPITEMIDLIST() const { return m_pidl; }
// get the corresponding path, returns empty string on error
wxString GetPath() const
{
wxString path;
if ( !SHGetPathFromIDList(m_pidl, wxStringBuffer(path, MAX_PATH)) )
{
wxLogLastError(wxT("SHGetPathFromIDList"));
}
return path;
}
private:
LPITEMIDLIST m_pidl;
wxDECLARE_NO_COPY_CLASS(wxItemIdList);
};
// enable autocompleting filenames in the text control with given HWND
//
// this only works on systems with shlwapi.dll 5.0 or later
//
// implemented in src/msw/utilsgui.cpp
extern bool wxEnableFileNameAutoComplete(HWND hwnd);
#endif // _WX_MSW_WRAPSHL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/listctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/listctrl.h
// Purpose: wxListCtrl class
// Author: Julian Smart
// Modified by: Agron Selimaj
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTCTRL_H_
#define _WX_LISTCTRL_H_
#include "wx/textctrl.h"
#include "wx/dynarray.h"
#include "wx/vector.h"
class wxMSWListItemData;
class wxMSWListHeaderCustomDraw;
// define this symbol to indicate the availability of SetColumnsOrder() and
// related functions
#define wxHAS_LISTCTRL_COLUMN_ORDER
/*
The wxListCtrl can show lists of items in four different modes:
wxLC_LIST: multicolumn list view, with optional small icons (icons could be
optional for some platforms). Columns are computed automatically,
i.e. you don't set columns as in wxLC_REPORT. In other words,
the list wraps, unlike a wxListBox.
wxLC_REPORT: single or multicolumn report view (with optional header)
wxLC_ICON: large icon view, with optional labels
wxLC_SMALL_ICON: small icon view, with optional labels
You can change the style dynamically, either with SetSingleStyle or
SetWindowStyleFlag.
Further window styles:
wxLC_ALIGN_TOP icons align to the top (default)
wxLC_ALIGN_LEFT icons align to the left
wxLC_AUTOARRANGE icons arrange themselves
wxLC_USER_TEXT the app provides label text on demand, except for column headers
wxLC_EDIT_LABELS labels are editable: app will be notified.
wxLC_NO_HEADER no header in report mode
wxLC_NO_SORT_HEADER can't click on header
wxLC_SINGLE_SEL single selection
wxLC_SORT_ASCENDING sort ascending (must still supply a comparison callback in SortItems)
wxLC_SORT_DESCENDING sort descending (ditto)
Items are referred to by their index (position in the list starting from zero).
Label text is supplied via insertion/setting functions and is stored by the
control, unless the wxLC_USER_TEXT style has been specified, in which case
the app will be notified when text is required (see sample).
Images are dealt with by (optionally) associating 3 image lists with the control.
Zero-based indexes into these image lists indicate which image is to be used for
which item. Each image in an image list can contain a mask, and can be made out
of either a bitmap, two bitmaps or an icon. See ImagList.h for more details.
Notifications are passed via the event system.
See the sample wxListCtrl app for API usage.
TODO:
- addition of further convenience functions
to avoid use of wxListItem in some functions
- state/overlay images: probably not needed.
- testing of whole API, extending current sample.
*/
class WXDLLIMPEXP_CORE wxListCtrl: public wxListCtrlBase
{
public:
/*
* Public interface
*/
wxListCtrl() { Init(); }
wxListCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListCtrlNameStr)
{
Init();
Create(parent, id, pos, size, style, validator, name);
}
virtual ~wxListCtrl();
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxLC_ICON,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListCtrlNameStr);
// Attributes
////////////////////////////////////////////////////////////////////////////
// Set the control colours
bool SetForegroundColour(const wxColour& col) wxOVERRIDE;
bool SetBackgroundColour(const wxColour& col) wxOVERRIDE;
// Header attributes
virtual bool SetHeaderAttr(const wxItemAttr& attr) wxOVERRIDE;
// Gets information about this column
bool GetColumn(int col, wxListItem& item) const wxOVERRIDE;
// Sets information about this column
bool SetColumn(int col, const wxListItem& item) wxOVERRIDE;
// Gets the column width
int GetColumnWidth(int col) const wxOVERRIDE;
// Sets the column width
bool SetColumnWidth(int col, int width) wxOVERRIDE;
// Gets the column order from its index or index from its order
int GetColumnOrder(int col) const;
int GetColumnIndexFromOrder(int order) const;
// Gets the column order for all columns
wxArrayInt GetColumnsOrder() const;
// Sets the column order for all columns
bool SetColumnsOrder(const wxArrayInt& orders);
// Gets the number of items that can fit vertically in the
// visible area of the list control (list or report view)
// or the total number of items in the list control (icon
// or small icon view)
int GetCountPerPage() const;
// return the total area occupied by all the items (icon/small icon only)
wxRect GetViewRect() const;
// Gets the edit control for editing labels.
wxTextCtrl* GetEditControl() const;
// Gets information about the item
bool GetItem(wxListItem& info) const;
// Sets information about the item
bool SetItem(wxListItem& info);
// Sets a string field at a particular column
bool SetItem(long index, int col, const wxString& label, int imageId = -1);
// Gets the item state
int GetItemState(long item, long stateMask) const;
// Sets the item state
bool SetItemState(long item, long state, long stateMask);
// Sets the item image
bool SetItemImage(long item, int image, int selImage = -1);
bool SetItemColumnImage(long item, long column, int image);
// Gets the item text
wxString GetItemText(long item, int col = 0) const;
// Sets the item text
void SetItemText(long item, const wxString& str);
// Gets the item data
wxUIntPtr GetItemData(long item) const;
// Sets the item data
bool SetItemPtrData(long item, wxUIntPtr data);
bool SetItemData(long item, long data) { return SetItemPtrData(item, data); }
// Gets the item rectangle
bool GetItemRect(long item, wxRect& rect, int code = wxLIST_RECT_BOUNDS) const;
// Gets the subitem rectangle in report mode
bool GetSubItemRect(long item, long subItem, wxRect& rect, int code = wxLIST_RECT_BOUNDS) const;
// Gets the item position
bool GetItemPosition(long item, wxPoint& pos) const;
// Sets the item position
bool SetItemPosition(long item, const wxPoint& pos);
// Gets the number of items in the list control
int GetItemCount() const;
// Gets the number of columns in the list control
int GetColumnCount() const wxOVERRIDE { return m_colCount; }
// get the horizontal and vertical components of the item spacing
wxSize GetItemSpacing() const;
// Foreground colour of an item.
void SetItemTextColour( long item, const wxColour& col);
wxColour GetItemTextColour( long item ) const;
// Background colour of an item.
void SetItemBackgroundColour( long item, const wxColour &col);
wxColour GetItemBackgroundColour( long item ) const;
// Font of an item.
void SetItemFont( long item, const wxFont &f);
wxFont GetItemFont( long item ) const;
// Checkbox state of an item
virtual bool HasCheckBoxes() const wxOVERRIDE;
virtual bool EnableCheckBoxes(bool enable = true) wxOVERRIDE;
virtual bool IsItemChecked(long item) const wxOVERRIDE;
virtual void CheckItem(long item, bool check) wxOVERRIDE;
// Gets the number of selected items in the list control
int GetSelectedItemCount() const;
// Gets the text colour of the listview
wxColour GetTextColour() const;
// Sets the text colour of the listview
void SetTextColour(const wxColour& col);
// Gets the index of the topmost visible item when in
// list or report view
long GetTopItem() const;
// Add or remove a single window style
void SetSingleStyle(long style, bool add = true);
// Set the whole window style
void SetWindowStyleFlag(long style) wxOVERRIDE;
// Searches for an item, starting from 'item'.
// item can be -1 to find the first item that matches the
// specified flags.
// Returns the item or -1 if unsuccessful.
long GetNextItem(long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE) const;
// Gets one of the three image lists
wxImageList *GetImageList(int which) const wxOVERRIDE;
// Sets the image list
void SetImageList(wxImageList *imageList, int which) wxOVERRIDE;
void AssignImageList(wxImageList *imageList, int which) wxOVERRIDE;
// refresh items selectively (only useful for virtual list controls)
void RefreshItem(long item);
void RefreshItems(long itemFrom, long itemTo);
// Operations
////////////////////////////////////////////////////////////////////////////
// Arranges the items
bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
// Deletes an item
bool DeleteItem(long item);
// Deletes all items
bool DeleteAllItems();
// Deletes a column
bool DeleteColumn(int col) wxOVERRIDE;
// Deletes all columns
bool DeleteAllColumns() wxOVERRIDE;
// Clears items, and columns if there are any.
void ClearAll();
// Edit the label
wxTextCtrl* EditLabel(long item, wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
// End label editing, optionally cancelling the edit
bool EndEditLabel(bool cancel);
// Ensures this item is visible
bool EnsureVisible(long item);
// Find an item whose label matches this string, starting from the item after 'start'
// or the beginning if 'start' is -1.
long FindItem(long start, const wxString& str, bool partial = false);
// Find an item whose data matches this data, starting from the item after 'start'
// or the beginning if 'start' is -1.
long FindItem(long start, wxUIntPtr data);
// Find an item nearest this position in the specified direction, starting from
// the item after 'start' or the beginning if 'start' is -1.
long FindItem(long start, const wxPoint& pt, int direction);
// Determines which item (if any) is at the specified point,
// giving details in 'flags' (see wxLIST_HITTEST_... flags above)
// Request the subitem number as well at the given coordinate.
long HitTest(const wxPoint& point, int& flags, long* ptrSubItem = NULL) const;
// Inserts an item, returning the index of the new item if successful,
// -1 otherwise.
long InsertItem(const wxListItem& info);
// Insert a string item
long InsertItem(long index, const wxString& label);
// Insert an image item
long InsertItem(long index, int imageIndex);
// Insert an image/string item
long InsertItem(long index, const wxString& label, int imageIndex);
// set the number of items in a virtual list control
void SetItemCount(long count);
// Scrolls the list control. If in icon, small icon or report view mode,
// x specifies the number of pixels to scroll. If in list view mode, x
// specifies the number of columns to scroll.
// If in icon, small icon or list view mode, y specifies the number of pixels
// to scroll. If in report view mode, y specifies the number of lines to scroll.
bool ScrollList(int dx, int dy);
// Sort items.
// fn is a function which takes 3 long arguments: item1, item2, data.
// item1 is the long data associated with a first item (NOT the index).
// item2 is the long data associated with a second item (NOT the index).
// data is the same value as passed to SortItems.
// The return value is a negative number if the first item should precede the second
// item, a positive number of the second item should precede the first,
// or zero if the two items are equivalent.
// data is arbitrary data to be passed to the sort function.
bool SortItems(wxListCtrlCompare fn, wxIntPtr data);
// IMPLEMENTATION
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWShouldPreProcessMessage(WXMSG* msg) wxOVERRIDE;
#if WXWIN_COMPATIBILITY_3_0
// bring the control in sync with current m_windowStyle value
wxDEPRECATED_MSG("useless and will be removed in the future, use SetWindowStyleFlag() instead")
void UpdateStyle();
#endif // WXWIN_COMPATIBILITY_3_0
// Event handlers
////////////////////////////////////////////////////////////////////////////
// Necessary for drawing hrules and vrules, if specified
void OnPaint(wxPaintEvent& event);
virtual bool ShouldInheritColours() const wxOVERRIDE { return false; }
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// convert our styles to Windows
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// special Windows message handling
virtual WXLRESULT MSWWindowProc(WXUINT nMsg,
WXWPARAM wParam,
WXLPARAM lParam) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
virtual bool MSWShouldSetDefaultFont() const wxOVERRIDE { return false; }
// Implement constrained best size calculation.
virtual int DoGetBestClientHeight(int width) const wxOVERRIDE
{ return MSWGetBestViewRect(width, -1).y; }
virtual int DoGetBestClientWidth(int height) const wxOVERRIDE
{ return MSWGetBestViewRect(-1, height).x; }
wxSize MSWGetBestViewRect(int x, int y) const;
// Implement base class pure virtual methods.
long DoInsertColumn(long col, const wxListItem& info) wxOVERRIDE;
// free memory taken by all internal data
void FreeAllInternalData();
// get the internal data object for this item (may return NULL)
wxMSWListItemData *MSWGetItemData(long item) const;
// get the item attribute, either by quering it for virtual control, or by
// returning the one previously set using setter methods for a normal one
wxItemAttr *DoGetItemColumnAttr(long item, long column) const;
wxTextCtrl* m_textCtrl; // The control used for editing a label
wxImageList * m_imageListNormal; // The image list for normal icons
wxImageList * m_imageListSmall; // The image list for small icons
wxImageList * m_imageListState; // The image list state icons (not implemented yet)
bool m_ownsImageListNormal,
m_ownsImageListSmall,
m_ownsImageListState;
int m_colCount; // Windows doesn't have GetColumnCount so must
// keep track of inserted/deleted columns
// all wxMSWListItemData objects we use
wxVector<wxMSWListItemData *> m_internalData;
// true if we have any items with custom attributes
bool m_hasAnyAttr;
// these functions are only used for virtual list view controls, i.e. the
// ones with wxLC_VIRTUAL style
// return the text for the given column of the given item
virtual wxString OnGetItemText(long item, long column) const;
// return the icon for the given item. In report view, OnGetItemImage will
// only be called for the first column. See OnGetItemColumnImage for
// details.
virtual int OnGetItemImage(long item) const;
// return the icon for the given item and column.
virtual int OnGetItemColumnImage(long item, long column) const;
// return the attribute for the given item and column (may return NULL if none)
virtual wxItemAttr *OnGetItemColumnAttr(long item, long WXUNUSED(column)) const
{
return OnGetItemAttr(item);
}
private:
// process NM_CUSTOMDRAW notification message
WXLPARAM OnCustomDraw(WXLPARAM lParam);
// set the extended styles for the control (used by Create() and
// UpdateStyle()), only should be called if InReportView()
void MSWSetExListStyles();
// initialize the (already created) m_textCtrl with the associated HWND
void InitEditControl(WXHWND hWnd);
// destroy m_textCtrl if it's currently valid and reset it to NULL
void DeleteEditControl();
// Intercept Escape and Enter keys to avoid them being stolen from our
// in-place editor control.
void OnCharHook(wxKeyEvent& event);
// Object using for header custom drawing if necessary, may be NULL.
wxMSWListHeaderCustomDraw* m_headerCustomDraw;
wxDECLARE_DYNAMIC_CLASS(wxListCtrl);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxListCtrl);
};
#endif // _WX_LISTCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/progdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/progdlg.h
// Purpose: wxProgressDialog
// Author: Rickard Westerlund
// Created: 2010-07-22
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PROGDLG_H_
#define _WX_PROGDLG_H_
class wxProgressDialogTaskRunner;
class wxProgressDialogSharedData;
class WXDLLIMPEXP_CORE wxProgressDialog : public wxGenericProgressDialog
{
public:
wxProgressDialog(const wxString& title, const wxString& message,
int maximum = 100,
wxWindow *parent = NULL,
int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE);
virtual ~wxProgressDialog();
virtual bool Update(int value, const wxString& newmsg = wxEmptyString, bool *skip = NULL) wxOVERRIDE;
virtual bool Pulse(const wxString& newmsg = wxEmptyString, bool *skip = NULL) wxOVERRIDE;
virtual void Resume() wxOVERRIDE;
virtual int GetValue() const wxOVERRIDE;
virtual wxString GetMessage() const wxOVERRIDE;
virtual void SetRange(int maximum) wxOVERRIDE;
// Return whether "Cancel" or "Skip" button was pressed, always return
// false if the corresponding button is not shown.
virtual bool WasSkipped() const wxOVERRIDE;
virtual bool WasCancelled() const wxOVERRIDE;
virtual void SetTitle(const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
virtual void SetIcons(const wxIconBundle& icons) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void Fit() wxOVERRIDE;
virtual bool Show( bool show = true ) wxOVERRIDE;
// Must provide overload to avoid hiding it (and warnings about it)
virtual void Update() wxOVERRIDE { wxGenericProgressDialog::Update(); }
virtual WXWidget GetHandle() const wxOVERRIDE;
private:
// Common part of Update() and Pulse().
//
// Returns false if the user requested cancelling the dialog.
bool DoNativeBeforeUpdate(bool *skip);
// Dispatch the pending events to let the windows to update, just as the
// generic version does. This is done as part of DoNativeBeforeUpdate().
void DispatchEvents();
// Updates the various timing informations for both determinate
// and indeterminate modes. Requires the shared object to have
// been entered.
void UpdateExpandedInformation(int value);
// Get the task dialog geometry when using the native dialog.
wxRect GetTaskDialogRect() const;
wxProgressDialogTaskRunner *m_taskDialogRunner;
wxProgressDialogSharedData *m_sharedData;
// Store the message and title we currently use to be able to return it
// from Get{Message,Title}()
wxString m_message,
m_title;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxProgressDialog);
};
#endif // _WX_PROGDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/font.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/font.h
// Purpose: wxFont class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FONT_H_
#define _WX_FONT_H_
#include "wx/gdicmn.h"
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFont : public wxFontBase
{
public:
// ctors and such
wxFont() { }
wxFont(const wxFontInfo& info);
wxFont(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Create(size, family, style, weight, underlined, face, encoding);
}
bool Create(int size,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
return DoCreate(InfoFromLegacyParams(size,
family,
style,
weight,
underlined,
face,
encoding));
}
wxFont(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(pixelSize, family, style, weight,
underlined, face, encoding);
}
wxFont(const wxNativeFontInfo& info, WXHFONT hFont = 0)
{
Create(info, hFont);
}
wxFont(const wxString& fontDesc);
bool Create(const wxSize& pixelSize,
wxFontFamily family,
wxFontStyle style,
wxFontWeight weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
return DoCreate(InfoFromLegacyParams(pixelSize,
family,
style,
weight,
underlined,
face,
encoding));
}
bool Create(const wxNativeFontInfo& info, WXHFONT hFont = 0);
virtual ~wxFont();
// implement base class pure virtuals
virtual float GetFractionalPointSize() const wxOVERRIDE;
virtual wxSize GetPixelSize() const wxOVERRIDE;
virtual bool IsUsingSizeInPixels() const wxOVERRIDE;
virtual wxFontStyle GetStyle() const wxOVERRIDE;
virtual int GetNumericWeight() const wxOVERRIDE;
virtual bool GetUnderlined() const wxOVERRIDE;
virtual bool GetStrikethrough() const wxOVERRIDE;
virtual wxString GetFaceName() const wxOVERRIDE;
virtual wxFontEncoding GetEncoding() const wxOVERRIDE;
virtual const wxNativeFontInfo *GetNativeFontInfo() const wxOVERRIDE;
virtual void SetFractionalPointSize(float pointSize) wxOVERRIDE;
virtual void SetPixelSize(const wxSize& pixelSize) wxOVERRIDE;
virtual void SetFamily(wxFontFamily family) wxOVERRIDE;
virtual void SetStyle(wxFontStyle style) wxOVERRIDE;
virtual void SetNumericWeight(int weight) wxOVERRIDE;
virtual bool SetFaceName(const wxString& faceName) wxOVERRIDE;
virtual void SetUnderlined(bool underlined) wxOVERRIDE;
virtual void SetStrikethrough(bool strikethrough) wxOVERRIDE;
virtual void SetEncoding(wxFontEncoding encoding) wxOVERRIDE;
wxDECLARE_COMMON_FONT_METHODS();
virtual bool IsFixedWidth() const wxOVERRIDE;
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants ie: wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD")
wxFont(int size,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(size, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight, underlined, face, encoding);
}
wxDEPRECATED_MSG("use wxFONT{FAMILY,STYLE,WEIGHT}_XXX constants ie: wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD")
wxFont(const wxSize& pixelSize,
int family,
int style,
int weight,
bool underlined = false,
const wxString& face = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
(void)Create(pixelSize, (wxFontFamily)family, (wxFontStyle)style, (wxFontWeight)weight,
underlined, face, encoding);
}
// implementation only from now on
// -------------------------------
virtual bool IsFree() const wxOVERRIDE;
virtual bool RealizeResource() wxOVERRIDE;
virtual WXHANDLE GetResourceHandle() const wxOVERRIDE;
virtual bool FreeResource(bool force = false) wxOVERRIDE;
// for consistency with other wxMSW classes
WXHFONT GetHFONT() const;
protected:
// Common helper of overloaded Create() methods.
bool DoCreate(const wxFontInfo& info);
virtual void DoSetNativeFontInfo(const wxNativeFontInfo& info) wxOVERRIDE;
virtual wxFontFamily DoGetFamily() const wxOVERRIDE;
// implement wxObject virtuals which are used by AllocExclusive()
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxFont);
};
#endif // _WX_FONT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/evtloopconsole.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/evtloopconsole.h
// Purpose: wxConsoleEventLoop class for Windows
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-07-31
// Copyright: (c) 2003-2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_EVTLOOPCONSOLE_H_
#define _WX_MSW_EVTLOOPCONSOLE_H_
class WXDLLIMPEXP_BASE wxMSWEventLoopBase : public wxEventLoopManual
{
public:
wxMSWEventLoopBase();
virtual ~wxMSWEventLoopBase();
// implement base class pure virtuals
virtual bool Pending() const wxOVERRIDE;
virtual void WakeUp() wxOVERRIDE;
#if wxUSE_THREADS
// MSW-specific method to wait for the termination of the specified (by its
// native handle) thread or any input message arriving (in GUI case).
//
// Return value is WAIT_OBJECT_0 if the thread terminated, WAIT_OBJECT_0+1
// if a message arrived with anything else indicating an error.
WXDWORD MSWWaitForThread(WXHANDLE hThread);
#endif // wxUSE_THREADS
// Return true if wake up was requested and not handled yet, i.e. if
// m_heventWake is signaled.
bool MSWIsWakeUpRequested();
protected:
// get the next message from queue and return true or return false if we
// got WM_QUIT or an error occurred
bool GetNextMessage(WXMSG *msg);
// same as above but with a timeout and return value can be -1 meaning that
// time out expired in addition to true/false
int GetNextMessageTimeout(WXMSG *msg, unsigned long timeout);
private:
// An auto-reset Win32 event which is signalled when we need to wake up the
// main thread waiting in GetNextMessage[Timeout]().
WXHANDLE m_heventWake;
};
#if wxUSE_CONSOLE_EVENTLOOP
class WXDLLIMPEXP_BASE wxConsoleEventLoop : public wxMSWEventLoopBase
{
public:
wxConsoleEventLoop() { }
// override/implement base class virtuals
virtual bool Dispatch() wxOVERRIDE;
virtual int DispatchTimeout(unsigned long timeout) wxOVERRIDE;
// Windows-specific function to process a single message
virtual void ProcessMessage(WXMSG *msg);
protected:
virtual void DoYieldFor(long eventsToProcess) wxOVERRIDE;
};
#endif // wxUSE_CONSOLE_EVENTLOOP
#endif // _WX_MSW_EVTLOOPCONSOLE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/nonownedwnd.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/nonownedwnd.h
// Purpose: wxNonOwnedWindow declaration for wxMSW.
// Author: Vadim Zeitlin
// Created: 2011-10-09
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_NONOWNEDWND_H_
#define _WX_MSW_NONOWNEDWND_H_
class wxNonOwnedWindowShapeImpl;
// ----------------------------------------------------------------------------
// wxNonOwnedWindow
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxNonOwnedWindow : public wxNonOwnedWindowBase
{
public:
wxNonOwnedWindow();
virtual ~wxNonOwnedWindow();
protected:
virtual bool DoClearShape() wxOVERRIDE;
virtual bool DoSetRegionShape(const wxRegion& region) wxOVERRIDE;
#if wxUSE_GRAPHICS_CONTEXT
virtual bool DoSetPathShape(const wxGraphicsPath& path) wxOVERRIDE;
private:
wxNonOwnedWindowShapeImpl* m_shapeImpl;
#endif // wxUSE_GRAPHICS_CONTEXT
wxDECLARE_NO_COPY_CLASS(wxNonOwnedWindow);
};
#endif // _WX_MSW_NONOWNEDWND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/app.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/app.h
// Purpose: wxApp class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_APP_H_
#define _WX_APP_H_
#include "wx/event.h"
#include "wx/icon.h"
class WXDLLIMPEXP_FWD_CORE wxFrame;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxApp;
class WXDLLIMPEXP_FWD_CORE wxKeyEvent;
class WXDLLIMPEXP_FWD_BASE wxLog;
// Represents the application. Derive OnInit and declare
// a new App object to start application
class WXDLLIMPEXP_CORE wxApp : public wxAppBase
{
public:
wxApp();
virtual ~wxApp();
// override base class (pure) virtuals
virtual bool Initialize(int& argc, wxChar **argv) wxOVERRIDE;
virtual void CleanUp() wxOVERRIDE;
virtual void WakeUpIdle() wxOVERRIDE;
virtual void SetPrintMode(int mode) wxOVERRIDE { m_printMode = mode; }
virtual int GetPrintMode() const { return m_printMode; }
// implementation only
void OnIdle(wxIdleEvent& event);
void OnEndSession(wxCloseEvent& event);
void OnQueryEndSession(wxCloseEvent& event);
#if wxUSE_EXCEPTIONS
virtual bool OnExceptionInMainLoop() wxOVERRIDE;
#endif // wxUSE_EXCEPTIONS
// MSW-specific from now on
// ------------------------
// this suffix should be appended to all our Win32 class names to obtain a
// variant registered without CS_[HV]REDRAW styles
static const wxChar *GetNoRedrawClassSuffix() { return wxT("NR"); }
// Flags for GetRegisteredClassName()
enum
{
// Just a symbolic name indicating absence of any special flags.
RegClass_Default = 0,
// Return the name with the GetNoRedrawClassSuffix() appended to it.
RegClass_ReturnNR = 1,
// Don't register the class with CS_[HV]REDRAW styles. This is useful
// for internal windows for which we can guarantee that they will be
// never created with wxFULL_REPAINT_ON_RESIZE flag.
//
// Notice that this implies RegClass_ReturnNR.
RegClass_OnlyNR = 3
};
// get the name of the registered Win32 class with the given (unique) base
// name: this function constructs the unique class name using this name as
// prefix, checks if the class is already registered and registers it if it
// isn't and returns the name it was registered under (or NULL if it failed)
//
// the registered class will always have CS_[HV]REDRAW and CS_DBLCLKS
// styles as well as any additional styles specified as arguments here; and
// there will be also a companion registered class identical to this one
// but without CS_[HV]REDRAW whose name will be the same one but with
// GetNoRedrawClassSuffix()
//
// the background brush argument must be either a COLOR_XXX standard value
// or (default) -1 meaning that the class paints its background itself
static const wxChar *GetRegisteredClassName(const wxChar *name,
int bgBrushCol = -1,
int extraStyles = 0,
int flags = RegClass_Default);
// return true if this name corresponds to one of the classes we registered
// in the previous GetRegisteredClassName() calls
static bool IsRegisteredClassName(const wxString& name);
// Return the layout direction to use for a window by default.
//
// If the parent is specified, use the same layout direction as it uses.
// Otherwise use the default global layout, either from wxTheApp, if it
// exists, or Windows itself.
//
// Notice that this normally should not be used for the child windows as
// they already inherit, just dialogs such as wxMessageDialog may want to
// use it.
static wxLayoutDirection MSWGetDefaultLayout(wxWindow* parent = NULL);
// Call ProcessPendingEvents() but only if we need to do it, i.e. there was
// a recent call to WakeUpIdle().
void MSWProcessPendingEventsIfNeeded();
protected:
int m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
public:
// unregister any window classes registered by GetRegisteredClassName()
static void UnregisterWindowClasses();
#if wxUSE_RICHEDIT
// initialize the richedit DLL of (at least) given version, return true if
// ok
static bool InitRichEdit(int version = 2);
#endif // wxUSE_RICHEDIT
// returns 400, 470, 471 for comctl32.dll 4.00, 4.70, 4.71 or 0 if it
// wasn't found at all
static int GetComCtl32Version();
// the SW_XXX value to be used for the frames opened by the application
// (currently seems unused which is a bug -- TODO)
static int m_nCmdShow;
protected:
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxApp);
wxDECLARE_DYNAMIC_CLASS(wxApp);
};
#endif // _WX_APP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/combo.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/combo.h
// Purpose: wxComboCtrl class
// Author: Jaakko Salli
// Modified by:
// Created: Apr-30-2006
// Copyright: (c) Jaakko Salli
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COMBOCONTROL_H_
#define _WX_COMBOCONTROL_H_
// NB: Definition of _WX_COMBOCONTROL_H_ is used in wx/generic/combo.h to
// determine whether there is native wxComboCtrl, so make sure you
// use it in all native wxComboCtrls.
#if wxUSE_COMBOCTRL
#if wxUSE_TIMER
#include "wx/timer.h"
#define wxUSE_COMBOCTRL_POPUP_ANIMATION 1
#endif
// ----------------------------------------------------------------------------
// Native wxComboCtrl
// ----------------------------------------------------------------------------
// Define this only if native implementation includes all features
#define wxCOMBOCONTROL_FULLY_FEATURED
extern WXDLLIMPEXP_DATA_CORE(const char) wxComboBoxNameStr[];
class WXDLLIMPEXP_CORE wxComboCtrl : public wxComboCtrlBase
{
public:
// ctors and such
wxComboCtrl() : wxComboCtrlBase() { Init(); }
wxComboCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr)
: wxComboCtrlBase()
{
Init();
(void)Create(parent, id, value, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxComboBoxNameStr);
virtual ~wxComboCtrl();
virtual void PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const wxOVERRIDE;
virtual bool IsKeyPopupToggle(const wxKeyEvent& event) const wxOVERRIDE;
static int GetFeatures() { return wxComboCtrlFeatures::All; }
#if wxUSE_COMBOCTRL_POPUP_ANIMATION
void OnTimerEvent(wxTimerEvent& WXUNUSED(event)) { DoTimerEvent(); }
protected:
void DoTimerEvent();
virtual bool AnimateShow( const wxRect& rect, int flags ) wxOVERRIDE;
#endif // wxUSE_COMBOCTRL_POPUP_ANIMATION
protected:
// Dummy method - we override all functions that call this
virtual WXHWND GetEditHWND() const wxOVERRIDE { return NULL; }
// customization
virtual void OnResize() wxOVERRIDE;
virtual wxCoord GetNativeTextIndent() const wxOVERRIDE;
// event handlers
void OnPaintEvent( wxPaintEvent& event );
void OnMouseEvent( wxMouseEvent& event );
virtual bool HasTransparentBackground() wxOVERRIDE { return IsDoubleBuffered(); }
private:
void Init();
#if wxUSE_COMBOCTRL_POPUP_ANIMATION
// Popup animation related
wxMilliClock_t m_animStart;
wxTimer m_animTimer;
wxRect m_animRect;
int m_animFlags;
#endif
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxComboCtrl);
};
#endif // wxUSE_COMBOCTRL
#endif
// _WX_COMBOCONTROL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/dcmemory.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dcmemory.h
// Purpose: wxMemoryDC class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DCMEMORY_H_
#define _WX_DCMEMORY_H_
#include "wx/dcmemory.h"
#include "wx/msw/dc.h"
class WXDLLIMPEXP_CORE wxMemoryDCImpl: public wxMSWDCImpl
{
public:
wxMemoryDCImpl( wxMemoryDC *owner );
wxMemoryDCImpl( wxMemoryDC *owner, wxBitmap& bitmap );
wxMemoryDCImpl( wxMemoryDC *owner, wxDC *dc ); // Create compatible DC
// override some base class virtuals
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) wxOVERRIDE;
virtual void DoGetSize(int* width, int* height) const wxOVERRIDE;
virtual void DoSelect(const wxBitmap& bitmap) wxOVERRIDE;
virtual wxBitmap DoGetAsBitmap(const wxRect* subrect) const wxOVERRIDE
{ return subrect == NULL ? GetSelectedBitmap() : GetSelectedBitmap().GetSubBitmapOfHDC(*subrect, GetHDC() );}
protected:
// create DC compatible with the given one or screen if dc == NULL
bool CreateCompatible(wxDC *dc);
// initialize the newly created DC
void Init();
wxDECLARE_CLASS(wxMemoryDCImpl);
wxDECLARE_NO_COPY_CLASS(wxMemoryDCImpl);
};
#endif
// _WX_DCMEMORY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/anybutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/anybutton.h
// Purpose: wxAnyButton class
// Author: Julian Smart
// Created: 1997-02-01 (extracted from button.h)
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_ANYBUTTON_H_
#define _WX_MSW_ANYBUTTON_H_
// ----------------------------------------------------------------------------
// Common button functionality
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAnyButton : public wxAnyButtonBase
{
public:
wxAnyButton()
{
m_imageData = NULL;
#if wxUSE_MARKUP
m_markupText = NULL;
#endif // wxUSE_MARKUP
}
virtual ~wxAnyButton();
// overridden base class methods
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour &colour) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour &colour) wxOVERRIDE;
// implementation from now on
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
// usually overridden base class virtuals
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxBitmap DoGetBitmap(State which) const wxOVERRIDE;
virtual void DoSetBitmap(const wxBitmap& bitmap, State which) wxOVERRIDE;
virtual wxSize DoGetBitmapMargins() const wxOVERRIDE;
virtual void DoSetBitmapMargins(wxCoord x, wxCoord y) wxOVERRIDE;
virtual void DoSetBitmapPosition(wxDirection dir) wxOVERRIDE;
#if wxUSE_MARKUP
virtual bool DoSetLabelMarkup(const wxString& markup) wxOVERRIDE;
#endif // wxUSE_MARKUP
// Increases the passed in size to account for the button image.
//
// Should only be called if we do have a button, i.e. if m_imageData is
// non-NULL.
void AdjustForBitmapSize(wxSize& size) const;
class wxButtonImageData *m_imageData;
#if wxUSE_MARKUP
class wxMarkupText *m_markupText;
#endif // wxUSE_MARKUP
// Switches button into owner-drawn mode: this is used if we need to draw
// something not supported by the native control, such as using non default
// colours or a bitmap on pre-XP systems.
void MakeOwnerDrawn();
bool IsOwnerDrawn() const;
virtual bool MSWIsPushed() const;
private:
wxDECLARE_NO_COPY_CLASS(wxAnyButton);
};
#endif // _WX_MSW_ANYBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/toplevel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/toplevel.h
// Purpose: wxTopLevelWindowMSW is the MSW implementation of wxTLW
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.09.01
// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TOPLEVEL_H_
#define _WX_MSW_TOPLEVEL_H_
#include "wx/weakref.h"
// ----------------------------------------------------------------------------
// wxTopLevelWindowMSW
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTopLevelWindowMSW : public wxTopLevelWindowBase
{
public:
// constructors and such
wxTopLevelWindowMSW() { Init(); }
wxTopLevelWindowMSW(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual ~wxTopLevelWindowMSW();
// implement base class pure virtuals
virtual void SetTitle( const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
virtual void Maximize(bool maximize = true) wxOVERRIDE;
virtual bool IsMaximized() const wxOVERRIDE;
virtual void Iconize(bool iconize = true) wxOVERRIDE;
virtual bool IsIconized() const wxOVERRIDE;
virtual void SetIcons(const wxIconBundle& icons ) wxOVERRIDE;
virtual void Restore() wxOVERRIDE;
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual void Raise() wxOVERRIDE;
virtual void ShowWithoutActivating() wxOVERRIDE;
virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) wxOVERRIDE;
virtual bool IsFullScreen() const wxOVERRIDE { return m_fsIsShowing; }
// wxMSW only: EnableCloseButton(false) may be used to remove the "Close"
// button from the title bar
virtual bool EnableCloseButton(bool enable = true) wxOVERRIDE;
virtual bool EnableMaximizeButton(bool enable = true) wxOVERRIDE;
virtual bool EnableMinimizeButton(bool enable = true) wxOVERRIDE;
// Set window transparency if the platform supports it
virtual bool SetTransparent(wxByte alpha) wxOVERRIDE;
virtual bool CanSetTransparent() wxOVERRIDE;
// MSW-specific methods
// --------------------
// Return the menu representing the "system" menu of the window. You can
// call wxMenu::AppendWhatever() methods on it but removing items from it
// is in general not a good idea.
//
// The pointer returned by this method belongs to the window and will be
// deleted when the window itself is, do not delete it yourself. May return
// NULL if getting the system menu failed.
wxMenu *MSWGetSystemMenu() const;
// Enable or disable the close button of the specified window.
static bool MSWEnableCloseButton(WXHWND hwnd, bool enable = true);
// implementation from now on
// --------------------------
// event handlers
void OnActivate(wxActivateEvent& event);
// called by wxWindow whenever it gets focus
void SetLastFocus(wxWindow *win) { m_winLastFocused = win; }
wxWindow *GetLastFocus() const { return m_winLastFocused; }
// translate wxWidgets flags to Windows ones
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle) const wxOVERRIDE;
// choose the right parent to use with CreateWindow()
virtual WXHWND MSWGetParent() const wxOVERRIDE;
// window proc for the frames
WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
// This function is only for internal use.
void MSWSetShowCommand(WXUINT showCmd) { m_showCmd = showCmd; }
protected:
// common part of all ctors
void Init();
// create a new frame, return false if it couldn't be created
bool CreateFrame(const wxString& title,
const wxPoint& pos,
const wxSize& size);
// create a new dialog using the given dialog template from resources,
// return false if it couldn't be created
bool CreateDialog(const void *dlgTemplate,
const wxString& title,
const wxPoint& pos,
const wxSize& size);
// Just a wrapper around MSW ShowWindow().
void DoShowWindow(int nShowCmd);
// Return true if the window is iconized at MSW level, ignoring m_showCmd.
bool MSWIsIconized() const;
// override those to return the normal window coordinates even when the
// window is minimized
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
// Top level windows have different freeze semantics on Windows
virtual void DoFreeze() wxOVERRIDE;
virtual void DoThaw() wxOVERRIDE;
// helper of SetIcons(): calls gets the icon with the size specified by the
// given system metrics (SM_C{X|Y}[SM]ICON) from the bundle and sets it
// using WM_SETICON with the specified wParam (ICOM_SMALL or ICON_BIG);
// returns true if the icon was set
bool DoSelectAndSetIcon(const wxIconBundle& icons, int smX, int smY, int i);
// override wxWindow virtual method to use CW_USEDEFAULT if necessary
virtual void MSWGetCreateWindowCoords(const wxPoint& pos,
const wxSize& size,
int& x, int& y,
int& w, int& h) const wxOVERRIDE;
// This field contains the show command to use when showing the window the
// next time and also indicates whether the window should be considered
// being iconized or maximized (which may be different from whether it's
// actually iconized or maximized at MSW level).
WXUINT m_showCmd;
// Data to save/restore when calling ShowFullScreen
long m_fsStyle; // Passed to ShowFullScreen
wxRect m_fsOldSize;
long m_fsOldWindowStyle;
bool m_fsIsMaximized;
bool m_fsIsShowing;
// Save the current focus to m_winLastFocused if we're not iconized (the
// focus is always NULL when we're iconized).
void DoSaveLastFocus();
// Restore focus to m_winLastFocused if possible and needed.
void DoRestoreLastFocus();
// The last focused child: we remember it when we're deactivated and
// restore focus to it when we're activated (this is done here) or restored
// from iconic state (done by wxFrame).
wxWindowRef m_winLastFocused;
private:
// The system menu: initially NULL but can be set (once) by
// MSWGetSystemMenu(). Owned by this window.
wxMenu *m_menuSystem;
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxTopLevelWindowMSW);
};
#endif // _WX_MSW_TOPLEVEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/sound.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/sound.h
// Purpose: wxSound class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SOUND_H_
#define _WX_SOUND_H_
#if wxUSE_SOUND
class WXDLLIMPEXP_ADV wxSound : public wxSoundBase
{
public:
wxSound();
wxSound(const wxString& fileName, bool isResource = false);
wxSound(size_t size, const void* data);
virtual ~wxSound();
// Create from resource or file
bool Create(const wxString& fileName, bool isResource = false);
// Create from data
bool Create(size_t size, const void* data);
bool IsOk() const { return m_data != NULL; }
static void Stop();
protected:
void Init() { m_data = NULL; }
bool CheckCreatedOk();
void Free();
virtual bool DoPlay(unsigned flags) const wxOVERRIDE;
private:
// data of this object
class wxSoundData *m_data;
wxDECLARE_NO_COPY_CLASS(wxSound);
};
#endif // wxUSE_SOUND
#endif // _WX_SOUND_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/tooltip.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/tooltip.h
// Purpose: wxToolTip class - tooltip control
// Author: Vadim Zeitlin
// Modified by:
// Created: 31.01.99
// Copyright: (c) 1999 Robert Roebling, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TOOLTIP_H_
#define _WX_MSW_TOOLTIP_H_
#include "wx/object.h"
#include "wx/gdicmn.h"
class WXDLLIMPEXP_FWD_CORE wxWindow;
class wxToolTipOtherWindows;
class WXDLLIMPEXP_CORE wxToolTip : public wxObject
{
public:
// ctor & dtor
wxToolTip(const wxString &tip);
virtual ~wxToolTip();
// ctor used by wxStatusBar to associate a tooltip to a portion of
// the status bar window:
wxToolTip(wxWindow* win, unsigned int id,
const wxString &tip, const wxRect& rc);
// accessors
// tip text
void SetTip(const wxString& tip);
const wxString& GetTip() const { return m_text; }
// the window we're associated with
void SetWindow(wxWindow *win);
wxWindow *GetWindow() const { return m_window; }
// controlling tooltip behaviour: globally change tooltip parameters
// enable or disable the tooltips globally
static void Enable(bool flag);
// set the delay after which the tooltip appears
static void SetDelay(long milliseconds);
// set the delay after which the tooltip disappears or how long the
// tooltip remains visible
static void SetAutoPop(long milliseconds);
// set the delay between subsequent tooltips to appear
static void SetReshow(long milliseconds);
// set maximum width for the new tooltips: -1 disables wrapping
// entirely, 0 restores the default behaviour
static void SetMaxWidth(int width);
// implementation only from now on
// -------------------------------
// should be called in response to WM_MOUSEMOVE
static void RelayEvent(WXMSG *msg);
// add a window to the tooltip control
void AddOtherWindow(WXHWND hwnd);
// remove any tooltip from the window
static void Remove(WXHWND hwnd, unsigned int id, const wxRect& rc);
// Set the rectangle we're associated with. This rectangle is only used for
// the main window, not any sub-windows added with Add() so in general it
// makes sense to use it for tooltips associated with a single window only.
void SetRect(const wxRect& rc);
// Called when TLW shown state is changed and hides the tooltip itself if
// the window it's associated with is hidden.
static void UpdateVisibility();
private:
// This module calls our DeleteToolTipCtrl().
friend class wxToolTipModule;
// Adds a window other than our main m_window to this tooltip.
void DoAddHWND(WXHWND hWnd);
// Perform the specified operation for the given window only.
void DoSetTip(WXHWND hWnd);
void DoRemove(WXHWND hWnd);
// Call the given function for all windows we're associated with.
void DoForAllWindows(void (wxToolTip::*func)(WXHWND));
// the one and only one tooltip control we use - never access it directly
// but use GetToolTipCtrl() which will create it when needed
static WXHWND ms_hwndTT;
// create the tooltip ctrl if it doesn't exist yet and return its HWND
static WXHWND GetToolTipCtrl();
// to be used in wxModule for deleting tooltip ctrl window when exiting mainloop
static void DeleteToolTipCtrl();
// new tooltip maximum width, defaults to min(display width, 400)
static int ms_maxWidth;
// remove this tooltip from the tooltip control
void Remove();
// adjust tooltip max width based on current tooltip text
bool AdjustMaxWidth();
wxString m_text; // tooltip text
wxWindow* m_window; // main window we're associated with
wxToolTipOtherWindows *m_others; // other windows associated with it or NULL
wxRect m_rect; // the rect of the window for which this tooltip is shown
// (or a rect with width/height == 0 to show it for the entire window)
unsigned int m_id; // the id of this tooltip (ignored when m_rect width/height is 0)
wxDECLARE_ABSTRACT_CLASS(wxToolTip);
wxDECLARE_NO_COPY_CLASS(wxToolTip);
};
#endif // _WX_MSW_TOOLTIP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/stattext.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stattext.h
// Purpose: wxStaticText class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATTEXT_H_
#define _WX_STATTEXT_H_
class WXDLLIMPEXP_CORE wxStaticText : public wxStaticTextBase
{
public:
wxStaticText() { }
wxStaticText(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr)
{
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticTextNameStr);
// override some methods to resize the window properly
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool SetFont( const wxFont &font ) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
// implement/override some base class virtuals
virtual void DoSetSize(int x, int y, int w, int h,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual wxString DoGetLabel() const wxOVERRIDE;
virtual void DoSetLabel(const wxString& str) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticText);
};
#endif
// _WX_STATTEXT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/genrcdefs.h | /*
* Name: wx/msw/genrcdefs.h
* Purpose: Emit preprocessor symbols into rcdefs.h for resource compiler
* Author: Mike Wetherell
* Copyright: (c) 2005 Mike Wetherell
* Licence: wxWindows licence
*/
#define EMIT(line) line
EMIT(#ifndef _WX_RCDEFS_H)
EMIT(#define _WX_RCDEFS_H)
#ifdef _MSC_FULL_VER
#if _MSC_FULL_VER < 140040130
EMIT(#define wxUSE_RC_MANIFEST 1)
#endif
#else
EMIT(#define wxUSE_RC_MANIFEST 1)
#endif
#if defined _M_AMD64 || defined __x86_64__
EMIT(#define WX_CPU_AMD64)
#endif
#ifdef _M_ARM
EMIT(#define WX_CPU_ARM)
#endif
#ifdef _M_ARM64
EMIT(#define WX_CPU_ARM64)
#endif
#if defined _M_IA64 || defined __ia64__
EMIT(#define WX_CPU_IA64)
#endif
#if defined _M_IX86 || defined _X86_
EMIT(#define WX_CPU_X86)
#endif
#ifdef _M_PPC
EMIT(#define WX_CPU_PPC)
#endif
#ifdef _M_SH
EMIT(#define WX_CPU_SH)
#endif
EMIT(#endif)
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/imaglist.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/imaglist.h
// Purpose: wxImageList class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGLIST_H_
#define _WX_IMAGLIST_H_
#include "wx/bitmap.h"
// Eventually we'll make this a reference-counted wxGDIObject. For
// now, the app must take care of ownership issues. That is, the
// image lists must be explicitly deleted after the control(s) that uses them
// is (are) deleted, or when the app exits.
class WXDLLIMPEXP_CORE wxImageList : public wxObject
{
public:
/*
* Public interface
*/
wxImageList();
// Creates an image list.
// Specify the width and height of the images in the list,
// whether there are masks associated with them (e.g. if creating images
// from icons), and the initial size of the list.
wxImageList(int width, int height, bool mask = true, int initialCount = 1)
{
Create(width, height, mask, initialCount);
}
virtual ~wxImageList();
// Attributes
////////////////////////////////////////////////////////////////////////////
// Returns the number of images in the image list.
int GetImageCount() const;
// Returns the size (same for all images) of the images in the list
bool GetSize(int index, int &width, int &height) const;
// Returns the overall size
wxSize GetSize() const { return m_size; }
// Operations
////////////////////////////////////////////////////////////////////////////
// Creates an image list
// width, height specify the size of the images in the list (all the same).
// mask specifies whether the images have masks or not.
// initialNumber is the initial number of images to reserve.
bool Create(int width, int height, bool mask = true, int initialNumber = 1);
// Adds a bitmap, and optionally a mask bitmap.
// Note that wxImageList creates *new* bitmaps, so you may delete
// 'bitmap' and 'mask' after calling Add.
int Add(const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
// Adds a bitmap, using the specified colour to create the mask bitmap
// Note that wxImageList creates *new* bitmaps, so you may delete
// 'bitmap' after calling Add.
int Add(const wxBitmap& bitmap, const wxColour& maskColour);
// Adds a bitmap and mask from an icon.
int Add(const wxIcon& icon);
// Replaces a bitmap, optionally passing a mask bitmap.
// Note that wxImageList creates new bitmaps, so you may delete
// 'bitmap' and 'mask' after calling Replace.
bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
// Replaces a bitmap and mask from an icon.
// You can delete 'icon' after calling Replace.
bool Replace(int index, const wxIcon& icon);
// Removes the image at the given index.
bool Remove(int index);
// Remove all images
bool RemoveAll();
// Draws the given image on a dc at the specified position.
// If 'solidBackground' is true, Draw sets the image list background
// colour to the background colour of the wxDC, to speed up
// drawing by eliminating masked drawing where possible.
bool Draw(int index, wxDC& dc, int x, int y,
int flags = wxIMAGELIST_DRAW_NORMAL,
bool solidBackground = false);
// Get a bitmap
wxBitmap GetBitmap(int index) const;
// Get an icon
wxIcon GetIcon(int index) const;
// TODO: miscellaneous functionality
/*
wxIcon *MakeIcon(int index);
bool SetOverlayImage(int index, int overlayMask);
*/
// TODO: Drag-and-drop related functionality.
#if 0
// Creates a new drag image by combining the given image (typically a mouse cursor image)
// with the current drag image.
bool SetDragCursorImage(int index, const wxPoint& hotSpot);
// If successful, returns a pointer to the temporary image list that is used for dragging;
// otherwise, NULL.
// dragPos: receives the current drag position.
// hotSpot: receives the offset of the drag image relative to the drag position.
static wxImageList *GetDragImageList(wxPoint& dragPos, wxPoint& hotSpot);
// Call this function to begin dragging an image. This function creates a temporary image list
// that is used for dragging. The image combines the specified image and its mask with the
// current cursor. In response to subsequent mouse move messages, you can move the drag image
// by using the DragMove member function. To end the drag operation, you can use the EndDrag
// member function.
bool BeginDrag(int index, const wxPoint& hotSpot);
// Ends a drag operation.
bool EndDrag();
// Call this function to move the image that is being dragged during a drag-and-drop operation.
// This function is typically called in response to a mouse move message. To begin a drag
// operation, use the BeginDrag member function.
static bool DragMove(const wxPoint& point);
// During a drag operation, locks updates to the window specified by lockWindow and displays
// the drag image at the position specified by point.
// The coordinates are relative to the window's upper left corner, so you must compensate
// for the widths of window elements, such as the border, title bar, and menu bar, when
// specifying the coordinates.
// If lockWindow is NULL, this function draws the image in the display context associated
// with the desktop window, and coordinates are relative to the upper left corner of the screen.
// This function locks all other updates to the given window during the drag operation.
// If you need to do any drawing during a drag operation, such as highlighting the target
// of a drag-and-drop operation, you can temporarily hide the dragged image by using the
// wxImageList::DragLeave function.
// lockWindow: pointer to the window that owns the drag image.
// point: position at which to display the drag image. Coordinates are relative to the
// upper left corner of the window (not the client area).
static bool DragEnter( wxWindow *lockWindow, const wxPoint& point );
// Unlocks the window specified by pWndLock and hides the drag image, allowing the
// window to be updated.
static bool DragLeave( wxWindow *lockWindow );
/* Here's roughly how you'd use these functions:
1) Starting to drag:
wxImageList *dragImageList = new wxImageList(16, 16, true);
dragImageList->Add(myDragImage); // Provide an image to combine with the current cursor
dragImageList->BeginDrag(0, wxPoint(0, 0));
wxShowCursor(false); // wxShowCursor not yet implemented in wxWin
myWindow->CaptureMouse();
2) Dragging:
// Called within mouse move event. Could also use dragImageList instead of assuming
// these are static functions.
// These two functions could possibly be combined into one, since DragEnter is
// a bit obscure.
wxImageList::DragMove(wxPoint(x, y)); // x, y are current cursor position
wxImageList::DragEnter(NULL, wxPoint(x, y)); // NULL assumes dragging across whole screen
3) Finishing dragging:
dragImageList->EndDrag();
myWindow->ReleaseMouse();
wxShowCursor(true);
*/
#endif
// Implementation
////////////////////////////////////////////////////////////////////////////
// Returns the native image list handle
WXHIMAGELIST GetHIMAGELIST() const { return m_hImageList; }
protected:
WXHIMAGELIST m_hImageList;
wxSize m_size;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxImageList);
};
#endif
// _WX_IMAGLIST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/gdiimage.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/gdiimage.h
// Purpose: wxGDIImage class: base class for wxBitmap, wxIcon, wxCursor
// under MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 20.11.99
// Copyright: (c) 1999 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// NB: this is a private header, it is not intended to be directly included by
// user code (but may be included from other, public, wxWin headers
#ifndef _WX_MSW_GDIIMAGE_H_
#define _WX_MSW_GDIIMAGE_H_
#include "wx/gdiobj.h" // base class
#include "wx/gdicmn.h" // wxBITMAP_TYPE_INVALID
#include "wx/list.h"
class WXDLLIMPEXP_FWD_CORE wxGDIImageRefData;
class WXDLLIMPEXP_FWD_CORE wxGDIImageHandler;
class WXDLLIMPEXP_FWD_CORE wxGDIImage;
WX_DECLARE_EXPORTED_LIST(wxGDIImageHandler, wxGDIImageHandlerList);
// ----------------------------------------------------------------------------
// wxGDIImageRefData: common data fields for all derived classes
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImageRefData : public wxGDIRefData
{
public:
wxGDIImageRefData()
{
m_width = m_height = m_depth = 0;
m_handle = 0;
}
wxGDIImageRefData(const wxGDIImageRefData& data) : wxGDIRefData()
{
m_width = data.m_width;
m_height = data.m_height;
m_depth = data.m_depth;
// can't copy handles like this, derived class copy ctor must do it!
m_handle = NULL;
}
// accessors
virtual bool IsOk() const wxOVERRIDE { return m_handle != 0; }
void SetSize(int w, int h) { m_width = w; m_height = h; }
// free the resources we allocated
virtual void Free() = 0;
// for compatibility, the member fields are public
// the size of the image
int m_width, m_height;
// the depth of the image
int m_depth;
// the handle to it
union
{
WXHANDLE m_handle; // for untyped access
WXHBITMAP m_hBitmap;
WXHICON m_hIcon;
WXHCURSOR m_hCursor;
};
};
// ----------------------------------------------------------------------------
// wxGDIImage: this class supports GDI image handlers which may be registered
// dynamically and will be used for loading/saving the images in the specified
// format. It also falls back to wxImage if no appropriate image is found.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImage : public wxGDIObject
{
public:
// handlers list interface
static wxGDIImageHandlerList& GetHandlers() { return ms_handlers; }
static void AddHandler(wxGDIImageHandler *handler);
static void InsertHandler(wxGDIImageHandler *handler);
static bool RemoveHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& name);
static wxGDIImageHandler *FindHandler(const wxString& extension, long type);
static wxGDIImageHandler *FindHandler(long type);
static void InitStandardHandlers();
static void CleanUpHandlers();
// access to the ref data casted to the right type
wxGDIImageRefData *GetGDIImageData() const
{ return (wxGDIImageRefData *)m_refData; }
// accessors
WXHANDLE GetHandle() const
{ return IsNull() ? 0 : GetGDIImageData()->m_handle; }
void SetHandle(WXHANDLE handle)
{ AllocExclusive(); GetGDIImageData()->m_handle = handle; }
int GetWidth() const { return IsNull() ? 0 : GetGDIImageData()->m_width; }
int GetHeight() const { return IsNull() ? 0 : GetGDIImageData()->m_height; }
int GetDepth() const { return IsNull() ? 0 : GetGDIImageData()->m_depth; }
wxSize GetSize() const
{
return IsNull() ? wxSize(0,0) :
wxSize(GetGDIImageData()->m_width, GetGDIImageData()->m_height);
}
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_INLINE(void SetWidth(int w), AllocExclusive(); GetGDIImageData()->m_width = w; )
wxDEPRECATED_INLINE(void SetHeight(int h), AllocExclusive(); GetGDIImageData()->m_height = h; )
wxDEPRECATED_INLINE(void SetDepth(int d), AllocExclusive(); GetGDIImageData()->m_depth = d; )
wxDEPRECATED_INLINE(void SetSize(int w, int h), AllocExclusive(); GetGDIImageData()->SetSize(w, h); )
wxDEPRECATED_INLINE(void SetSize(const wxSize& size), AllocExclusive(); GetGDIImageData()->SetSize(size.x, size.y); )
#endif // WXWIN_COMPATIBILITY_3_0
// forward some of base class virtuals to wxGDIImageRefData
bool FreeResource(bool force = false) wxOVERRIDE;
virtual WXHANDLE GetResourceHandle() const wxOVERRIDE;
protected:
// create the data for the derived class here
virtual wxGDIImageRefData *CreateData() const = 0;
// implement the wxGDIObject method in terms of our, more specific, one
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE { return CreateData(); }
// we can't [efficiently] clone objects of this class
virtual wxGDIRefData *
CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const wxOVERRIDE
{
wxFAIL_MSG( wxT("must be implemented if used") );
return NULL;
}
static wxGDIImageHandlerList ms_handlers;
};
// ----------------------------------------------------------------------------
// wxGDIImageHandler: a class which knows how to load/save wxGDIImages.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxGDIImageHandler : public wxObject
{
public:
// ctor
wxGDIImageHandler() { m_type = wxBITMAP_TYPE_INVALID; }
wxGDIImageHandler(const wxString& name,
const wxString& ext,
wxBitmapType type)
: m_name(name), m_extension(ext), m_type(type) { }
// accessors
void SetName(const wxString& name) { m_name = name; }
void SetExtension(const wxString& ext) { m_extension = ext; }
void SetType(wxBitmapType type) { m_type = type; }
const wxString& GetName() const { return m_name; }
const wxString& GetExtension() const { return m_extension; }
wxBitmapType GetType() const { return m_type; }
// real handler operations: to implement in derived classes
virtual bool Create(wxGDIImage *image,
const void* data,
wxBitmapType flags,
int width, int height, int depth = 1) = 0;
virtual bool Load(wxGDIImage *image,
const wxString& name,
wxBitmapType flags,
int desiredWidth, int desiredHeight) = 0;
virtual bool Save(const wxGDIImage *image,
const wxString& name,
wxBitmapType type) const = 0;
protected:
wxString m_name;
wxString m_extension;
wxBitmapType m_type;
};
#endif // _WX_MSW_GDIIMAGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/radiobut.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/radiobut.h
// Purpose: wxRadioButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBUT_H_
#define _WX_RADIOBUT_H_
#include "wx/msw/ownerdrawnbutton.h"
class WXDLLIMPEXP_CORE wxRadioButton : public wxMSWOwnerDrawnButton<wxControl>
{
public:
// ctors and creation functions
wxRadioButton() { Init(); }
wxRadioButton(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr)
{
Init();
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxRadioButtonNameStr);
// implement the radio button interface
virtual void SetValue(bool value);
virtual bool GetValue() const;
// implementation only from now on
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// Implement wxMSWOwnerDrawnButtonBase methods.
virtual int MSWGetButtonStyle() const wxOVERRIDE;
virtual void MSWOnButtonResetOwnerDrawn() wxOVERRIDE;
virtual int MSWGetButtonCheckedFlag() const wxOVERRIDE;
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) wxOVERRIDE;
private:
// common part of all ctors
void Init();
// we need to store the state internally as the result of GetValue()
// sometimes gets out of sync in WM_COMMAND handler
bool m_isChecked;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxRadioButton);
};
#endif // _WX_RADIOBUT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/radiobox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/radiobox.h
// Purpose: wxRadioBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_RADIOBOX_H_
#define _WX_RADIOBOX_H_
#include "wx/statbox.h"
class WXDLLIMPEXP_FWD_CORE wxSubwindows;
// ----------------------------------------------------------------------------
// wxRadioBox
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxRadioBox : public wxStaticBox, public wxRadioBoxBase
{
public:
wxRadioBox() { Init(); }
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, n, choices, majorDim,
style, val, name);
}
wxRadioBox(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr)
{
Init();
(void)Create(parent, id, title, pos, size, choices, majorDim,
style, val, name);
}
virtual ~wxRadioBox();
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
int majorDim = 0,
long style = wxRA_SPECIFY_COLS,
const wxValidator& val = wxDefaultValidator,
const wxString& name = wxRadioBoxNameStr);
// implement the radiobox interface
virtual void SetSelection(int n) wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE { return m_selectedButton; }
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& label) wxOVERRIDE;
virtual bool Enable(unsigned int n, bool enable = true) wxOVERRIDE;
virtual bool Show(unsigned int n, bool show = true) wxOVERRIDE;
virtual bool IsItemEnabled(unsigned int n) const wxOVERRIDE;
virtual bool IsItemShown(unsigned int n) const wxOVERRIDE;
virtual int GetItemFromPoint(const wxPoint& pt) const wxOVERRIDE;
// override some base class methods
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool CanBeFocused() const wxOVERRIDE;
virtual void SetFocus() wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual bool HasToolTips() const wxOVERRIDE;
#endif // wxUSE_TOOLTIPS
#if wxUSE_HELP
// override virtual function with a platform-independent implementation
virtual wxString GetHelpTextAtPoint(const wxPoint & pt, wxHelpEvent::Origin origin) const wxOVERRIDE
{
return wxRadioBoxBase::DoGetHelpTextAtPoint( this, pt, origin );
}
#endif // wxUSE_HELP
virtual bool Reparent(wxWindowBase *newParent) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
void SetLabelFont(const wxFont& WXUNUSED(font)) {}
void SetButtonFont(const wxFont& font) { SetFont(font); }
// implementation only from now on
// -------------------------------
// This function can be used to check if the given radio button HWND
// belongs to one of our radio boxes. If it doesn't, NULL is returned.
static wxRadioBox *GetFromRadioButtonHWND(WXHWND hwnd);
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
void Command(wxCommandEvent& event) wxOVERRIDE;
void SendNotificationEvent();
protected:
// common part of all ctors
void Init();
// subclass one radio button
void SubclassRadioButton(WXHWND hWndBtn);
// get the max size of radio buttons
wxSize GetMaxButtonSize() const;
// get the total size occupied by the radio box buttons
wxSize GetTotalButtonSize(const wxSize& sizeBtn) const;
// Adjust all the buttons to the new window size.
void PositionAllButtons(int x, int y, int width, int height);
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetItemToolTip(unsigned int n, wxToolTip * tooltip) wxOVERRIDE;
#endif
virtual WXHRGN MSWGetRegionWithoutChildren() wxOVERRIDE;
// resolve ambiguity in base classes
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxRadioBoxBase::GetDefaultBorder(); }
// the buttons we contain
wxSubwindows *m_radioButtons;
// and the special dummy button used only as a tab group boundary
WXHWND m_dummyHwnd;
wxWindowIDRef m_dummyId;
// currently selected button or wxNOT_FOUND if none
int m_selectedButton;
private:
wxDECLARE_DYNAMIC_CLASS(wxRadioBox);
wxDECLARE_NO_COPY_CLASS(wxRadioBox);
};
#endif
// _WX_RADIOBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/hyperlink.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/hyperlink.h
// Purpose: Hyperlink control
// Author: Rickard Westerlund
// Created: 2010-08-04
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_HYPERLINK_H_
#define _WX_MSW_HYPERLINK_H_
#include "wx/generic/hyperlink.h"
// ----------------------------------------------------------------------------
// wxHyperlinkCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxHyperlinkCtrl : public wxGenericHyperlinkCtrl
{
public:
// Default constructor (for two-step construction).
wxHyperlinkCtrl() { }
// Constructor.
wxHyperlinkCtrl(wxWindow *parent,
wxWindowID id,
const wxString& label, const wxString& url,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHL_DEFAULT_STYLE,
const wxString& name = wxHyperlinkCtrlNameStr)
{
(void)Create(parent, id, label, url, pos, size, style, name);
}
// Creation function (for two-step construction).
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label, const wxString& url,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxHL_DEFAULT_STYLE,
const wxString& name = wxHyperlinkCtrlNameStr);
// overridden base class methods
// -----------------------------
virtual void SetURL(const wxString &url) wxOVERRIDE;
virtual void SetLabel(const wxString &label) wxOVERRIDE;
protected:
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
private:
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS( wxHyperlinkCtrl );
};
#endif // _WX_MSW_HYPERLINK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/stdpaths.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stdpaths.h
// Purpose: wxStandardPaths for Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-10-19
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STDPATHS_H_
#define _WX_MSW_STDPATHS_H_
struct _GUID;
// ----------------------------------------------------------------------------
// wxStandardPaths
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStandardPaths : public wxStandardPathsBase
{
public:
// implement base class pure virtuals
virtual wxString GetExecutablePath() const wxOVERRIDE;
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
virtual wxString GetDataDir() const wxOVERRIDE;
virtual wxString GetUserDataDir() const wxOVERRIDE;
virtual wxString GetUserLocalDataDir() const wxOVERRIDE;
virtual wxString GetPluginsDir() const wxOVERRIDE;
virtual wxString GetUserDir(Dir userDir) const wxOVERRIDE;
virtual wxString MakeConfigFileName(const wxString& basename,
ConfigFileConv conv = ConfigFileConv_Ext
) const wxOVERRIDE;
// MSW-specific methods
// This class supposes that data, plugins &c files are located under the
// program directory which is the directory containing the application
// binary itself. But sometimes this binary may be in a subdirectory of the
// main program directory, e.g. this happens in at least the following
// common cases:
// 1. The program is in "bin" subdirectory of the installation directory.
// 2. The program is in "debug" subdirectory of the directory containing
// sources and data files during development
//
// By calling this function you instruct the class to remove the last
// component of the path if it matches its argument. Notice that it may be
// called more than once, e.g. you can call both IgnoreAppSubDir("bin") and
// IgnoreAppSubDir("debug") to take care of both production and development
// cases above but that each call will only remove the last path component.
// Finally note that the argument can contain wild cards so you can also
// call IgnoreAppSubDir("vc*msw*") to ignore all build directories at once
// when using wxWidgets-inspired output directories names.
void IgnoreAppSubDir(const wxString& subdirPattern);
// This function is used to ignore all common build directories and is
// called from the ctor -- use DontIgnoreAppSubDir() to undo this.
void IgnoreAppBuildSubDirs();
// Undo the effects of all preceding IgnoreAppSubDir() calls.
void DontIgnoreAppSubDir();
// Returns the directory corresponding to the specified Windows shell CSIDL
static wxString MSWGetShellDir(int csidl);
protected:
// Ctor is protected, use wxStandardPaths::Get() instead of instantiating
// objects of this class directly.
//
// It calls IgnoreAppBuildSubDirs() and also sets up the object to use
// both vendor and application name by default.
wxStandardPaths();
// get the path corresponding to the given standard CSIDL_XXX constant
static wxString DoGetDirectory(int csidl);
static wxString DoGetKnownFolder(const _GUID& rfid);
// return the directory of the application itself
wxString GetAppDir() const;
// directory returned by GetAppDir()
mutable wxString m_appDir;
};
// ----------------------------------------------------------------------------
// wxStandardPathsWin16: this class is for internal use only
// ----------------------------------------------------------------------------
// override config file locations to be compatible with the values used by
// wxFileConfig (dating from Win16 days which explains the class name)
class WXDLLIMPEXP_BASE wxStandardPathsWin16 : public wxStandardPaths
{
public:
virtual wxString GetConfigDir() const wxOVERRIDE;
virtual wxString GetUserConfigDir() const wxOVERRIDE;
};
#endif // _WX_MSW_STDPATHS_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/checklst.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/checklst.h
// Purpose: wxCheckListBox class - a listbox with checkable items
// Author: Vadim Zeitlin
// Modified by:
// Created: 16.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef __CHECKLST__H_
#define __CHECKLST__H_
#if !wxUSE_OWNER_DRAWN
#error "wxCheckListBox class requires owner-drawn functionality."
#endif
class WXDLLIMPEXP_FWD_CORE wxOwnerDrawn;
class WXDLLIMPEXP_FWD_CORE wxCheckListBoxItem; // fwd decl, defined in checklst.cpp
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
public:
// ctors
wxCheckListBox();
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// items may be checked
virtual bool IsChecked(unsigned int uiIndex) const wxOVERRIDE;
virtual void Check(unsigned int uiIndex, bool bCheck = true) wxOVERRIDE;
virtual void Toggle(unsigned int uiIndex);
// we create our items ourselves and they have non-standard size,
// so we need to override these functions
virtual wxOwnerDrawn *CreateLboxItem(size_t n) wxOVERRIDE;
virtual bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item) wxOVERRIDE;
protected:
// pressing space or clicking the check box toggles the item
void OnKeyDown(wxKeyEvent& event);
void OnLeftClick(wxMouseEvent& event);
// send an "item checked" event
void SendEvent(unsigned int uiIndex)
{
wxCommandEvent event(wxEVT_CHECKLISTBOX, GetId());
event.SetInt(uiIndex);
event.SetEventObject(this);
event.SetString(GetString(uiIndex));
ProcessCommand(event);
}
wxSize DoGetBestClientSize() const wxOVERRIDE;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckListBox);
};
#endif //_CHECKLST_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/htmlhelp.h | /*
* wx/msw/htmlhelp.h
* Copyright 2004 Jacek Caban
*
* Originally written for the Wine project, and issued under
* the wxWindows licence by kind permission of the author.
*
* Licence: wxWindows licence
*/
#ifndef __HTMLHELP_H__
#define __HTMLHELP_H__
#define HH_DISPLAY_TOPIC 0x00
#define HH_HELP_FINDER 0x00
#define HH_DISPLAY_TOC 0x01
#define HH_DISPLAY_INDEX 0x02
#define HH_DISPLAY_SEARCH 0x03
#define HH_SET_WIN_TYPE 0x04
#define HH_GET_WIN_TYPE 0x05
#define HH_GET_WIN_HANDLE 0x06
#define HH_ENUM_INFO_TYPE 0x07
#define HH_SET_INFO_TYPE 0x08
#define HH_SYNC 0x09
#define HH_RESERVED1 0x0A
#define HH_RESERVED2 0x0B
#define HH_RESERVED3 0x0C
#define HH_KEYWORD_LOOKUP 0x0D
#define HH_DISPLAY_TEXT_POPUP 0x0E
#define HH_HELP_CONTEXT 0x0F
#define HH_TP_HELP_CONTEXTMENU 0x10
#define HH_TP_HELP_WM_HELP 0x11
#define HH_CLOSE_ALL 0x12
#define HH_ALINK_LOOKUP 0x13
#define HH_GET_LAST_ERROR 0x14
#define HH_ENUM_CATEGORY 0x15
#define HH_ENUM_CATEGORY_IT 0x16
#define HH_RESET_IT_FILTER 0x17
#define HH_SET_INCLUSIVE_FILTER 0x18
#define HH_SET_EXCLUSIVE_FILTER 0x19
#define HH_INITIALIZE 0x1C
#define HH_UNINITIALIZE 0x1D
#define HH_PRETRANSLATEMESSAGE 0xFD
#define HH_SET_GLOBAL_PROPERTY 0xFC
#define HHWIN_PROP_TAB_AUTOHIDESHOW 0x00000001
#define HHWIN_PROP_ONTOP 0x00000002
#define HHWIN_PROP_NOTITLEBAR 0x00000004
#define HHWIN_PROP_NODEF_STYLES 0x00000008
#define HHWIN_PROP_NODEF_EXSTYLES 0x00000010
#define HHWIN_PROP_TRI_PANE 0x00000020
#define HHWIN_PROP_NOTB_TEXT 0x00000040
#define HHWIN_PROP_POST_QUIT 0x00000080
#define HHWIN_PROP_AUTO_SYNC 0x00000100
#define HHWIN_PROP_TRACKING 0x00000200
#define HHWIN_PROP_TAB_SEARCH 0x00000400
#define HHWIN_PROP_TAB_HISTORY 0x00000800
#define HHWIN_PROP_TAB_FAVORITES 0x00001000
#define HHWIN_PROP_CHANGE_TITLE 0x00002000
#define HHWIN_PROP_NAV_ONLY_WIN 0x00004000
#define HHWIN_PROP_NO_TOOLBAR 0x00008000
#define HHWIN_PROP_MENU 0x00010000
#define HHWIN_PROP_TAB_ADVSEARCH 0x00020000
#define HHWIN_PROP_USER_POS 0x00040000
#define HHWIN_PROP_TAB_CUSTOM1 0x00080000
#define HHWIN_PROP_TAB_CUSTOM2 0x00100000
#define HHWIN_PROP_TAB_CUSTOM3 0x00200000
#define HHWIN_PROP_TAB_CUSTOM4 0x00400000
#define HHWIN_PROP_TAB_CUSTOM5 0x00800000
#define HHWIN_PROP_TAB_CUSTOM6 0x01000000
#define HHWIN_PROP_TAB_CUSTOM7 0x02000000
#define HHWIN_PROP_TAB_CUSTOM8 0x04000000
#define HHWIN_PROP_TAB_CUSTOM9 0x08000000
#define HHWIN_TB_MARGIN 0x10000000
#define HHWIN_PARAM_PROPERTIES 0x00000002
#define HHWIN_PARAM_STYLES 0x00000004
#define HHWIN_PARAM_EXSTYLES 0x00000008
#define HHWIN_PARAM_RECT 0x00000010
#define HHWIN_PARAM_NAV_WIDTH 0x00000020
#define HHWIN_PARAM_SHOWSTATE 0x00000040
#define HHWIN_PARAM_INFOTYPES 0x00000080
#define HHWIN_PARAM_TB_FLAGS 0x00000100
#define HHWIN_PARAM_EXPANSION 0x00000200
#define HHWIN_PARAM_TABPOS 0x00000400
#define HHWIN_PARAM_TABORDER 0x00000800
#define HHWIN_PARAM_HISTORY_COUNT 0x00001000
#define HHWIN_PARAM_CUR_TAB 0x00002000
#define HHWIN_BUTTON_EXPAND 0x00000002
#define HHWIN_BUTTON_BACK 0x00000004
#define HHWIN_BUTTON_FORWARD 0x00000008
#define HHWIN_BUTTON_STOP 0x00000010
#define HHWIN_BUTTON_REFRESH 0x00000020
#define HHWIN_BUTTON_HOME 0x00000040
#define HHWIN_BUTTON_BROWSE_FWD 0x00000080
#define HHWIN_BUTTON_BROWSE_BCK 0x00000100
#define HHWIN_BUTTON_NOTES 0x00000200
#define HHWIN_BUTTON_CONTENTS 0x00000400
#define HHWIN_BUTTON_SYNC 0x00000800
#define HHWIN_BUTTON_OPTIONS 0x00001000
#define HHWIN_BUTTON_PRINT 0x00002000
#define HHWIN_BUTTON_INDEX 0x00004000
#define HHWIN_BUTTON_SEARCH 0x00008000
#define HHWIN_BUTTON_HISTORY 0x00010000
#define HHWIN_BUTTON_FAVORITES 0x00020000
#define HHWIN_BUTTON_JUMP1 0x00040000
#define HHWIN_BUTTON_JUMP2 0x00080000
#define HHWIN_BUTTON_ZOOM 0x00100000
#define HHWIN_BUTTON_TOC_NEXT 0x00200000
#define HHWIN_BUTTON_TOC_PREV 0x00400000
#define HHWIN_DEF_BUTTONS \
(HHWIN_BUTTON_EXPAND | HHWIN_BUTTON_BACK | HHWIN_BUTTON_OPTIONS | HHWIN_BUTTON_PRINT)
#define IDTB_EXPAND 200
#define IDTB_CONTRACT 201
#define IDTB_STOP 202
#define IDTB_REFRESH 203
#define IDTB_BACK 204
#define IDTB_HOME 205
#define IDTB_SYNC 206
#define IDTB_PRINT 207
#define IDTB_OPTIONS 208
#define IDTB_FORWARD 209
#define IDTB_NOTES 210
#define IDTB_BROWSE_FWD 211
#define IDTB_BROWSE_BACK 212
#define IDTB_CONTENTS 213
#define IDTB_INDEX 214
#define IDTB_SEARCH 215
#define IDTB_HISTORY 216
#define IDTB_FAVORITES 217
#define IDTB_JUMP1 218
#define IDTB_JUMP2 219
#define IDTB_CUSTOMIZE 221
#define IDTB_ZOOM 222
#define IDTB_TOC_NEXT 223
#define IDTB_TOC_PREV 224
#define HHN_FIRST (0U-860U)
#define HHN_LAST (0U-879U)
#define HHN_NAVCOMPLETE HHN_FIRST
#define HHN_TRACK (HHN_FIRST-1)
#define HHN_WINDOW_CREATE (HHN_FIRST-2)
#ifdef __cplusplus
extern "C" {
#endif
typedef struct tagHH_NOTIFY {
NMHDR hdr;
PCSTR pszurl;
} HH_NOTIFY;
typedef struct tagHH_POPUPA {
int cbStruct;
HINSTANCE hinst;
UINT idString;
LPCSTR pszText;
POINT pt;
COLORREF clrForeground;
COLORREF clrBackground;
RECT rcMargins;
LPCSTR pszFont;
} HH_POPUPA;
typedef struct tagHH_POPUPW {
int cbStruct;
HINSTANCE hinst;
UINT idString;
LPCWSTR pszText;
POINT pt;
COLORREF clrForeground;
COLORREF clrBackground;
RECT rcMargins;
LPCWSTR pszFont;
} HH_POPUPW;
#ifdef _UNICODE
typedef HH_POPUPW HH_POPUP;
#else
typedef HH_POPUPA HH_POPUP;
#endif
typedef struct tagHH_ALINKA {
int cbStruct;
BOOL fReserved;
LPCSTR pszKeywords;
LPCSTR pszUrl;
LPCSTR pszMsgText;
LPCSTR pszMsgTitle;
LPCSTR pszWindow;
BOOL fIndexOnFail;
} HH_ALINKA;
typedef struct tagHH_ALINKW {
int cbStruct;
BOOL fReserved;
LPCWSTR pszKeywords;
LPCWSTR pszUrl;
LPCWSTR pszMsgText;
LPCWSTR pszMsgTitle;
LPCWSTR pszWindow;
BOOL fIndexOnFail;
} HH_ALINKW;
#ifdef _UNICODE
typedef HH_ALINKW HH_ALINK;
typedef HH_ALINKW HH_AKLINK;
#else
typedef HH_ALINKA HH_ALINK;
typedef HH_ALINKA HH_AKLINK;
#endif
enum {
HHWIN_NAVTYPE_TOC,
HHWIN_NAVTYPE_INDEX,
HHWIN_NAVTYPE_SEARCH,
HHWIN_NAVTYPE_FAVORITES,
HHWIN_NAVTYPE_HISTORY,
HHWIN_NAVTYPE_AUTHOR,
HHWIN_NAVTYPE_CUSTOM_FIRST = 11
};
enum {
IT_INCLUSIVE,
IT_EXCLUSIVE,
IT_HIDDEN
};
typedef struct tagHH_ENUM_IT {
int cbStruct;
int iType;
LPCSTR pszCatName;
LPCSTR pszITName;
LPCSTR pszITDescription;
} HH_ENUM_IT, *PHH_ENUM_IT;
typedef struct tagHH_ENUM_CAT {
int cbStruct;
LPCSTR pszCatName;
LPCSTR pszCatDescription;
} HH_ENUM_CAT, *PHH_ENUM_CAT;
typedef struct tagHH_SET_INFOTYPE {
int cbStruct;
LPCSTR pszCatName;
LPCSTR pszInfoTypeName;
} HH_SET_INFOTYPE;
typedef DWORD HH_INFOTYPE, *PHH_INFOTYPE;
enum {
HHWIN_NAVTAB_TOP,
HHWIN_NAVTAB_LEFT,
HHWIN_NAVTAB_BOTTOM
};
#define HH_MAX_TABS 19
enum {
HH_TAB_CONTENTS,
HH_TAB_INDEX,
HH_TAB_SEARCH,
HH_TAB_FAVORITES,
HH_TAB_HISTORY,
HH_TAB_AUTHOR,
HH_TAB_CUSTOM_FIRST = 11,
HH_TAB_CUSTOM_LAST = HH_MAX_TABS
};
#define HH_MAX_TABS_CUSTOM (HH_TAB_CUSTOM_LAST-HH_TAB_CUSTOM_FIRST+1)
#define HH_FTS_DEFAULT_PROXIMITY -1
typedef struct tagHH_FTS_QUERYA {
int cbStruct;
BOOL fUniCodeStrings;
LPCSTR pszSearchQuery;
LONG iProximity;
BOOL fStemmedSearch;
BOOL fTitleOnly;
BOOL fExecute;
LPCSTR pszWindow;
} HH_FTS_QUERYA;
typedef struct tagHH_FTS_QUERYW {
int cbStruct;
BOOL fUniCodeStrings;
LPCWSTR pszSearchQuery;
LONG iProximity;
BOOL fStemmedSearch;
BOOL fTitleOnly;
BOOL fExecute;
LPCWSTR pszWindow;
} HH_FTS_QUERYW;
#ifdef _UNICODE
typedef HH_FTS_QUERYW HH_FTS_QUERY;
#else
typedef HH_FTS_QUERYA HH_FTS_QUERY;
#endif
typedef struct tagHH_WINTYPEA {
int cbStruct;
BOOL fUniCodeStrings;
LPCSTR pszType;
DWORD fsValidMembers;
DWORD fsWinProperties;
LPCSTR pszCaption;
DWORD dwStyles;
DWORD dwExStyles;
RECT rcWindowPos;
int nShowState;
HWND hwndHelp;
HWND hwndCaller;
PHH_INFOTYPE paInfoTypes;
HWND hwndToolBar;
HWND hwndNavigation;
HWND hwndHTML;
int iNavWidth;
RECT rcHTML;
LPCSTR pszToc;
LPCSTR pszIndex;
LPCSTR pszFile;
LPCSTR pszHome;
DWORD fsToolBarFlags;
BOOL fNotExpanded;
int curNavType;
int tabpos;
int idNotify;
BYTE tabOrder[HH_MAX_TABS+1];
int cHistory;
LPCSTR pszJump1;
LPCSTR pszJump2;
LPCSTR pszUrlJump1;
LPCSTR pszUrlJump2;
RECT rcMinSize;
int cbInfoTypes;
LPCSTR pszCustomTabs;
} HH_WINTYPEA, *PHH_WINTYPEA;
typedef struct tagHH_WINTYPEW {
int cbStruct;
BOOL fUniCodeStrings;
LPCWSTR pszType;
DWORD fsValidMembers;
DWORD fsWinProperties;
LPCWSTR pszCaption;
DWORD dwStyles;
DWORD dwExStyles;
RECT rcWindowPos;
int nShowState;
HWND hwndHelp;
HWND hwndCaller;
PHH_INFOTYPE paInfoTypes;
HWND hwndToolBar;
HWND hwndNavigation;
HWND hwndHTML;
int iNavWidth;
RECT rcHTML;
LPCWSTR pszToc;
LPCWSTR pszIndex;
LPCWSTR pszFile;
LPCWSTR pszHome;
DWORD fsToolBarFlags;
BOOL fNotExpanded;
int curNavType;
int tabpos;
int idNotify;
BYTE tabOrder[HH_MAX_TABS+1];
int cHistory;
LPCWSTR pszJump1;
LPCWSTR pszJump2;
LPCWSTR pszUrlJump1;
LPCWSTR pszUrlJump2;
RECT rcMinSize;
int cbInfoTypes;
LPCWSTR pszCustomTabs;
} HH_WINTYPEW, *PHH_WINTYPEW;
#ifdef _UNICODE
typedef HH_WINTYPEW HH_WINTYPE;
#else
typedef HH_WINTYPEA HH_WINTYPE;
#endif
enum {
HHACT_TAB_CONTENTS,
HHACT_TAB_INDEX,
HHACT_TAB_SEARCH,
HHACT_TAB_HISTORY,
HHACT_TAB_FAVORITES,
HHACT_EXPAND,
HHACT_CONTRACT,
HHACT_BACK,
HHACT_FORWARD,
HHACT_STOP,
HHACT_REFRESH,
HHACT_HOME,
HHACT_SYNC,
HHACT_OPTIONS,
HHACT_PRINT,
HHACT_HIGHLIGHT,
HHACT_CUSTOMIZE,
HHACT_JUMP1,
HHACT_JUMP2,
HHACT_ZOOM,
HHACT_TOC_NEXT,
HHACT_TOC_PREV,
HHACT_NOTES,
HHACT_LAST_ENUM
};
typedef struct tagHH_NTRACKA {
NMHDR hdr;
PCSTR pszCurUrl;
int idAction;
PHH_WINTYPEA phhWinType;
} HH_NTRACKA;
typedef struct tagHH_NTRACKW {
NMHDR hdr;
PCSTR pszCurUrl;
int idAction;
PHH_WINTYPEW phhWinType;
} HH_NTRACKW;
#ifdef _UNICODE
typedef HH_NTRACKW HH_NTRACK;
#else
typedef HH_NTRACKA HH_NTRACK;
#endif
HWND WINAPI HtmlHelpA(HWND,LPCSTR,UINT,DWORD);
HWND WINAPI HtmlHelpA(HWND,LPCSTR,UINT,DWORD);
#define HtmlHelp WINELIB_NAME_AW(HtmlHelp)
#define ATOM_HTMLHELP_API_ANSI (LPTSTR)14
#define ATOM_HTMLHELP_API_UNICODE (LPTSTR)15
typedef enum tagHH_GPROPID {
HH_GPROPID_SINGLETHREAD = 1,
HH_GPROPID_TOOLBAR_MARGIN = 2,
HH_GPROPID_UI_LANGUAGE = 3,
HH_GPROPID_CURRENT_SUBSET = 4,
HH_GPROPID_CONTENT_LANGUAGE = 5
} HH_GPROPID;
#ifdef __WIDL_OAIDL_H
typedef struct tagHH_GLOBAL_PROPERTY
{
HH_GPROPID id;
VARIANT var;
} HH_GLOBAL_PROPERTY ;
#endif /* __WIDL_OAIDL_H */
#ifdef __cplusplus
}
#endif
#endif /* __HTMLHELP_H__ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/listbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/listbox.h
// Purpose: wxListBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTBOX_H_
#define _WX_LISTBOX_H_
#if wxUSE_LISTBOX
// ----------------------------------------------------------------------------
// simple types
// ----------------------------------------------------------------------------
#if wxUSE_OWNER_DRAWN
class WXDLLIMPEXP_FWD_CORE wxOwnerDrawn;
// define the array of list box items
#include "wx/dynarray.h"
WX_DEFINE_EXPORTED_ARRAY_PTR(wxOwnerDrawn *, wxListBoxItemsArray);
#endif // wxUSE_OWNER_DRAWN
// forward declaration for GetSelections()
class WXDLLIMPEXP_FWD_BASE wxArrayInt;
// ----------------------------------------------------------------------------
// List box control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxListBox : public wxListBoxBase
{
public:
// ctors and such
wxListBox() { Init(); }
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Init();
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr)
{
Init();
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
virtual ~wxListBox();
virtual unsigned int GetCount() const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& s) wxOVERRIDE;
virtual int FindString(const wxString& s, bool bCase = false) const wxOVERRIDE;
virtual bool IsSelected(int n) const wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual int GetSelections(wxArrayInt& aSelections) const wxOVERRIDE;
// return the index of the item at this position or wxNOT_FOUND
int HitTest(const wxPoint& pt) const { return DoHitTestList(pt); }
int HitTest(wxCoord x, wxCoord y) const { return DoHitTestList(wxPoint(x, y)); }
virtual void EnsureVisible(int n) wxOVERRIDE;
virtual int GetTopItem() const wxOVERRIDE;
virtual int GetCountPerPage() const wxOVERRIDE;
// ownerdrawn wxListBox and wxCheckListBox support
#if wxUSE_OWNER_DRAWN
// override base class virtuals
virtual bool SetFont(const wxFont &font) wxOVERRIDE;
bool MSWOnMeasure(WXMEASUREITEMSTRUCT *item) wxOVERRIDE;
bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE;
// plug-in for derived classes
virtual wxOwnerDrawn *CreateLboxItem(size_t n);
// allows to get the item and use SetXXX functions to set it's appearance
wxOwnerDrawn *GetItem(size_t n) const { return m_aItems[n]; }
// get the index of the given item
int GetItemIndex(wxOwnerDrawn *item) const { return m_aItems.Index(item); }
// get rect of the given item index
bool GetItemRect(size_t n, wxRect& rect) const;
// redraw the given item
bool RefreshItem(size_t n);
#endif // wxUSE_OWNER_DRAWN
// Windows-specific code to update the horizontal extent of the listbox, if
// necessary. If s is non-empty, the horizontal extent is increased to the
// length of this string if it's currently too short, otherwise the maximum
// extent of all strings is used. In any case calls InvalidateBestSize()
virtual void SetHorizontalExtent(const wxString& s = wxEmptyString);
// Windows callbacks
bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// under XP when using "transition effect for menus and tooltips" if we
// return true for WM_PRINTCLIENT here then it causes noticeable slowdown
virtual bool MSWShouldPropagatePrintChild() wxOVERRIDE
{
return false;
}
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL)
{
return GetCompositeControlsDefaultAttributes(variant);
}
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
virtual void OnInternalIdle() wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoClear() wxOVERRIDE;
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual void DoSetSelection(int n, bool select) wxOVERRIDE;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual void DoSetFirstItem(int n) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
// this can't be called DoHitTest() because wxWindow already has this method
virtual int DoHitTestList(const wxPoint& point) const;
// free memory (common part of Clear() and dtor)
void Free();
unsigned int m_noItems;
#if wxUSE_OWNER_DRAWN
// control items
wxListBoxItemsArray m_aItems;
#endif
private:
// common part of all ctors
void Init();
// call this when items are added to or deleted from the listbox or an
// items text changes
void MSWOnItemsChanged();
// flag indicating whether the max horizontal extent should be updated,
// i.e. if we need to call SetHorizontalExtent() from OnInternalIdle()
bool m_updateHorizontalExtent;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxListBox);
};
#endif // wxUSE_LISTBOX
#endif
// _WX_LISTBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/textentry.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/textentry.h
// Purpose: wxMSW-specific wxTextEntry implementation
// Author: Vadim Zeitlin
// Created: 2007-09-26
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TEXTENTRY_H_
#define _WX_MSW_TEXTENTRY_H_
class wxTextAutoCompleteData; // private class used only by wxTextEntry itself
// ----------------------------------------------------------------------------
// wxTextEntry: common part of wxComboBox and (single line) wxTextCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxTextEntry : public wxTextEntryBase
{
public:
wxTextEntry();
virtual ~wxTextEntry();
// implement wxTextEntryBase pure virtual methods
virtual void WriteText(const wxString& text) wxOVERRIDE;
virtual void Remove(long from, long to) wxOVERRIDE;
virtual void Copy() wxOVERRIDE;
virtual void Cut() wxOVERRIDE;
virtual void Paste() wxOVERRIDE;
virtual void Undo() wxOVERRIDE;
virtual void Redo() wxOVERRIDE;
virtual bool CanUndo() const wxOVERRIDE;
virtual bool CanRedo() const wxOVERRIDE;
virtual void SetInsertionPoint(long pos) wxOVERRIDE;
virtual long GetInsertionPoint() const wxOVERRIDE;
virtual long GetLastPosition() const wxOVERRIDE;
virtual void SetSelection(long from, long to) wxOVERRIDE
{ DoSetSelection(from, to); }
virtual void GetSelection(long *from, long *to) const wxOVERRIDE;
virtual bool IsEditable() const wxOVERRIDE;
virtual void SetEditable(bool editable) wxOVERRIDE;
virtual void SetMaxLength(unsigned long len) wxOVERRIDE;
virtual void ForceUpper() wxOVERRIDE;
#if wxUSE_UXTHEME
virtual bool SetHint(const wxString& hint) wxOVERRIDE;
virtual wxString GetHint() const wxOVERRIDE;
#endif // wxUSE_UXTHEME
protected:
virtual wxString DoGetValue() const wxOVERRIDE;
// this is really a hook for multiline text controls as the single line
// ones don't need to ever scroll to show the selection but having it here
// allows us to put Remove() in the base class
enum
{
SetSel_NoScroll = 0, // don't do anything special
SetSel_Scroll = 1 // default: scroll to make the selection visible
};
virtual void DoSetSelection(long from, long to, int flags = SetSel_Scroll);
// margins functions
virtual bool DoSetMargins(const wxPoint& pt) wxOVERRIDE;
virtual wxPoint DoGetMargins() const wxOVERRIDE;
// auto-completion uses COM under Windows so they won't work without
// wxUSE_OLE as OleInitialize() is not called then
#if wxUSE_OLE
virtual bool DoAutoCompleteStrings(const wxArrayString& choices) wxOVERRIDE;
#if wxUSE_DYNLIB_CLASS
virtual bool DoAutoCompleteFileNames(int flags) wxOVERRIDE;
#endif // wxUSE_DYNLIB_CLASS
virtual bool DoAutoCompleteCustom(wxTextCompleter *completer) wxOVERRIDE;
#endif // wxUSE_OLE
private:
// implement this to return the HWND of the EDIT control
virtual WXHWND GetEditHWND() const = 0;
#if wxUSE_OLE
// This method is called to process special keys such as Return and Tab
// before they're consumed by the auto-completer. Notice that it is only
// called if we do need to process the key, i.e. if the corresponding
// wxTE_PROCESS_XXX style is set in the associated object.
//
// It is not pure virtual because it won't get called if the derived class
// doesn't use auto-completer, but it does need to be overridden if it can
// be called and the default implementation asserts if this is not the case.
virtual void MSWProcessSpecialKey(wxKeyEvent& event);
// Get the auto-complete object creating it if necessary. Returns NULL if
// creating it failed.
wxTextAutoCompleteData *GetOrCreateCompleter();
// Various auto-completion-related stuff, only used if any of AutoComplete()
// methods are called. Use the function above to access it.
wxTextAutoCompleteData *m_autoCompleteData;
// It needs to call our GetEditableWindow() and GetEditHWND() methods.
friend class wxTextAutoCompleteData;
#endif // wxUSE_OLE
};
// We don't need the generic version.
#define wxHAS_NATIVE_TEXT_FORCEUPPER
#endif // _WX_MSW_TEXTENTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/wrapwin.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapwin.h
// Purpose: Wrapper around <windows.h>, to be included instead of it
// Author: Vaclav Slavik
// Created: 2003/07/22
// Copyright: (c) 2003 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_WRAPWIN_H_
#define _WX_WRAPWIN_H_
#include "wx/platform.h"
// before including windows.h, define version macros at (currently) maximal
// values because we do all our checks at run-time anyhow
#include "wx/msw/winver.h"
// strict type checking to detect conversion from HFOO to HBAR at compile-time
#ifndef STRICT
#define STRICT 1
#endif
// this macro tells windows.h to not define min() and max() as macros: we need
// this as otherwise they conflict with standard C++ functions
#ifndef NOMINMAX
#define NOMINMAX
#endif // NOMINMAX
// For IPv6 support, we must include winsock2.h before winsock.h, and
// windows.h include winsock.h so do it before including it
#if wxUSE_IPV6
#include <winsock2.h>
#endif
// Disable any warnings inside Windows headers.
#ifdef __VISUALC__
#pragma warning(push, 1)
#endif
#include <windows.h>
#ifdef __VISUALC__
#pragma warning(pop)
#endif
// #undef the macros defined in winsows.h which conflict with code elsewhere
#include "wx/msw/winundef.h"
#endif // _WX_WRAPWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/fontdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/fontdlg.h
// Purpose: wxFontDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_FONTDLG_H_
#define _WX_MSW_FONTDLG_H_
// ----------------------------------------------------------------------------
// wxFontDialog
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFontDialog : public wxFontDialogBase
{
public:
wxFontDialog() : wxFontDialogBase() { /* must be Create()d later */ }
wxFontDialog(wxWindow *parent)
: wxFontDialogBase(parent) { Create(parent); }
wxFontDialog(wxWindow *parent, const wxFontData& data)
: wxFontDialogBase(parent, data) { Create(parent, data); }
virtual int ShowModal() wxOVERRIDE;
virtual void SetTitle(const wxString& title) wxOVERRIDE;
virtual wxString GetTitle() const wxOVERRIDE;
protected:
wxString m_title;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxFontDialog);
};
#endif
// _WX_MSW_FONTDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/filedlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/filedlg.h
// Purpose: wxFileDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_FILEDLG_H_
#define _WX_FILEDLG_H_
//-------------------------------------------------------------------------
// wxFileDialog
//-------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxFileDialog: public wxFileDialogBase
{
public:
wxFileDialog(wxWindow *parent,
const wxString& message = wxFileSelectorPromptStr,
const wxString& defaultDir = wxEmptyString,
const wxString& defaultFile = wxEmptyString,
const wxString& wildCard = wxFileSelectorDefaultWildcardStr,
long style = wxFD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& sz = wxDefaultSize,
const wxString& name = wxFileDialogNameStr);
virtual void GetPaths(wxArrayString& paths) const wxOVERRIDE;
virtual void GetFilenames(wxArrayString& files) const wxOVERRIDE;
virtual bool SupportsExtraControl() const wxOVERRIDE { return true; }
void MSWOnInitDialogHook(WXHWND hwnd);
virtual int ShowModal() wxOVERRIDE;
// wxMSW-specific implementation from now on
// -----------------------------------------
// called from the hook procedure on CDN_INITDONE reception
virtual void MSWOnInitDone(WXHWND hDlg);
// called from the hook procedure on CDN_SELCHANGE.
void MSWOnSelChange(WXHWND hDlg);
protected:
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoCentre(int dir) wxOVERRIDE;
virtual void DoGetSize( int *width, int *height ) const wxOVERRIDE;
virtual void DoGetPosition( int *x, int *y ) const wxOVERRIDE;
private:
wxArrayString m_fileNames;
// remember if our SetPosition() or Centre() (which requires special
// treatment) was called
bool m_bMovedWindow;
int m_centreDir; // nothing to do if 0
wxDECLARE_DYNAMIC_CLASS(wxFileDialog);
wxDECLARE_NO_COPY_CLASS(wxFileDialog);
};
#endif // _WX_FILEDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/gccpriv.h | /*
Name: wx/msw/gccpriv.h
Purpose: MinGW/Cygwin definitions
Author: Vadim Zeitlin
Modified by:
Created:
Copyright: (c) Vadim Zeitlin
Licence: wxWindows Licence
*/
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
#ifndef _WX_MSW_GCCPRIV_H_
#define _WX_MSW_GCCPRIV_H_
#if defined(__MINGW32__) && !defined(__GNUWIN32__)
#define __GNUWIN32__
#endif
#if defined(__MINGW32__)
/*
Include the header defining __MINGW32_{MAJ,MIN}OR_VERSION but check
that UNICODE or _UNICODE is already defined, as _mingw.h relies on them
being set and we'd get weird compilation errors later if it is included
without them being defined, better give a clearer error right now.
*/
#if !defined(UNICODE)
#ifndef wxUSE_UNICODE
#error "wxUSE_UNICODE must be defined before including this header."
#endif
#if wxUSE_UNICODE
#error "UNICODE must be defined before including this header."
#endif
#endif
/*
MinGW 5.3.0 (and presumably later) predefines _WIN32_WINNT and WINVER
in sdkddkver.h included from _mingw.h to very low (Windows 2000!)
values. We really want to predefine them ourselves instead, so do it
before including _mingw.h.
*/
#include "wx/msw/winver.h"
#include <_mingw.h>
/*
MinGW-w64 project provides compilers for both Win32 and Win64 but only
defines the same __MINGW32__ symbol for the former as MinGW32 toolchain
which is quite different (notably doesn't provide many SDK headers that
MinGW-w64 does include). So we define a separate symbol which, unlike
the predefined __MINGW64__, can be used to detect this toolchain in
both 32 and 64 bit builds.
And define __MINGW32_TOOLCHAIN__ for consistency and also because it's
convenient as we often want to have some workarounds only for the (old)
MinGW32 but not (newer) MinGW-w64, which still predefines __MINGW32__.
*/
#ifdef __MINGW64_VERSION_MAJOR
#ifndef __MINGW64_TOOLCHAIN__
#define __MINGW64_TOOLCHAIN__
#endif
#else
#ifndef __MINGW32_TOOLCHAIN__
#define __MINGW32_TOOLCHAIN__
#endif
#endif
#define wxCHECK_MINGW32_VERSION( major, minor ) \
( ( ( __MINGW32_MAJOR_VERSION > (major) ) \
|| ( __MINGW32_MAJOR_VERSION == (major) && __MINGW32_MINOR_VERSION >= (minor) ) ) )
#else
#define wxCHECK_MINGW32_VERSION( major, minor ) (0)
#endif
#if defined( __MINGW32__ ) && !defined(__WINE__) && !defined( HAVE_W32API_H )
#if __MINGW32_MAJOR_VERSION >= 1
#define HAVE_W32API_H
#endif
#elif defined( __CYGWIN__ ) && !defined( HAVE_W32API_H )
#if ( __GNUC__ > 2 )
#define HAVE_W32API_H
#endif
#endif
/* check for MinGW/Cygwin w32api version ( releases >= 0.5, only ) */
#if defined( HAVE_W32API_H )
#include <w32api.h>
#endif
#if defined(__W32API_MAJOR_VERSION) && defined(__W32API_MINOR_VERSION)
#define wxCHECK_W32API_VERSION( major, minor ) \
( ( ( __W32API_MAJOR_VERSION > (major) ) \
|| ( __W32API_MAJOR_VERSION == (major) && __W32API_MINOR_VERSION >= (minor) ) ) )
#else
#define wxCHECK_W32API_VERSION( major, minor ) (0)
#endif
/* Cygwin 1.0 */
#if defined(__CYGWIN__) && ((__GNUC__==2) && (__GNUC_MINOR__==9))
#define __CYGWIN10__
#endif
/*
Traditional MinGW (but not MinGW-w64 nor TDM-GCC) omits many POSIX
functions from their headers when compiled with __STRICT_ANSI__ defined.
Unfortunately this means that they are not available when using -std=c++98
(not very common) or -std=c++11 (much more so), but we still need them even
in this case. As the intention behind using -std=c++11 is probably to get
the new C++11 features and not disable the use of POSIX functions, we just
manually declare the functions we need in this case if necessary.
*/
#ifdef __MINGW32_TOOLCHAIN__
/*
The macro below is used in wx/wxcrtbase.h included from C regex library
code, so make sure it compiles in non-C++ code too.
*/
#ifdef __cplusplus
#define wxEXTERNC extern "C"
#else
#define wxEXTERNC
#endif
/*
This macro is somewhat unusual as it takes the list of parameters
inside parentheses and includes semicolon inside it as putting the
semicolon outside wouldn't do the right thing when this macro is empty.
*/
#define wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params) \
wxEXTERNC _CRTIMP rettype __cdecl __MINGW_NOTHROW func params ;
#ifdef __STRICT_ANSI__
#define wxNEEDS_STRICT_ANSI_WORKAROUNDS
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params) \
wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params)
/*
There is a bug resulting in a compilation error in MinGW standard
math.h header, see https://sourceforge.net/p/mingw/bugs/2250/, work
around it here because math.h is also included from several other
standard headers (e.g. <algorithm>) and we don't want to duplicate this
hack everywhere this happens.
*/
wxDECL_FOR_STRICT_MINGW32(double, _hypot, (double, double))
#else
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params)
#endif
#else
#define wxDECL_FOR_MINGW32_ALWAYS(rettype, func, params)
#define wxDECL_FOR_STRICT_MINGW32(rettype, func, params)
#endif
#endif
/* _WX_MSW_GCCPRIV_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/apptrait.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/apptrait.h
// Purpose: class implementing wxAppTraits for MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 21.06.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_APPTRAIT_H_
#define _WX_MSW_APPTRAIT_H_
// ----------------------------------------------------------------------------
// wxGUI/ConsoleAppTraits: must derive from wxAppTraits, not wxAppTraitsBase
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxConsoleAppTraits : public wxConsoleAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
virtual void *BeforeChildWaitLoop() wxOVERRIDE;
virtual void AfterChildWaitLoop(void *data) wxOVERRIDE;
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif // wxUSE_TIMER
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() wxOVERRIDE;
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags) wxOVERRIDE;
#endif // wxUSE_THREADS
virtual bool CanUseStderr() wxOVERRIDE { return true; }
virtual bool WriteToStderr(const wxString& text) wxOVERRIDE;
};
#if wxUSE_GUI
#if defined(__WXMSW__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop() wxOVERRIDE;
virtual void *BeforeChildWaitLoop() wxOVERRIDE;
virtual void AfterChildWaitLoop(void *data) wxOVERRIDE;
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer) wxOVERRIDE;
#endif // wxUSE_TIMER
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() wxOVERRIDE;
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags) wxOVERRIDE;
#endif // wxUSE_THREADS
wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const wxOVERRIDE;
virtual bool CanUseStderr() wxOVERRIDE;
virtual bool WriteToStderr(const wxString& text) wxOVERRIDE;
};
#elif defined(__WXGTK__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop();
virtual void *BeforeChildWaitLoop() { return NULL; }
virtual void AfterChildWaitLoop(void *WXUNUSED(data)) { }
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer);
#endif
#if wxUSE_THREADS && defined(__WXGTK20__)
virtual void MutexGuiEnter();
virtual void MutexGuiLeave();
#endif
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() { return true; }
virtual WXDWORD WaitForThread(WXHANDLE hThread, int WXUNUSED(flags))
{ return DoSimpleWaitForThread(hThread); }
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const;
virtual bool CanUseStderr() { return false; }
virtual bool WriteToStderr(const wxString& WXUNUSED(text)) { return false; }
};
#elif defined(__WXQT__)
class WXDLLIMPEXP_CORE wxGUIAppTraits : public wxGUIAppTraitsBase
{
public:
virtual wxEventLoopBase *CreateEventLoop();
virtual void *BeforeChildWaitLoop() { return NULL; }
virtual void AfterChildWaitLoop(void*) { }
#if wxUSE_TIMER
virtual wxTimerImpl *CreateTimerImpl(wxTimer *timer);
#endif
#if wxUSE_THREADS
virtual bool DoMessageFromThreadWait() { return true; }
virtual WXDWORD WaitForThread(WXHANDLE hThread, int WXUNUSED(flags))
{ return DoSimpleWaitForThread(hThread); }
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL,
int *minVer = NULL,
int *microVer = NULL) const;
virtual bool CanUseStderr() { return false; }
virtual bool WriteToStderr(const wxString&) { return false; }
};
#endif
#endif // wxUSE_GUI
#endif // _WX_MSW_APPTRAIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/spinbutt.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/spinbutt.h
// Purpose: wxSpinButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SPINBUTT_H_
#define _WX_SPINBUTT_H_
#include "wx/control.h"
#include "wx/event.h"
#if wxUSE_SPINBTN
class WXDLLIMPEXP_CORE wxSpinButton : public wxSpinButtonBase
{
public:
// construction
wxSpinButton() { }
wxSpinButton(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME)
{
Create(parent, id, pos, size, style, name);
}
virtual ~wxSpinButton();
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
const wxString& name = wxSPIN_BUTTON_NAME);
// accessors
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int val) wxOVERRIDE;
virtual void SetRange(int minVal, int maxVal) wxOVERRIDE;
// implementation
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
// a wxSpinButton can't do anything useful with focus, only wxSpinCtrl can
virtual bool AcceptsFocus() const wxOVERRIDE { return false; }
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// ensure that the control displays a value in the current range
virtual void NormalizeValue();
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxSpinButton);
};
#endif // wxUSE_SPINBTN
#endif // _WX_SPINBUTT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/helpbest.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpbest.h
// Purpose: Tries to load MS HTML Help, falls back to wxHTML upon failure
// Author: Mattia Barbon
// Modified by:
// Created: 02/04/2001
// Copyright: (c) Mattia Barbon
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPBEST_H_
#define _WX_HELPBEST_H_
#if wxUSE_HELP && wxUSE_MS_HTML_HELP \
&& wxUSE_WXHTML_HELP && !defined(__WXUNIVERSAL__)
#include "wx/helpbase.h"
#include "wx/html/helpfrm.h" // for wxHF_DEFAULT_STYLE
class WXDLLIMPEXP_HTML wxBestHelpController: public wxHelpControllerBase
{
public:
wxBestHelpController(wxWindow* parentWindow = NULL,
int style = wxHF_DEFAULT_STYLE)
: wxHelpControllerBase(parentWindow),
m_helpControllerType(wxUseNone),
m_helpController(NULL),
m_style(style)
{
}
virtual ~wxBestHelpController() { delete m_helpController; }
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE
{
return m_helpController->LoadFile( GetValidFilename( file ) );
}
virtual bool DisplayContents() wxOVERRIDE
{
return m_helpController->DisplayContents();
}
virtual bool DisplaySection(int sectionNo) wxOVERRIDE
{
return m_helpController->DisplaySection( sectionNo );
}
virtual bool DisplaySection(const wxString& section) wxOVERRIDE
{
return m_helpController->DisplaySection( section );
}
virtual bool DisplayBlock(long blockNo) wxOVERRIDE
{
return m_helpController->DisplayBlock( blockNo );
}
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE
{
return m_helpController->DisplayContextPopup( contextId );
}
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos) wxOVERRIDE
{
return m_helpController->DisplayTextPopup( text, pos );
}
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE
{
return m_helpController->KeywordSearch( k, mode );
}
virtual bool Quit() wxOVERRIDE
{
return m_helpController->Quit();
}
// Allows one to override the default settings for the help frame.
virtual void SetFrameParameters(const wxString& title,
const wxSize& size,
const wxPoint& pos = wxDefaultPosition,
bool newFrameEachTime = false) wxOVERRIDE
{
m_helpController->SetFrameParameters( title, size, pos,
newFrameEachTime );
}
// Obtains the latest settings used by the help frame and the help frame.
virtual wxFrame *GetFrameParameters(wxSize *size = NULL,
wxPoint *pos = NULL,
bool *newFrameEachTime = NULL) wxOVERRIDE
{
return m_helpController->GetFrameParameters( size, pos,
newFrameEachTime );
}
/// Set the window that can optionally be used for the help window's parent.
virtual void SetParentWindow(wxWindow* win) wxOVERRIDE { m_helpController->SetParentWindow(win); }
/// Get the window that can optionally be used for the help window's parent.
virtual wxWindow* GetParentWindow() const wxOVERRIDE { return m_helpController->GetParentWindow(); }
protected:
// Append/change extension if necessary.
wxString GetValidFilename(const wxString& file) const;
protected:
enum HelpControllerType { wxUseNone, wxUseHtmlHelp, wxUseChmHelp };
HelpControllerType m_helpControllerType;
wxHelpControllerBase* m_helpController;
int m_style;
wxDECLARE_DYNAMIC_CLASS(wxBestHelpController);
wxDECLARE_NO_COPY_CLASS(wxBestHelpController);
};
#endif // wxUSE_HELP && wxUSE_MS_HTML_HELP && wxUSE_WXHTML_HELP
#endif
// _WX_HELPBEST_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/registry.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/registry.h
// Purpose: Registry classes and functions
// Author: Vadim Zeitlin
// Modified by:
// Created: 03.04.1998
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_REGISTRY_H_
#define _WX_MSW_REGISTRY_H_
#include "wx/defs.h"
#if wxUSE_REGKEY
class WXDLLIMPEXP_FWD_BASE wxOutputStream;
// ----------------------------------------------------------------------------
// class wxRegKey encapsulates window HKEY handle
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxRegKey
{
public:
// NB: do _not_ change the values of elements in these enumerations!
// registry value types (with comments from winnt.h)
enum ValueType
{
Type_None, // No value type
Type_String, // Unicode nul terminated string
Type_Expand_String, // Unicode nul terminated string
// (with environment variable references)
Type_Binary, // Free form binary
Type_Dword, // 32-bit number
Type_Dword_little_endian // 32-bit number
= Type_Dword, // (same as Type_DWORD)
Type_Dword_big_endian, // 32-bit number
Type_Link, // Symbolic Link (unicode)
Type_Multi_String, // Multiple Unicode strings
Type_Resource_list, // Resource list in the resource map
Type_Full_resource_descriptor, // Resource list in the hardware description
Type_Resource_requirements_list // ???
};
// predefined registry keys
enum StdKey
{
HKCR, // classes root
HKCU, // current user
HKLM, // local machine
HKUSR, // users
HKPD, // (obsolete under XP and later)
HKCC, // current config
HKDD, // (obsolete under XP and later)
HKMAX
};
// access mode for the key
enum AccessMode
{
Read, // read-only
Write // read and write
};
// Different registry views supported under WOW64.
enum WOW64ViewMode
{
// 32 bit registry for 32 bit applications, 64 bit registry
// for 64 bit ones.
WOW64ViewMode_Default,
// Can be used in 64 bit apps to access 32 bit registry,
// has no effect (i.e. treated as default) in 32 bit apps.
WOW64ViewMode_32,
// Can be used in 32 bit apps to access 64 bit registry,
// has no effect (i.e. treated as default) in 64 bit apps.
WOW64ViewMode_64
};
// information about standard (predefined) registry keys
// number of standard keys
static const size_t nStdKeys;
// get the name of a standard key
static const wxChar *GetStdKeyName(size_t key);
// get the short name of a standard key
static const wxChar *GetStdKeyShortName(size_t key);
// get StdKey from root HKEY
static StdKey GetStdKeyFromHkey(WXHKEY hkey);
// extracts the std key prefix from the string (return value) and
// leaves only the part after it (i.e. modifies the string passed!)
static StdKey ExtractKeyName(wxString& str);
// ctors
// root key is set to HKCR (the only root key under Win16)
wxRegKey(WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the full name of the key (i.e. starting with HKEY_xxx...)
wxRegKey(const wxString& strKey,
WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the name of key under (standard key) keyParent
wxRegKey(StdKey keyParent,
const wxString& strKey,
WOW64ViewMode viewMode = WOW64ViewMode_Default);
// strKey is the name of key under (previously created) keyParent
wxRegKey(const wxRegKey& keyParent, const wxString& strKey);
// dtor closes the key
~wxRegKey();
// change key (closes the previously opened key if any)
// the name is absolute, i.e. should start with HKEY_xxx
void SetName(const wxString& strKey);
// the name is relative to the parent key
void SetName(StdKey keyParent, const wxString& strKey);
// the name is relative to the parent key
void SetName(const wxRegKey& keyParent, const wxString& strKey);
// hKey should be opened and will be closed in wxRegKey dtor
void SetHkey(WXHKEY hKey);
// get information about the key
// get the (full) key name. Abbreviate std root keys if bShortPrefix.
wxString GetName(bool bShortPrefix = true) const;
// Retrieves the registry view used by this key.
WOW64ViewMode GetView() const { return m_viewMode; }
// return true if the key exists
bool Exists() const;
// get the info about key (any number of these pointers may be NULL)
bool GetKeyInfo(size_t *pnSubKeys, // number of subkeys
size_t *pnMaxKeyLen, // max length of subkey name
size_t *pnValues, // number of values
size_t *pnMaxValueLen) const;
// return true if the key is opened
bool IsOpened() const { return m_hKey != 0; }
// for "if ( !key ) wxLogError(...)" kind of expressions
operator bool() const { return m_dwLastError == 0; }
// operations on the key itself
// explicitly open the key (will be automatically done by all functions
// which need the key to be opened if the key is not opened yet)
bool Open(AccessMode mode = Write);
// create the key: will fail if the key already exists and !bOkIfExists
bool Create(bool bOkIfExists = true);
// rename a value from old name to new one
bool RenameValue(const wxString& szValueOld, const wxString& szValueNew);
// rename the key
bool Rename(const wxString& szNewName);
// copy value to another key possibly changing its name (by default it will
// remain the same)
bool CopyValue(const wxString& szValue, wxRegKey& keyDst,
const wxString& szNewName = wxEmptyString);
// copy the entire contents of the key recursively to another location
bool Copy(const wxString& szNewName);
// same as Copy() but using a key and not the name
bool Copy(wxRegKey& keyDst);
// close the key (will be automatically done in dtor)
bool Close();
// deleting keys/values
// deletes this key and all of it's subkeys/values
bool DeleteSelf();
// deletes the subkey with all of it's subkeys/values recursively
bool DeleteKey(const wxString& szKey);
// deletes the named value (may be empty string to remove the default value)
bool DeleteValue(const wxString& szValue);
// access to values and subkeys
// get value type
ValueType GetValueType(const wxString& szValue) const;
// returns true if the value contains a number (else it's some string)
bool IsNumericValue(const wxString& szValue) const;
// assignment operators set the default value of the key
wxRegKey& operator=(const wxString& strValue)
{ SetValue(wxEmptyString, strValue); return *this; }
// query the default value of the key: implicitly or explicitly
wxString QueryDefaultValue() const;
operator wxString() const { return QueryDefaultValue(); }
// named values
// set the string value
bool SetValue(const wxString& szValue, const wxString& strValue);
// retrieve the string value
bool QueryValue(const wxString& szValue, wxString& strValue) const
{ return QueryValue(szValue, strValue, false); }
// retrieve raw string value
bool QueryRawValue(const wxString& szValue, wxString& strValue) const
{ return QueryValue(szValue, strValue, true); }
// retrieve either raw or expanded string value
bool QueryValue(const wxString& szValue, wxString& strValue, bool raw) const;
// set the numeric value
bool SetValue(const wxString& szValue, long lValue);
// return the numeric value
bool QueryValue(const wxString& szValue, long *plValue) const;
// set the binary value
bool SetValue(const wxString& szValue, const wxMemoryBuffer& buf);
// return the binary value
bool QueryValue(const wxString& szValue, wxMemoryBuffer& buf) const;
// query existence of a key/value
// return true if value exists
bool HasValue(const wxString& szKey) const;
// return true if given subkey exists
bool HasSubKey(const wxString& szKey) const;
// return true if any subkeys exist
bool HasSubkeys() const;
// return true if any values exist
bool HasValues() const;
// return true if the key is empty (nothing under this key)
bool IsEmpty() const { return !HasSubkeys() && !HasValues(); }
// enumerate values and subkeys
bool GetFirstValue(wxString& strValueName, long& lIndex);
bool GetNextValue (wxString& strValueName, long& lIndex) const;
bool GetFirstKey (wxString& strKeyName , long& lIndex);
bool GetNextKey (wxString& strKeyName , long& lIndex) const;
// export the contents of this key and all its subkeys to the given file
// (which won't be overwritten, it's an error if it already exists)
//
// note that we export the key in REGEDIT4 format, not RegSaveKey() binary
// format nor newer REGEDIT5 one
bool Export(const wxString& filename) const;
// same as above but write to the given (opened) stream
bool Export(wxOutputStream& ostr) const;
// for wxRegConfig usage only: preallocate some memory for the name
void ReserveMemoryForName(size_t bytes) { m_strKey.reserve(bytes); }
private:
// common part of all ctors
void Init()
{
m_hKey = (WXHKEY) NULL;
m_dwLastError = 0;
}
// recursive helper for Export()
bool DoExport(wxOutputStream& ostr) const;
// export a single value
bool DoExportValue(wxOutputStream& ostr, const wxString& name) const;
// return the text representation (in REGEDIT4 format) of the value with the
// given name
wxString FormatValue(const wxString& name) const;
WXHKEY m_hKey, // our handle
m_hRootKey; // handle of the top key (i.e. StdKey)
wxString m_strKey; // key name (relative to m_hRootKey)
WOW64ViewMode m_viewMode; // which view to select under WOW64
AccessMode m_mode; // valid only if key is opened
long m_dwLastError; // last error (0 if none)
wxDECLARE_NO_COPY_CLASS(wxRegKey);
};
#endif // wxUSE_REGKEY
#endif // _WX_MSW_REGISTRY_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/statbmp.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/statbmp.h
// Purpose: wxStaticBitmap class for wxMSW
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_STATBMP_H_
#define _WX_STATBMP_H_
#include "wx/control.h"
#include "wx/icon.h"
#include "wx/bitmap.h"
extern WXDLLIMPEXP_DATA_CORE(const char) wxStaticBitmapNameStr[];
// a control showing an icon or a bitmap
class WXDLLIMPEXP_CORE wxStaticBitmap : public wxStaticBitmapBase
{
public:
wxStaticBitmap() { Init(); }
wxStaticBitmap(wxWindow *parent,
wxWindowID id,
const wxGDIImage& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr)
{
Init();
Create(parent, id, label, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxGDIImage& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxString& name = wxStaticBitmapNameStr);
virtual ~wxStaticBitmap() { Free(); }
virtual void SetIcon(const wxIcon& icon) wxOVERRIDE { SetImage(&icon); }
virtual void SetBitmap(const wxBitmap& bitmap) wxOVERRIDE { SetImage(&bitmap); }
virtual wxBitmap GetBitmap() const wxOVERRIDE;
virtual wxIcon GetIcon() const wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
// ctor/dtor helpers
void Init();
void Free();
// true if icon/bitmap is valid
bool ImageIsOk() const;
void SetImage(const wxGDIImage* image);
void SetImageNoCopy( wxGDIImage* image );
// draw the bitmap ourselves here if the OS can't do it correctly (if it
// can we leave it to it)
void DoPaintManually(wxPaintEvent& event);
void WXHandleSize(wxSizeEvent& event);
// we can have either an icon or a bitmap
bool m_isIcon;
wxGDIImage *m_image;
// handle used in last call to STM_SETIMAGE
WXHANDLE m_currentHandle;
private:
// Flag indicating whether we own m_currentHandle, i.e. should delete it.
bool m_ownsCurrentHandle;
// Replace the image at the native control level with the given HBITMAP or
// HICON (which can be 0) and destroy the previous image if necessary.
void MSWReplaceImageHandle(WXLPARAM handle);
// Delete the current handle only if we own it.
void DeleteCurrentHandleIfNeeded();
wxDECLARE_DYNAMIC_CLASS(wxStaticBitmap);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxStaticBitmap);
};
#endif
// _WX_STATBMP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/slider.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/slider.h
// Purpose: wxSlider class implementation using trackbar control
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SLIDER_H_
#define _WX_SLIDER_H_
class WXDLLIMPEXP_FWD_CORE wxSubwindows;
// Slider
class WXDLLIMPEXP_CORE wxSlider : public wxSliderBase
{
public:
wxSlider() { Init(); }
wxSlider(wxWindow *parent,
wxWindowID id,
int value,
int minValue,
int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr)
{
Init();
(void)Create(parent, id, value, minValue, maxValue,
pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
int value,
int minValue, int maxValue,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSL_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxSliderNameStr);
virtual ~wxSlider();
// slider methods
virtual int GetValue() const wxOVERRIDE;
virtual void SetValue(int) wxOVERRIDE;
void SetRange(int minValue, int maxValue) wxOVERRIDE;
int GetMin() const wxOVERRIDE { return m_rangeMin; }
int GetMax() const wxOVERRIDE { return m_rangeMax; }
// Win32-specific slider methods
int GetTickFreq() const wxOVERRIDE { return m_tickFreq; }
void SetPageSize(int pageSize) wxOVERRIDE;
int GetPageSize() const wxOVERRIDE;
void ClearSel() wxOVERRIDE;
void ClearTicks() wxOVERRIDE;
void SetLineSize(int lineSize) wxOVERRIDE;
int GetLineSize() const wxOVERRIDE;
int GetSelEnd() const wxOVERRIDE;
int GetSelStart() const wxOVERRIDE;
void SetSelection(int minPos, int maxPos) wxOVERRIDE;
void SetThumbLength(int len) wxOVERRIDE;
int GetThumbLength() const wxOVERRIDE;
void SetTick(int tickPos) wxOVERRIDE;
// implementation only from now on
WXHWND GetStaticMin() const;
WXHWND GetStaticMax() const;
WXHWND GetEditValue() const;
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE;
// we should let background show through the slider (and its labels)
virtual bool HasTransparentBackground() wxOVERRIDE { return true; }
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Enable(bool show = true) wxOVERRIDE;
virtual bool SetFont(const wxFont& font) wxOVERRIDE;
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& colour) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// format an integer value as string
static wxString Format(int n) { return wxString::Format(wxT("%d"), n); }
// get the boundig box for the slider and possible labels
wxRect GetBoundingBox() const;
// Get the height and, if the pointers are non NULL, widths of both labels.
//
// Notice that the return value will be 0 if we don't have wxSL_LABELS
// style but we do fill widthMin and widthMax even if we don't have
// wxSL_MIN_MAX_LABELS style set so the caller should account for it.
int GetLabelsSize(int *widthMin = NULL, int *widthMax = NULL) const;
// overridden base class virtuals
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
WXHBRUSH DoMSWControlColor(WXHDC pDC, wxColour colBg, WXHWND hWnd) wxOVERRIDE;
// the labels windows, if any
wxSubwindows *m_labels;
// Last background brush we returned from DoMSWControlColor(), see there.
WXHBRUSH m_hBrushBg;
int m_rangeMin;
int m_rangeMax;
int m_pageSize;
int m_lineSize;
int m_tickFreq;
// flag needed to detect whether we're getting THUMBRELEASE event because
// of dragging the thumb or scrolling the mouse wheel
bool m_isDragging;
// Platform-specific implementation of SetTickFreq
virtual void DoSetTickFreq(int freq) wxOVERRIDE;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxSlider);
};
#endif // _WX_SLIDER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/crashrpt.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/crashrpt.h
// Purpose: helpers for the structured exception handling (SEH) under Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 13.07.2003
// Copyright: (c) 2003 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CRASHRPT_H_
#define _WX_MSW_CRASHRPT_H_
#include "wx/defs.h"
#if wxUSE_CRASHREPORT
struct _EXCEPTION_POINTERS;
// ----------------------------------------------------------------------------
// crash report generation flags
// ----------------------------------------------------------------------------
enum
{
// we always report where the crash occurred
wxCRASH_REPORT_LOCATION = 0,
// if this flag is given, the call stack is dumped
//
// this results in dump/crash report as small as possible, this is the
// default flag
wxCRASH_REPORT_STACK = 1,
// if this flag is given, the values of the local variables are dumped
//
// note that with the current implementation it requires dumping the full
// process address space and so this will result in huge dump file and will
// take some time to generate
//
// it's probably not a good idea to use this by default, start with default
// mini dump and ask your users to set WX_CRASH_FLAGS environment variable
// to 2 or 4 if you need more information in the dump
wxCRASH_REPORT_LOCALS = 2,
// if this flag is given, the values of all global variables are dumped
//
// this creates a much larger mini dump than just wxCRASH_REPORT_STACK but
// still much smaller than wxCRASH_REPORT_LOCALS one
wxCRASH_REPORT_GLOBALS = 4,
// default is to create the smallest possible crash report
wxCRASH_REPORT_DEFAULT = wxCRASH_REPORT_LOCATION | wxCRASH_REPORT_STACK
};
// ----------------------------------------------------------------------------
// wxCrashContext: information about the crash context
// ----------------------------------------------------------------------------
struct WXDLLIMPEXP_BASE wxCrashContext
{
// initialize this object with the given information or from the current
// global exception info which is only valid inside wxApp::OnFatalException
wxCrashContext(_EXCEPTION_POINTERS *ep = NULL);
// get the name for this exception code
wxString GetExceptionString() const;
// exception code
size_t code;
// exception address
void *addr;
// machine-specific registers vaues
struct
{
#ifdef __INTEL__
wxInt32 eax, ebx, ecx, edx, esi, edi,
ebp, esp, eip,
cs, ds, es, fs, gs, ss,
flags;
#endif // __INTEL__
} regs;
};
// ----------------------------------------------------------------------------
// wxCrashReport: this class is used to create crash reports
// ----------------------------------------------------------------------------
struct WXDLLIMPEXP_BASE wxCrashReport
{
// set the name of the file to which the report is written, it is
// constructed from the .exe name by default
static void SetFileName(const wxString& filename);
// return the current file name
static wxString GetFileName();
// write the exception report to the file, return true if it could be done
// or false otherwise
//
// if ep pointer is NULL, the global exception info which is valid only
// inside wxApp::OnFatalException() is used
static bool Generate(int flags = wxCRASH_REPORT_DEFAULT,
_EXCEPTION_POINTERS *ep = NULL);
// generate a crash report from outside of wxApp::OnFatalException(), this
// can be used to take "snapshots" of the program in wxApp::OnAssert() for
// example
static bool GenerateNow(int flags = wxCRASH_REPORT_DEFAULT);
};
#endif // wxUSE_CRASHREPORT
#endif // _WX_MSW_CRASHRPT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/menuitem.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/menuitem.h
// Purpose: wxMenuItem class
// Author: Vadim Zeitlin
// Modified by:
// Created: 11.11.97
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _MENUITEM_H
#define _MENUITEM_H
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/bitmap.h"
#if wxUSE_OWNER_DRAWN
#include "wx/ownerdrw.h"
struct tagRECT;
#endif
// ----------------------------------------------------------------------------
// wxMenuItem: an item in the menu, optionally implements owner-drawn behaviour
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuItem : public wxMenuItemBase
#if wxUSE_OWNER_DRAWN
, public wxOwnerDrawn
#endif
{
public:
// ctor & dtor
wxMenuItem(wxMenu *parentMenu = NULL,
int id = wxID_SEPARATOR,
const wxString& name = wxEmptyString,
const wxString& help = wxEmptyString,
wxItemKind kind = wxITEM_NORMAL,
wxMenu *subMenu = NULL);
virtual ~wxMenuItem();
// override base class virtuals
virtual void SetItemLabel(const wxString& strName) wxOVERRIDE;
virtual void Enable(bool bDoEnable = true) wxOVERRIDE;
virtual void Check(bool bDoCheck = true) wxOVERRIDE;
virtual bool IsChecked() const wxOVERRIDE;
// unfortunately needed to resolve ambiguity between
// wxMenuItemBase::IsCheckable() and wxOwnerDrawn::IsCheckable()
bool IsCheckable() const { return wxMenuItemBase::IsCheckable(); }
// the id for a popup menu is really its menu handle (as required by
// ::AppendMenu() API), so this function will return either the id or the
// menu handle depending on what we are
//
// notice that it also returns the id as an unsigned int, as required by
// Win32 API
WXWPARAM GetMSWId() const;
#if WXWIN_COMPATIBILITY_2_8
// compatibility only, don't use in new code
wxDEPRECATED(
wxMenuItem(wxMenu *parentMenu,
int id,
const wxString& text,
const wxString& help,
bool isCheckable,
wxMenu *subMenu = NULL)
);
#endif
void SetBitmaps(const wxBitmap& bmpChecked,
const wxBitmap& bmpUnchecked = wxNullBitmap)
{
DoSetBitmap(bmpChecked, true);
DoSetBitmap(bmpUnchecked, false);
}
void SetBitmap(const wxBitmap& bmp, bool bChecked = true)
{
DoSetBitmap(bmp, bChecked);
}
const wxBitmap& GetBitmap(bool bChecked = true) const
{ return (bChecked ? m_bmpChecked : m_bmpUnchecked); }
#if wxUSE_OWNER_DRAWN
void SetDisabledBitmap(const wxBitmap& bmpDisabled)
{
m_bmpDisabled = bmpDisabled;
SetOwnerDrawn(true);
}
const wxBitmap& GetDisabledBitmap() const
{ return m_bmpDisabled; }
int MeasureAccelWidth() const;
// override wxOwnerDrawn base class virtuals
virtual wxString GetName() const wxOVERRIDE;
virtual bool OnMeasureItem(size_t *pwidth, size_t *pheight) wxOVERRIDE;
virtual bool OnDrawItem(wxDC& dc, const wxRect& rc, wxODAction act, wxODStatus stat) wxOVERRIDE;
protected:
virtual void GetFontToUse(wxFont& font) const wxOVERRIDE;
virtual void GetColourToUse(wxODStatus stat, wxColour& colText, wxColour& colBack) const wxOVERRIDE;
private:
// helper function for draw std menu check mark
void DrawStdCheckMark(WXHDC hdc, const tagRECT* rc, wxODStatus stat);
// helper function to determine if the item must be owner-drawn
bool MSWMustUseOwnerDrawn();
#endif // wxUSE_OWNER_DRAWN
enum BitmapKind
{
Normal,
Checked,
Unchecked
};
// helper function to get a handle for bitmap associated with item
WXHBITMAP GetHBitmapForMenu(BitmapKind kind) const;
// helper function to set/change the bitmap
void DoSetBitmap(const wxBitmap& bmp, bool bChecked);
private:
// common part of all ctors
void Init();
// Return the item position in the menu containing it.
//
// Returns -1 if the item is not attached to a menu or if we can't find its
// position (which is not really supposed to ever happen).
int MSGetMenuItemPos() const;
// item bitmaps
wxBitmap m_bmpChecked, // bitmap to put near the item
m_bmpUnchecked; // (checked is used also for 'uncheckable' items)
#if wxUSE_OWNER_DRAWN
wxBitmap m_bmpDisabled;
#endif // wxUSE_OWNER_DRAWN
// Give wxMenu access to our MSWMustUseOwnerDrawn() and GetHBitmapForMenu().
friend class wxMenu;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuItem);
};
#endif //_MENUITEM_H
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/ownerdrawnbutton.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ownerdrawnbutton.h
// Purpose: Common base class for wxCheckBox and wxRadioButton
// Author: Vadim Zeitlin
// Created: 2014-05-04
// Copyright: (c) 2014 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_OWNERDRAWNBUTTON_H_
#define _WX_MSW_OWNERDRAWNBUTTON_H_
// ----------------------------------------------------------------------------
// wxMSWOwnerDrawnButton: base class for any kind of Windows buttons
// ----------------------------------------------------------------------------
// This class contains the type-independent part of wxMSWOwnerDrawnButton and
// is implemented in src/msw/control.cpp.
//
// Notice that this class is internal implementation detail only and is
// intentionally not documented. Ideally it wouldn't be even exported from the
// DLL but this somehow breaks building of applications using wxWidgets with
// Intel compiler using LTCG, so we do export it.
class WXDLLIMPEXP_CORE wxMSWOwnerDrawnButtonBase
{
protected:
// Ctor takes the back pointer to the real window, must be non-NULL.
wxMSWOwnerDrawnButtonBase(wxWindow* win) :
m_win(win)
{
m_isPressed =
m_isHot = false;
}
// Explicitly define the destructor even if it's trivial to make it
// protected. This avoids compiler warnings about the fact that this class
// has virtual functions, but no virtual destructor without making the dtor
// virtual which is not needed here as objects are never deleted via
// pointers to this class (and protected dtor enforces this).
//
// Unfortunately g++ 3.4.5 still complains about the dtor being non virtual
// even if it is protected, but actually does not give any warnings if the
// dtor is not defined at all, so work around this 3.4.5 bug inside our
// general g++ workaround.
#if wxCHECK_GCC_VERSION(4, 0)
~wxMSWOwnerDrawnButtonBase() { }
#endif // g++ 4.0+
// Make the control owner drawn if necessary to implement support for the
// given foreground colour.
void MSWMakeOwnerDrawnIfNecessary(const wxColour& colFg);
// Return true if the control is currently owner drawn.
bool MSWIsOwnerDrawn() const;
// Draw the button if the message information about which is provided in
// the given DRAWITEMSTRUCT asks us to do it, otherwise just return false.
bool MSWDrawButton(WXDRAWITEMSTRUCT *item);
// Methods which must be overridden in the derived concrete class.
// Return the style to use for the non-owner-drawn button.
virtual int MSWGetButtonStyle() const = 0;
// Called after reverting button to non-owner drawn state, provides a hook
// for wxCheckBox-specific hack.
virtual void MSWOnButtonResetOwnerDrawn() { }
// Return the flags (such as wxCONTROL_CHECKED) to use for the control when
// drawing it. Notice that this class already takes care of the common
// logic and sets the other wxCONTROL_XXX flags on its own, this method
// really only needs to return the flags depending on the checked state.
virtual int MSWGetButtonCheckedFlag() const = 0;
// Actually draw the check or radio bitmap, typically just by using the
// appropriate wxRendererNative method.
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) = 0;
private:
// Make the control owner drawn or reset it to normal style.
void MSWMakeOwnerDrawn(bool ownerDrawn);
// Event handlers used to update the appearance of owner drawn button.
void OnMouseEnterOrLeave(wxMouseEvent& event);
void OnMouseLeft(wxMouseEvent& event);
void OnFocus(wxFocusEvent& event);
// The real window.
wxWindow* const m_win;
// true if the checkbox is currently pressed
bool m_isPressed;
// true if mouse is currently over the control
bool m_isHot;
wxDECLARE_NO_COPY_CLASS(wxMSWOwnerDrawnButtonBase);
};
// This class uses a weak version of CRTP, i.e. it's a template class taking
// the base class that the class deriving from it would normally derive from.
template <class T>
class wxMSWOwnerDrawnButton
: public T,
private wxMSWOwnerDrawnButtonBase
{
private:
typedef T Base;
public:
wxMSWOwnerDrawnButton() : wxMSWOwnerDrawnButtonBase(this)
{
}
virtual bool SetForegroundColour(const wxColour& colour) wxOVERRIDE
{
if ( !Base::SetForegroundColour(colour) )
return false;
MSWMakeOwnerDrawnIfNecessary(colour);
return true;
}
virtual bool MSWOnDraw(WXDRAWITEMSTRUCT *item) wxOVERRIDE
{
return MSWDrawButton(item) || Base::MSWOnDraw(item);
}
protected:
bool IsOwnerDrawn() const { return MSWIsOwnerDrawn(); }
};
#endif // _WX_MSW_OWNERDRAWNBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/panel.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/panel.h
// Purpose: wxMSW-specific wxPanel class.
// Author: Vadim Zeitlin
// Created: 2011-03-18
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_PANEL_H_
#define _WX_MSW_PANEL_H_
class WXDLLIMPEXP_FWD_CORE wxBrush;
// ----------------------------------------------------------------------------
// wxPanel
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxPanel : public wxPanelBase
{
public:
wxPanel() { }
wxPanel(wxWindow *parent,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, winid, pos, size, style, name);
}
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR(
wxPanel(wxWindow *parent,
int x, int y, int width, int height,
long style = wxTAB_TRAVERSAL | wxNO_BORDER,
const wxString& name = wxPanelNameStr)
{
Create(parent, wxID_ANY, wxPoint(x, y), wxSize(width, height), style, name);
}
)
#endif // WXWIN_COMPATIBILITY_2_8
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxPanel);
};
#endif // _WX_MSW_PANEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/calctrl.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/calctrl.h
// Purpose: wxCalendarCtrl control implementation for MSW
// Author: Vadim Zeitlin
// Copyright: (C) 2008 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CALCTRL_H_
#define _WX_MSW_CALCTRL_H_
class WXDLLIMPEXP_ADV wxCalendarCtrl : public wxCalendarCtrlBase
{
public:
wxCalendarCtrl() { Init(); }
wxCalendarCtrl(wxWindow *parent,
wxWindowID id,
const wxDateTime& date = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAL_SHOW_HOLIDAYS,
const wxString& name = wxCalendarNameStr)
{
Init();
Create(parent, id, date, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxDateTime& date = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxCAL_SHOW_HOLIDAYS,
const wxString& name = wxCalendarNameStr);
virtual bool SetDate(const wxDateTime& date) wxOVERRIDE;
virtual wxDateTime GetDate() const wxOVERRIDE;
virtual bool SetDateRange(const wxDateTime& lowerdate = wxDefaultDateTime,
const wxDateTime& upperdate = wxDefaultDateTime) wxOVERRIDE;
virtual bool GetDateRange(wxDateTime *lowerdate, wxDateTime *upperdate) const wxOVERRIDE;
virtual bool EnableMonthChange(bool enable = true) wxOVERRIDE;
virtual void Mark(size_t day, bool mark) wxOVERRIDE;
virtual void SetHoliday(size_t day) wxOVERRIDE;
virtual wxCalendarHitTestResult HitTest(const wxPoint& pos,
wxDateTime *date = NULL,
wxDateTime::WeekDay *wd = NULL) wxOVERRIDE;
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
void MSWOnClick(wxMouseEvent& event);
void MSWOnDoubleClick(wxMouseEvent& event);
private:
void Init();
// bring the control in sync with m_marks
void UpdateMarks();
// set first day of week in the control to correspond to our
// wxCAL_MONDAY_FIRST flag
void UpdateFirstDayOfWeek();
// reset holiday information
virtual void ResetHolidayAttrs() wxOVERRIDE { m_holidays = 0; }
// redisplay holidays
virtual void RefreshHolidays() wxOVERRIDE { UpdateMarks(); }
// current date, we need to store it instead of simply retrieving it from
// the control as needed in order to be able to generate the correct events
// from MSWOnNotify()
wxDateTime m_date;
// bit field containing the state (marked or not) of all days in the month
wxUint32 m_marks;
// the same but indicating whether a day is a holiday or not
wxUint32 m_holidays;
wxDECLARE_DYNAMIC_CLASS(wxCalendarCtrl);
wxDECLARE_NO_COPY_CLASS(wxCalendarCtrl);
};
#endif // _WX_MSW_CALCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/wrapcdlg.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wrapcdlg.h
// Purpose: Wrapper for the standard <commdlg.h> header
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 22.03.2005
// Copyright: (c) 2005 Wlodzimierz Skiba
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WRAPCDLG_H_
#define _WX_MSW_WRAPCDLG_H_
#include "wx/defs.h"
#include "wx/msw/wrapwin.h"
#include "wx/msw/private.h"
#include "wx/msw/missing.h"
#if wxUSE_COMMON_DIALOGS
#include <commdlg.h>
#endif
#include "wx/msw/winundef.h"
#endif // _WX_MSW_WRAPCDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/toolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/toolbar.h
// Purpose: wxToolBar class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TBAR95_H_
#define _WX_MSW_TBAR95_H_
#if wxUSE_TOOLBAR
#include "wx/dynarray.h"
#include "wx/imaglist.h"
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
// ctors and dtor
wxToolBar() { Init(); }
wxToolBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr)
{
Init();
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr);
virtual ~wxToolBar();
// override/implement base class virtuals
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual bool Realize() wxOVERRIDE;
virtual void SetToolBitmapSize(const wxSize& size) wxOVERRIDE;
virtual wxSize GetToolSize() const wxOVERRIDE;
virtual void SetRows(int nRows) wxOVERRIDE;
virtual void SetToolNormalBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolDisabledBitmap(int id, const wxBitmap& bitmap) wxOVERRIDE;
virtual void SetToolPacking(int packing) wxOVERRIDE;
// implementation only from now on
// -------------------------------
virtual void SetWindowStyleFlag(long style) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
void OnMouseEvent(wxMouseEvent& event);
void OnSysColourChanged(wxSysColourChangedEvent& event);
void OnEraseBackground(wxEraseEvent& event);
void SetFocus() wxOVERRIDE {}
static WXHBITMAP MapBitmap(WXHBITMAP bitmap, int width, int height);
// override WndProc mainly to process WM_SIZE
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
virtual bool MSWEraseBgHook(WXHDC hDC) wxOVERRIDE;
virtual WXHBRUSH MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child) wxOVERRIDE;
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled = wxNullBitmap,
wxItemKind kind = wxITEM_NORMAL,
wxObject *clientData = NULL,
const wxString& shortHelp = wxEmptyString,
const wxString& longHelp = wxEmptyString) wxOVERRIDE;
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label) wxOVERRIDE;
protected:
// common part of all ctors
void Init();
// create the native toolbar control
bool MSWCreateToolbar(const wxPoint& pos, const wxSize& size);
// recreate the control completely
void Recreate();
// implement base class pure virtuals
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool) wxOVERRIDE;
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) wxOVERRIDE;
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) wxOVERRIDE;
// return the appropriate size and flags for the toolbar control
virtual wxSize DoGetBestSize() const wxOVERRIDE;
// handlers for various events
bool HandleSize(WXWPARAM wParam, WXLPARAM lParam);
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
bool HandlePaint(WXWPARAM wParam, WXLPARAM lParam);
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
void HandleMouseMove(WXWPARAM wParam, WXLPARAM lParam);
// should be called whenever the toolbar size changes
void UpdateSize();
// create m_disabledImgList (but doesn't fill it), set it to NULL if it is
// unneeded
void CreateDisabledImageList();
// get the Windows toolbar style of this control
long GetMSWToolbarStyle() const;
// set native toolbar padding
void MSWSetPadding(WXWORD padding);
// the big bitmap containing all bitmaps of the toolbar buttons
WXHBITMAP m_hBitmap;
// the image list with disabled images, may be NULL if we use
// system-provided versions of them
wxImageList *m_disabledImgList;
// the total number of toolbar elements
size_t m_nButtons;
// the sum of the sizes of the fixed items (i.e. excluding stretchable
// spaces) in the toolbar direction
int m_totalFixedSize;
// the tool the cursor is in
wxToolBarToolBase *m_pInTool;
private:
// makes sure tool bitmap size is sufficient for all tools
void AdjustToolBitmapSize();
// update the sizes of stretchable spacers to consume all extra space we
// have
void UpdateStretchableSpacersSize();
#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
// do erase the toolbar background, always do it for the entire control as
// the caller sets the clipping region correctly to exclude parts which
// should not be erased
void MSWDoEraseBackground(WXHDC hDC);
// return the brush to use for erasing the toolbar background
WXHBRUSH MSWGetToolbarBgBrush();
#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
wxDECLARE_NO_COPY_CLASS(wxToolBar);
};
#endif // wxUSE_TOOLBAR
#endif // _WX_MSW_TBAR95_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/helpchm.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/helpchm.h
// Purpose: Help system: MS HTML Help implementation
// Author: Julian Smart
// Modified by:
// Created: 16/04/2000
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_HELPCHM_H_
#define _WX_MSW_HELPCHM_H_
#if wxUSE_MS_HTML_HELP
#include "wx/helpbase.h"
class WXDLLIMPEXP_CORE wxCHMHelpController : public wxHelpControllerBase
{
public:
wxCHMHelpController(wxWindow* parentWindow = NULL): wxHelpControllerBase(parentWindow) { }
// Must call this to set the filename
virtual bool Initialize(const wxString& file) wxOVERRIDE;
virtual bool Initialize(const wxString& file, int WXUNUSED(server) ) wxOVERRIDE { return Initialize( file ); }
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString) wxOVERRIDE;
virtual bool DisplayContents() wxOVERRIDE;
virtual bool DisplaySection(int sectionNo) wxOVERRIDE;
virtual bool DisplaySection(const wxString& section) wxOVERRIDE;
virtual bool DisplayBlock(long blockNo) wxOVERRIDE;
virtual bool DisplayContextPopup(int contextId) wxOVERRIDE;
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos) wxOVERRIDE;
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL) wxOVERRIDE;
virtual bool Quit() wxOVERRIDE;
wxString GetHelpFile() const { return m_helpFile; }
// helper of DisplayTextPopup(), also used in wxSimpleHelpProvider::ShowHelp
static bool ShowContextHelpPopup(const wxString& text,
const wxPoint& pos,
wxWindow *window);
protected:
// get the name of the CHM file we use from our m_helpFile
wxString GetValidFilename() const;
// Call HtmlHelp() with the provided parameters (both overloads do the same
// thing but allow to avoid casts in the calling code) and return false
// (but don't crash) if HTML help is unavailable
static bool CallHtmlHelp(wxWindow *win, const wxChar *str,
unsigned cmd, WXWPARAM param);
static bool CallHtmlHelp(wxWindow *win, const wxChar *str,
unsigned cmd, const void *param = NULL)
{
return CallHtmlHelp(win, str, cmd, reinterpret_cast<WXWPARAM>(param));
}
// even simpler wrappers using GetParentWindow() and GetValidFilename() as
// the first 2 HtmlHelp() parameters
bool CallHtmlHelp(unsigned cmd, WXWPARAM param)
{
return CallHtmlHelp(GetParentWindow(), GetValidFilename().t_str(),
cmd, param);
}
bool CallHtmlHelp(unsigned cmd, const void *param = NULL)
{
return CallHtmlHelp(cmd, reinterpret_cast<WXWPARAM>(param));
}
// wrapper around CallHtmlHelp(HH_DISPLAY_TEXT_POPUP): only one of text and
// contextId parameters can be non-NULL/non-zero
static bool DoDisplayTextPopup(const wxChar *text,
const wxPoint& pos,
int contextId,
wxWindow *window);
wxString m_helpFile;
wxDECLARE_DYNAMIC_CLASS(wxCHMHelpController);
};
#endif // wxUSE_MS_HTML_HELP
#endif // _WX_MSW_HELPCHM_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/gauge.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/gauge.h
// Purpose: wxGauge implementation for MSW
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_GAUGE_H_
#define _WX_MSW_GAUGE_H_
#if wxUSE_GAUGE
extern WXDLLIMPEXP_DATA_CORE(const char) wxGaugeNameStr[];
// Group box
class WXDLLIMPEXP_CORE wxGauge : public wxGaugeBase
{
public:
wxGauge() { }
wxGauge(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr)
{
(void)Create(parent, id, range, pos, size, style, validator, name);
}
virtual ~wxGauge();
bool Create(wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxGA_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxGaugeNameStr);
// set gauge range/value
virtual void SetRange(int range) wxOVERRIDE;
virtual void SetValue(int pos) wxOVERRIDE;
// overridden base class virtuals
virtual bool SetForegroundColour(const wxColour& col) wxOVERRIDE;
virtual bool SetBackgroundColour(const wxColour& col) wxOVERRIDE;
virtual void Pulse() wxOVERRIDE;
WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
private:
// returns true if the control is currently in indeterminate (a.k.a.
// "marquee") mode
bool IsInIndeterminateMode() const;
// switch to/from indeterminate mode
void SetIndeterminateMode();
void SetDeterminateMode();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxGauge);
};
#endif // wxUSE_GAUGE
#endif // _WX_MSW_GAUGE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/spinctrl.h | ////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/spinctrl.h
// Purpose: wxSpinCtrl class declaration for Win32
// Author: Vadim Zeitlin
// Modified by:
// Created: 22.07.99
// Copyright: (c) Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_SPINCTRL_H_
#define _WX_MSW_SPINCTRL_H_
#include "wx/spinbutt.h" // the base class
#if wxUSE_SPINCTRL
#include "wx/dynarray.h"
class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
WX_DEFINE_EXPORTED_ARRAY_PTR(wxSpinCtrl *, wxArraySpins);
// ----------------------------------------------------------------------------
// Under Win32, wxSpinCtrl is a wxSpinButton with a buddy (as MSDN docs call
// it) text window whose contents is automatically updated when the spin
// control is clicked.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSpinCtrl : public wxSpinButton
{
public:
wxSpinCtrl() { Init(); }
wxSpinCtrl(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
int min = 0, int max = 100, int initial = 0,
const wxString& name = wxT("wxSpinCtrl"))
{
Init();
Create(parent, id, value, pos, size, style, min, max, initial, name);
}
bool Create(wxWindow *parent,
wxWindowID id = wxID_ANY,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSP_ARROW_KEYS,
int min = 0, int max = 100, int initial = 0,
const wxString& name = wxT("wxSpinCtrl"));
// a wxTextCtrl-like method (but we can't have GetValue returning wxString
// because the base class already has one returning int!)
void SetValue(const wxString& text);
// another wxTextCtrl-like method
void SetSelection(long from, long to);
// wxSpinCtrlBase methods
virtual int GetBase() const;
virtual bool SetBase(int base);
// implementation only from now on
// -------------------------------
virtual ~wxSpinCtrl();
virtual void SetValue(int val) wxOVERRIDE;
virtual int GetValue() const wxOVERRIDE;
virtual void SetRange(int minVal, int maxVal) wxOVERRIDE;
virtual bool SetFont(const wxFont &font) wxOVERRIDE;
virtual void SetFocus() wxOVERRIDE;
virtual bool Enable(bool enable = true) wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
virtual bool Reparent(wxWindowBase *newParent) wxOVERRIDE;
// wxSpinButton doesn't accept focus, but we do
virtual bool AcceptsFocus() const wxOVERRIDE { return wxWindow::AcceptsFocus(); }
// we're like wxTextCtrl and not (default) wxButton
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL)
{
return GetCompositeControlsDefaultAttributes(variant);
}
// for internal use only
// get the subclassed window proc of the buddy text
WXWNDPROC GetBuddyWndProc() const { return m_wndProcBuddy; }
// return the spinctrl object whose buddy is the given window or NULL
static wxSpinCtrl *GetSpinForTextCtrl(WXHWND hwndBuddy);
// process a WM_COMMAND generated by the buddy text control
bool ProcessTextCommand(WXWORD cmd, WXWORD id);
// recognize buddy window as part of this control at wx level
virtual bool ContainsHWND(WXHWND hWnd) const wxOVERRIDE { return hWnd == m_hwndBuddy; }
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
protected:
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
virtual void DoGetSize(int *width, int *height) const wxOVERRIDE;
virtual void DoGetClientSize(int *x, int *y) const wxOVERRIDE;
#if wxUSE_TOOLTIPS
virtual void DoSetToolTip( wxToolTip *tip ) wxOVERRIDE;
#endif // wxUSE_TOOLTIPS
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
// handle processing of special keys
void OnChar(wxKeyEvent& event);
void OnSetFocus(wxFocusEvent& event);
void OnKillFocus(wxFocusEvent& event);
// generate spin control update event with the given value
void SendSpinUpdate(int value);
// called to ensure that the value is in the correct range
virtual void NormalizeValue() wxOVERRIDE;
// the value of the control before the latest change (which might not have
// changed anything in fact -- this is why we need this field)
int m_oldValue;
// the data for the "buddy" text ctrl
WXHWND m_hwndBuddy;
WXWNDPROC m_wndProcBuddy;
// Block text update event after SetValue()
bool m_blockEvent;
private:
// Common part of all ctors.
void Init();
// Adjust the text control style depending on whether we need to enter only
// digits or may need to enter something else (e.g. "-" sign, "x"
// hexadecimal prefix, ...) in it.
void UpdateBuddyStyle();
// Determine the (horizontal) pixel overlap between the spin button
// (up-down control) and the text control (buddy window).
int GetOverlap() const;
wxDECLARE_DYNAMIC_CLASS(wxSpinCtrl);
wxDECLARE_EVENT_TABLE();
wxDECLARE_NO_COPY_CLASS(wxSpinCtrl);
};
#endif // wxUSE_SPINCTRL
#endif // _WX_MSW_SPINCTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/region.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/region.h
// Purpose: wxRegion class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) 1997-2002 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_REGION_H_
#define _WX_MSW_REGION_H_
class WXDLLIMPEXP_CORE wxRegion : public wxRegionWithCombine
{
public:
wxRegion();
wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
wxRegion(const wxRect& rect);
wxRegion(WXHRGN hRegion); // Hangs on to this region
wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
#if wxUSE_IMAGE
wxRegion( const wxBitmap& bmp)
{
Union(bmp);
}
wxRegion( const wxBitmap& bmp,
const wxColour& transColour, int tolerance = 0)
{
Union(bmp, transColour, tolerance);
}
#endif // wxUSE_IMAGE
virtual ~wxRegion();
// wxRegionBase methods
virtual void Clear() wxOVERRIDE;
virtual bool IsEmpty() const wxOVERRIDE;
// Get internal region handle
WXHRGN GetHRGN() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
virtual bool DoIsEqual(const wxRegion& region) const wxOVERRIDE;
virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const wxOVERRIDE;
virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const wxOVERRIDE;
virtual wxRegionContain DoContainsRect(const wxRect& rect) const wxOVERRIDE;
virtual bool DoOffset(wxCoord x, wxCoord y) wxOVERRIDE;
virtual bool DoCombine(const wxRegion& region, wxRegionOp op) wxOVERRIDE;
friend class WXDLLIMPEXP_FWD_CORE wxRegionIterator;
wxDECLARE_DYNAMIC_CLASS(wxRegion);
};
class WXDLLIMPEXP_CORE wxRegionIterator : public wxObject
{
public:
wxRegionIterator() { Init(); }
wxRegionIterator(const wxRegion& region);
wxRegionIterator(const wxRegionIterator& ri) : wxObject(ri) { Init(); *this = ri; }
wxRegionIterator& operator=(const wxRegionIterator& ri);
virtual ~wxRegionIterator();
void Reset() { m_current = 0; }
void Reset(const wxRegion& region);
bool HaveRects() const { return (m_current < m_numRects); }
operator bool () const { return HaveRects(); }
wxRegionIterator& operator++();
wxRegionIterator operator++(int);
wxCoord GetX() const;
wxCoord GetY() const;
wxCoord GetW() const;
wxCoord GetWidth() const { return GetW(); }
wxCoord GetH() const;
wxCoord GetHeight() const { return GetH(); }
wxRect GetRect() const { return wxRect(GetX(), GetY(), GetW(), GetH()); }
private:
// common part of all ctors
void Init();
long m_current;
long m_numRects;
wxRegion m_region;
wxRect* m_rects;
wxDECLARE_DYNAMIC_CLASS(wxRegionIterator);
};
#endif // _WX_MSW_REGION_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/init.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/init.h
// Purpose: Windows-specific wxEntry() overload
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_INIT_H_
#define _WX_MSW_INIT_H_
// ----------------------------------------------------------------------------
// Windows-specific wxEntry() overload and wxIMPLEMENT_WXWIN_MAIN definition
// ----------------------------------------------------------------------------
// wxEntry() overload using the command line for the current process, instead
// of argc/argv provided by the CRT. This is only really useful when using
// Unicode with a compiler not providing wmain() or similar entry point, but is
// always provided for consistency.
extern int WXDLLIMPEXP_BASE wxEntry();
#if wxUSE_GUI
// we need HINSTANCE declaration to define WinMain()
#include "wx/msw/wrapwin.h"
#ifndef SW_SHOWNORMAL
#define SW_SHOWNORMAL 1
#endif
// WinMain() is always ANSI, even in Unicode build.
typedef char *wxCmdLineArgType;
// Windows-only overloads of wxEntry() and wxEntryStart() which take the
// parameters passed to WinMain() instead of those passed to main()
extern WXDLLIMPEXP_CORE bool
wxEntryStart(HINSTANCE hInstance,
HINSTANCE hPrevInstance = NULL,
wxCmdLineArgType pCmdLine = NULL,
int nCmdShow = SW_SHOWNORMAL);
extern WXDLLIMPEXP_CORE int
wxEntry(HINSTANCE hInstance,
HINSTANCE hPrevInstance = NULL,
wxCmdLineArgType pCmdLine = NULL,
int nCmdShow = SW_SHOWNORMAL);
#if defined(__BORLANDC__) && wxUSE_UNICODE
// Borland C++ has the following nonstandard behaviour: when the -WU
// command line flag is used, the linker expects to find wWinMain instead
// of WinMain. This flag causes the compiler to define _UNICODE and
// UNICODE symbols and there's no way to detect its use, so we have to
// define both WinMain and wWinMain so that wxIMPLEMENT_WXWIN_MAIN works
// for both code compiled with and without -WU.
// See http://sourceforge.net/tracker/?func=detail&atid=309863&aid=1935997&group_id=9863
// for more details.
#define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD \
extern "C" int WINAPI wWinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \
wchar_t * WXUNUSED(lpCmdLine), \
int nCmdShow) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
\
/* NB: wxEntry expects lpCmdLine argument to be char*, not */ \
/* wchar_t*, but fortunately it's not used anywhere */ \
/* and we can simply pass NULL in: */ \
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
}
#else
#define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // defined(__BORLANDC__) && wxUSE_UNICODE
#define wxIMPLEMENT_WXWIN_MAIN \
extern "C" int WINAPI WinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \
wxCmdLineArgType WXUNUSED(lpCmdLine), \
int nCmdShow) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
\
/* NB: We pass NULL in place of lpCmdLine to behave the same as */ \
/* Borland-specific wWinMain() above. If it becomes needed */ \
/* to pass lpCmdLine to wxEntry() here, you'll have to fix */ \
/* wWinMain() above too. */ \
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
} \
wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // wxUSE_GUI
#endif // _WX_MSW_INIT_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/datectrl.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/datectrl.h
// Purpose: wxDatePickerCtrl for Windows
// Author: Vadim Zeitlin
// Modified by:
// Created: 2005-01-09
// Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DATECTRL_H_
#define _WX_MSW_DATECTRL_H_
// ----------------------------------------------------------------------------
// wxDatePickerCtrl
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_ADV wxDatePickerCtrl : public wxDatePickerCtrlBase
{
public:
// ctors
wxDatePickerCtrl() { }
wxDatePickerCtrl(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDP_DEFAULT | wxDP_SHOWCENTURY,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxDatePickerCtrlNameStr)
{
Create(parent, id, dt, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxDateTime& dt = wxDefaultDateTime,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDP_DEFAULT | wxDP_SHOWCENTURY,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxDatePickerCtrlNameStr);
// Override this one to add date-specific (and time-ignoring) checks.
virtual void SetValue(const wxDateTime& dt) wxOVERRIDE;
virtual wxDateTime GetValue() const wxOVERRIDE;
// Implement the base class pure virtuals.
virtual void SetRange(const wxDateTime& dt1, const wxDateTime& dt2) wxOVERRIDE;
virtual bool GetRange(wxDateTime *dt1, wxDateTime *dt2) const wxOVERRIDE;
// Override MSW-specific functions used during control creation.
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
#if wxUSE_INTL
virtual wxLocaleInfo MSWGetFormat() const wxOVERRIDE;
#endif // wxUSE_INTL
virtual bool MSWAllowsNone() const wxOVERRIDE { return HasFlag(wxDP_ALLOWNONE); }
virtual bool MSWOnDateTimeChange(const tagNMDATETIMECHANGE& dtch) wxOVERRIDE;
private:
wxDateTime MSWGetControlValue() const;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDatePickerCtrl);
};
#endif // _WX_MSW_DATECTRL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/winver.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/winver.h
// Purpose: Define Windows version macros if they're not predefined.
// Author: Vadim Zeitlin
// Created: 2017-01-13 (extracted from wx/msw/wrapwin.h)
// Copyright: (c) 2017 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WINVER_H_
#define _WX_MSW_WINVER_H_
// Notice that this header must not include any other wx headers as it's
// indirectly included from wx/defs.h itself when using gcc (via wx/platform.h,
// then wx/compiler.h and wx/msw/gccpriv.h).
// Define WINVER, _WIN32_WINNT and _WIN32_IE to the highest possible values
// because we always check for the version of installed DLLs at runtime anyway
// (see wxGetWinVersion() and wxApp::GetComCtl32Version()) unless the user
// really doesn't want to use APIs only available on later OS versions and had
// defined them to (presumably lower) values -- or, alternatively, wants to use
// even higher version of the API which will become available later.
#ifndef WINVER
#define WINVER 0x0A00
#endif
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0A00
#endif
#ifndef _WIN32_IE
#define _WIN32_IE 0x0A00
#endif
#endif // _WX_MSW_WINVER_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/evtloop.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/evtloop.h
// Purpose: wxEventLoop class for wxMSW port
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-07-31
// Copyright: (c) 2003-2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_EVTLOOP_H_
#define _WX_MSW_EVTLOOP_H_
#include "wx/dynarray.h"
#include "wx/msw/wrapwin.h"
#include "wx/window.h"
#include "wx/msw/evtloopconsole.h" // for wxMSWEventLoopBase
// ----------------------------------------------------------------------------
// wxEventLoop
// ----------------------------------------------------------------------------
WX_DECLARE_EXPORTED_OBJARRAY(MSG, wxMSGArray);
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxMSWEventLoopBase
{
public:
wxGUIEventLoop() { }
// process a single message: calls PreProcessMessage() before dispatching
// it
virtual void ProcessMessage(WXMSG *msg);
// preprocess a message, return true if processed (i.e. no further
// dispatching required)
virtual bool PreProcessMessage(WXMSG *msg);
// set the critical window: this is the window such that all the events
// except those to this window (and its children) stop to be processed
// (typical examples: assert or crash report dialog)
//
// calling this function with NULL argument restores the normal event
// handling
static void SetCriticalWindow(wxWindowMSW *win) { ms_winCritical = win; }
// return true if there is no critical window or if this window is [a child
// of] the critical one
static bool AllowProcessing(wxWindowMSW *win)
{
return !ms_winCritical || IsChildOfCriticalWindow(win);
}
// override/implement base class virtuals
virtual bool Dispatch() wxOVERRIDE;
virtual int DispatchTimeout(unsigned long timeout) wxOVERRIDE;
protected:
virtual void OnNextIteration() wxOVERRIDE;
virtual void DoYieldFor(long eventsToProcess) wxOVERRIDE;
private:
// check if the given window is a child of ms_winCritical (which must be
// non NULL)
static bool IsChildOfCriticalWindow(wxWindowMSW *win);
// array of messages used for temporary storage by YieldFor()
wxMSGArray m_arrMSG;
// critical window or NULL
static wxWindowMSW *ms_winCritical;
};
#endif // _WX_MSW_EVTLOOP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/palette.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/palette.h
// Purpose: wxPalette class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PALETTE_H_
#define _WX_PALETTE_H_
#include "wx/gdiobj.h"
class WXDLLIMPEXP_CORE wxPalette : public wxPaletteBase
{
public:
wxPalette() { }
wxPalette(int n,
const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
Create(n, red, green, blue);
}
bool Create(int n,
const unsigned char *red, const unsigned char *green, const unsigned char *blue);
virtual int GetColoursCount() const wxOVERRIDE;
int
GetPixel(unsigned char red, unsigned char green, unsigned char blue) const;
bool
GetRGB(int pixel,
unsigned char *red, unsigned char *green, unsigned char *blue) const;
// implementation
WXHPALETTE GetHPALETTE() const;
void SetHPALETTE(WXHPALETTE pal);
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS(wxPalette);
};
#endif // _WX_PALETTE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/menu.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/menu.h
// Purpose: wxMenu, wxMenuBar classes
// Author: Julian Smart
// Modified by: Vadim Zeitlin (wxMenuItem is now in separate file)
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MENU_H_
#define _WX_MENU_H_
#if wxUSE_ACCEL
#include "wx/accel.h"
#include "wx/dynarray.h"
WX_DEFINE_EXPORTED_ARRAY_PTR(wxAcceleratorEntry *, wxAcceleratorArray);
#endif // wxUSE_ACCEL
class WXDLLIMPEXP_FWD_CORE wxFrame;
class wxMenuRadioItemsData;
#include "wx/arrstr.h"
// ----------------------------------------------------------------------------
// Menu
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenu : public wxMenuBase
{
public:
// ctors & dtor
wxMenu(const wxString& title, long style = 0)
: wxMenuBase(title, style) { Init(); }
wxMenu(long style = 0) : wxMenuBase(style) { Init(); }
virtual ~wxMenu();
virtual void Break() wxOVERRIDE;
virtual void SetTitle(const wxString& title) wxOVERRIDE;
// MSW-only methods
// ----------------
// Create a new menu from the given native HMENU. Takes ownership of the
// menu handle and will delete it when this object is destroyed.
static wxMenu *MSWNewFromHMENU(WXHMENU hMenu) { return new wxMenu(hMenu); }
// Detaches HMENU so that it isn't deleted when this object is destroyed.
// Don't use this object after calling this method.
WXHMENU MSWDetachHMENU() { WXHMENU m = m_hMenu; m_hMenu = NULL; return m; }
// implementation only from now on
// -------------------------------
bool MSWCommand(WXUINT param, WXWORD id);
// get the native menu handle
WXHMENU GetHMenu() const { return m_hMenu; }
// Return the start and end position of the radio group to which the item
// at the given position belongs. Returns false if there is no radio group
// containing this position.
bool MSWGetRadioGroupRange(int pos, int *start, int *end) const;
#if wxUSE_ACCEL
// called by wxMenuBar to build its accel table from the accels of all menus
bool HasAccels() const { return !m_accels.empty(); }
size_t GetAccelCount() const { return m_accels.size(); }
size_t CopyAccels(wxAcceleratorEntry *accels) const;
// called by wxMenuItem when its accels changes
void UpdateAccel(wxMenuItem *item);
void RemoveAccel(wxMenuItem *item);
// helper used by wxMenu itself (returns the index in m_accels)
int FindAccel(int id) const;
// used only by wxMDIParentFrame currently but could be useful elsewhere:
// returns a new accelerator table with accelerators for just this menu
// (shouldn't be called if we don't have any accelerators)
wxAcceleratorTable *CreateAccelTable() const;
#endif // wxUSE_ACCEL
// get the menu with given handle (recursively)
wxMenu* MSWGetMenu(WXHMENU hMenu);
#if wxUSE_OWNER_DRAWN
int GetMaxAccelWidth()
{
if (m_maxAccelWidth == -1)
CalculateMaxAccelWidth();
return m_maxAccelWidth;
}
void ResetMaxAccelWidth()
{
m_maxAccelWidth = -1;
}
private:
void CalculateMaxAccelWidth();
#endif // wxUSE_OWNER_DRAWN
protected:
virtual wxMenuItem* DoAppend(wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoInsert(size_t pos, wxMenuItem *item) wxOVERRIDE;
virtual wxMenuItem* DoRemove(wxMenuItem *item) wxOVERRIDE;
private:
// This constructor is private, use MSWNewFromHMENU() to use it.
wxMenu(WXHMENU hMenu);
// Common part of all ctors, it doesn't create a new HMENU.
void InitNoCreate();
// Common part of all ctors except of the one above taking a native menu
// handler: calls InitNoCreate() and also creates a new menu.
void Init();
// common part of Append/Insert (behaves as Append is pos == (size_t)-1)
bool DoInsertOrAppend(wxMenuItem *item, size_t pos = (size_t)-1);
// This variable contains the description of the radio item groups and
// allows to find whether an item at the given position is part of the
// group and also where its group starts and ends.
//
// It is initially NULL and only allocated if we have any radio items.
wxMenuRadioItemsData *m_radioData;
// if true, insert a breal before appending the next item
bool m_doBreak;
// the menu handle of this menu
WXHMENU m_hMenu;
#if wxUSE_ACCEL
// the accelerators for our menu items
wxAcceleratorArray m_accels;
#endif // wxUSE_ACCEL
#if wxUSE_OWNER_DRAWN
// true if the menu has any ownerdrawn items
bool m_ownerDrawn;
// the max width of menu items bitmaps
int m_maxBitmapWidth;
// the max width of menu items accels
int m_maxAccelWidth;
#endif // wxUSE_OWNER_DRAWN
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenu);
};
// ----------------------------------------------------------------------------
// Menu Bar (a la Windows)
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMenuBar : public wxMenuBarBase
{
public:
// ctors & dtor
// default constructor
wxMenuBar();
// unused under MSW
wxMenuBar(long style);
// menubar takes ownership of the menus arrays but copies the titles
wxMenuBar(size_t n, wxMenu *menus[], const wxString titles[], long style = 0);
virtual ~wxMenuBar();
// menubar construction
virtual bool Append( wxMenu *menu, const wxString &title ) wxOVERRIDE;
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title) wxOVERRIDE;
virtual wxMenu *Remove(size_t pos) wxOVERRIDE;
virtual void EnableTop( size_t pos, bool flag ) wxOVERRIDE;
virtual bool IsEnabledTop(size_t pos) const wxOVERRIDE;
virtual void SetMenuLabel( size_t pos, const wxString& label ) wxOVERRIDE;
virtual wxString GetMenuLabel( size_t pos ) const wxOVERRIDE;
// implementation from now on
WXHMENU Create();
virtual void Detach() wxOVERRIDE;
virtual void Attach(wxFrame *frame) wxOVERRIDE;
#if wxUSE_ACCEL
// update the accel table (must be called after adding/deleting a menu)
void RebuildAccelTable();
#endif // wxUSE_ACCEL
// get the menu handle
WXHMENU GetHMenu() const { return m_hMenu; }
// if the menubar is modified, the display is not updated automatically,
// call this function to update it (m_menuBarFrame should be !NULL)
void Refresh();
// To avoid compile warning
void Refresh( bool eraseBackground,
const wxRect *rect = (const wxRect *) NULL ) wxOVERRIDE { wxWindow::Refresh(eraseBackground, rect); }
// Get a top level menu position or wxNOT_FOUND from its handle.
int MSWGetTopMenuPos(WXHMENU hMenu) const;
// Get a top level or sub menu with given handle (recursively).
wxMenu* MSWGetMenu(WXHMENU hMenu) const;
protected:
// common part of all ctors
void Init();
WXHMENU m_hMenu;
// Return the MSW position for a wxMenu which is sometimes different from
// the wxWidgets position.
int MSWPositionForWxMenu(wxMenu *menu, int wxpos);
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuBar);
};
#endif // _WX_MENU_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/colour.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/colour.h
// Purpose: wxColour class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COLOUR_H_
#define _WX_COLOUR_H_
#include "wx/object.h"
// ----------------------------------------------------------------------------
// Colour
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxColour : public wxColourBase
{
public:
// constructors
// ------------
DEFINE_STD_WXCOLOUR_CONSTRUCTORS
// accessors
// ---------
virtual bool IsOk() const wxOVERRIDE { return m_isInit; }
unsigned char Red() const wxOVERRIDE { return m_red; }
unsigned char Green() const wxOVERRIDE { return m_green; }
unsigned char Blue() const wxOVERRIDE { return m_blue; }
unsigned char Alpha() const wxOVERRIDE { return m_alpha ; }
// comparison
bool operator==(const wxColour& colour) const
{
return m_isInit == colour.m_isInit
&& m_red == colour.m_red
&& m_green == colour.m_green
&& m_blue == colour.m_blue
&& m_alpha == colour.m_alpha;
}
bool operator!=(const wxColour& colour) const { return !(*this == colour); }
WXCOLORREF GetPixel() const { return m_pixel; }
public:
WXCOLORREF m_pixel;
protected:
// Helper function
void Init();
virtual void
InitRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a) wxOVERRIDE;
private:
bool m_isInit;
unsigned char m_red;
unsigned char m_blue;
unsigned char m_green;
unsigned char m_alpha;
private:
wxDECLARE_DYNAMIC_CLASS(wxColour);
};
#endif // _WX_COLOUR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/checkbox.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/checkbox.h
// Purpose: wxCheckBox class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHECKBOX_H_
#define _WX_CHECKBOX_H_
#include "wx/msw/ownerdrawnbutton.h"
// Checkbox item (single checkbox)
class WXDLLIMPEXP_CORE wxCheckBox : public wxMSWOwnerDrawnButton<wxCheckBoxBase>
{
public:
wxCheckBox() { }
wxCheckBox(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr)
{
Create(parent, id, label, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxCheckBoxNameStr);
virtual void SetValue(bool value) wxOVERRIDE;
virtual bool GetValue() const wxOVERRIDE;
// override some base class virtuals
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
virtual void Command(wxCommandEvent& event) wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
// implementation only from now on
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle = NULL) const wxOVERRIDE;
protected:
virtual wxSize DoGetBestClientSize() const wxOVERRIDE;
virtual void DoSet3StateValue(wxCheckBoxState value) wxOVERRIDE;
virtual wxCheckBoxState DoGet3StateValue() const wxOVERRIDE;
// Implement wxMSWOwnerDrawnButtonBase methods.
virtual int MSWGetButtonStyle() const wxOVERRIDE;
virtual void MSWOnButtonResetOwnerDrawn() wxOVERRIDE;
virtual int MSWGetButtonCheckedFlag() const wxOVERRIDE;
virtual void
MSWDrawButtonBitmap(wxDC& dc, const wxRect& rect, int flags) wxOVERRIDE;
private:
// common part of all ctors
void Init();
// current state of the checkbox
wxCheckBoxState m_state;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckBox);
};
#endif // _WX_CHECKBOX_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/bmpbuttn.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/bmpbuttn.h
// Purpose: wxBitmapButton class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BMPBUTTN_H_
#define _WX_BMPBUTTN_H_
#include "wx/button.h"
#include "wx/bitmap.h"
#include "wx/brush.h"
class WXDLLIMPEXP_CORE wxBitmapButton : public wxBitmapButtonBase
{
public:
wxBitmapButton() {}
wxBitmapButton(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
{
Create(parent, id, bitmap, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
protected:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxBitmapButton);
};
#endif // _WX_BMPBUTTN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/custombgwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/custombgwin.h
// Purpose: wxMSW implementation of wxCustomBackgroundWindow
// Author: Vadim Zeitlin
// Created: 2011-10-10
// Copyright: (c) 2011 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CUSTOMBGWIN_H_
#define _WX_MSW_CUSTOMBGWIN_H_
#include "wx/bitmap.h"
#include "wx/brush.h"
// ----------------------------------------------------------------------------
// wxCustomBackgroundWindow
// ----------------------------------------------------------------------------
template <class W>
class wxCustomBackgroundWindow : public W,
public wxCustomBackgroundWindowBase
{
public:
typedef W BaseWindowClass;
wxCustomBackgroundWindow() { m_backgroundBrush = NULL; }
virtual ~wxCustomBackgroundWindow() { delete m_backgroundBrush; }
protected:
virtual void DoSetBackgroundBitmap(const wxBitmap& bmp) wxOVERRIDE
{
delete m_backgroundBrush;
m_backgroundBrush = bmp.IsOk() ? new wxBrush(bmp) : NULL;
// Our transparent children should use our background if we have it,
// otherwise try to restore m_inheritBgCol to some reasonable value: true
// if we also have non-default background colour or false otherwise.
BaseWindowClass::m_inheritBgCol = bmp.IsOk()
|| BaseWindowClass::UseBgCol();
}
virtual WXHBRUSH MSWGetCustomBgBrush() wxOVERRIDE
{
if ( m_backgroundBrush )
return (WXHBRUSH)m_backgroundBrush->GetResourceHandle();
return BaseWindowClass::MSWGetCustomBgBrush();
}
wxBrush *m_backgroundBrush;
wxDECLARE_NO_COPY_TEMPLATE_CLASS(wxCustomBackgroundWindow, W);
};
#endif // _WX_MSW_CUSTOMBGWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/taskbarbutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/taskbarbutton.h
// Purpose: Defines wxTaskBarButtonImpl class.
// Author: Chaobin Zhang <[email protected]>
// Created: 2014-06-01
// Copyright: (c) 2014 wxWidgets development team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_TASKBARBUTTON_H_
#define _WX_MSW_TASKBARBUTTON_H_
#include "wx/defs.h"
#if wxUSE_TASKBARBUTTON
#include "wx/vector.h"
#include "wx/taskbarbutton.h"
class WXDLLIMPEXP_FWD_CORE wxITaskbarList3;
class WXDLLIMPEXP_CORE wxTaskBarButtonImpl : public wxTaskBarButton
{
public:
virtual ~wxTaskBarButtonImpl();
virtual void SetProgressRange(int range) wxOVERRIDE;
virtual void SetProgressValue(int value) wxOVERRIDE;
virtual void PulseProgress() wxOVERRIDE;
virtual void Show(bool show = true) wxOVERRIDE;
virtual void Hide() wxOVERRIDE;
virtual void SetThumbnailTooltip(const wxString& tooltip) wxOVERRIDE;
virtual void SetProgressState(wxTaskBarButtonState state) wxOVERRIDE;
virtual void SetOverlayIcon(const wxIcon& icon,
const wxString& description = wxString()) wxOVERRIDE;
virtual void SetThumbnailClip(const wxRect& rect) wxOVERRIDE;
virtual void SetThumbnailContents(const wxWindow *child) wxOVERRIDE;
virtual bool InsertThumbBarButton(size_t pos,
wxThumbBarButton *button) wxOVERRIDE;
virtual bool AppendThumbBarButton(wxThumbBarButton *button) wxOVERRIDE;
virtual bool AppendSeparatorInThumbBar() wxOVERRIDE;
virtual wxThumbBarButton* RemoveThumbBarButton(
wxThumbBarButton *button) wxOVERRIDE;
virtual wxThumbBarButton* RemoveThumbBarButton(int id) wxOVERRIDE;
wxThumbBarButton* GetThumbBarButtonByIndex(size_t index);
bool InitOrUpdateThumbBarButtons();
virtual void Realize() wxOVERRIDE;
private:
// This ctor is only used by wxTaskBarButton::New()
wxTaskBarButtonImpl(wxITaskbarList3* taskbarList, wxWindow* parent);
wxWindow* m_parent;
wxITaskbarList3 *m_taskbarList;
typedef wxVector<wxThumbBarButton*> wxThumbBarButtons;
wxThumbBarButtons m_thumbBarButtons;
int m_progressRange;
int m_progressValue;
wxTaskBarButtonState m_progressState;
wxString m_thumbnailTooltip;
wxIcon m_overlayIcon;
wxString m_overlayIconDescription;
wxRect m_thumbnailClipRect;
bool m_hasInitThumbnailToolbar;
friend wxTaskBarButton* wxTaskBarButton::New(wxWindow*);
wxDECLARE_NO_COPY_CLASS(wxTaskBarButtonImpl);
};
#endif // wxUSE_TASKBARBUTTON
#endif // _WX_MSW_TASKBARBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/mdi.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/mdi.h
// Purpose: MDI (Multiple Document Interface) classes
// Author: Julian Smart
// Modified by: 2008-10-31 Vadim Zeitlin: derive from the base classes
// Created: 01/02/97
// Copyright: (c) 1997 Julian Smart
// (c) 2008 Vadim Zeitlin
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_MDI_H_
#define _WX_MSW_MDI_H_
#include "wx/frame.h"
class WXDLLIMPEXP_FWD_CORE wxAcceleratorTable;
// ---------------------------------------------------------------------------
// wxMDIParentFrame
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMDIParentFrame : public wxMDIParentFrameBase
{
public:
wxMDIParentFrame() { Init(); }
wxMDIParentFrame(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
virtual ~wxMDIParentFrame();
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE | wxVSCROLL | wxHSCROLL,
const wxString& name = wxFrameNameStr);
// override/implement base class [pure] virtual methods
// ----------------------------------------------------
static bool IsTDI() { return false; }
// we don't store the active child in m_currentChild so override this
// function to find it dynamically
virtual wxMDIChildFrame *GetActiveChild() const wxOVERRIDE;
virtual void Cascade() wxOVERRIDE;
virtual void Tile(wxOrientation orient = wxHORIZONTAL) wxOVERRIDE;
virtual void ArrangeIcons() wxOVERRIDE;
virtual void ActivateNext() wxOVERRIDE;
virtual void ActivatePrevious() wxOVERRIDE;
#if wxUSE_MENUS
virtual void SetWindowMenu(wxMenu* menu) wxOVERRIDE;
virtual void DoMenuUpdates(wxMenu* menu = NULL) wxOVERRIDE;
// return the active child menu, if any
virtual WXHMENU MSWGetActiveMenu() const wxOVERRIDE;
#endif // wxUSE_MENUS
// implementation only from now on
// MDI helpers
// -----------
#if wxUSE_MENUS
// called by wxMDIChildFrame after it was successfully created
virtual void AddMDIChild(wxMDIChildFrame *child);
// called by wxMDIChildFrame just before it is destroyed
virtual void RemoveMDIChild(wxMDIChildFrame *child);
#endif // wxUSE_MENUS
// Retrieve the current window menu label: it can be different from
// "Window" when using non-English translations and can also be different
// from wxGetTranslation("Window") if the locale has changed since the
// "Window" menu was added.
const wxString& MSWGetCurrentWindowMenuLabel() const
{ return m_currentWindowMenuLabel; }
// handlers
// --------
// Responds to colour changes
void OnSysColourChanged(wxSysColourChangedEvent& event);
void OnActivate(wxActivateEvent& event);
void OnSize(wxSizeEvent& event);
void OnIconized(wxIconizeEvent& event);
bool HandleActivate(int state, bool minimized, WXHWND activate);
// override window proc for MDI-specific message processing
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXLRESULT MSWDefWindowProc(WXUINT, WXWPARAM, WXLPARAM) wxOVERRIDE;
virtual bool MSWTranslateMessage(WXMSG* msg) wxOVERRIDE;
#if wxUSE_MENUS
// override the menu-relayed methods to also look in the active child menu
// bar and the "Window" menu
virtual wxMenuItem *FindItemInMenuBar(int menuId) const wxOVERRIDE;
virtual wxMenu* MSWFindMenuFromHMENU(WXHMENU hMenu) wxOVERRIDE;
#endif // wxUSE_MENUS
protected:
#if wxUSE_MENUS_NATIVE
virtual void InternalSetMenuBar() wxOVERRIDE;
#endif // wxUSE_MENUS_NATIVE
virtual WXHICON GetDefaultIcon() const wxOVERRIDE;
// set the size of the MDI client window to match the frame size
void UpdateClientSize();
private:
// common part of all ctors
void Init();
#if wxUSE_MENUS
// "Window" menu commands event handlers
void OnMDICommand(wxCommandEvent& event);
void OnMDIChild(wxCommandEvent& event);
// add/remove window menu if we have it (i.e. m_windowMenu != NULL)
void AddWindowMenu();
void RemoveWindowMenu();
// update the window menu (if we have it) to enable or disable the commands
// which only make sense when we have more than one child
void UpdateWindowMenu(bool enable);
#if wxUSE_ACCEL
wxAcceleratorTable *m_accelWindowMenu;
#endif // wxUSE_ACCEL
#endif // wxUSE_MENUS
// return the number of child frames we currently have (maybe 0)
int GetChildFramesCount() const;
// if true, indicates whether the event wasn't really processed even though
// it was "handled", see OnActivate() and HandleActivate()
bool m_activationNotHandled;
// holds the current translation for the window menu label
wxString m_currentWindowMenuLabel;
friend class WXDLLIMPEXP_FWD_CORE wxMDIChildFrame;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxMDIParentFrame);
wxDECLARE_NO_COPY_CLASS(wxMDIParentFrame);
};
// ---------------------------------------------------------------------------
// wxMDIChildFrame
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMDIChildFrame : public wxMDIChildFrameBase
{
public:
wxMDIChildFrame() { Init(); }
wxMDIChildFrame(wxMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr)
{
Init();
Create(parent, id, title, pos, size, style, name);
}
bool Create(wxMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME_STYLE,
const wxString& name = wxFrameNameStr);
virtual ~wxMDIChildFrame();
// implement MDI operations
virtual void Activate() wxOVERRIDE;
// Override some frame operations too
virtual void Maximize(bool maximize = true) wxOVERRIDE;
virtual void Restore() wxOVERRIDE;
virtual bool Show(bool show = true) wxOVERRIDE;
// Implementation only from now on
// -------------------------------
// Handlers
bool HandleMDIActivate(long bActivate, WXHWND, WXHWND);
bool HandleWindowPosChanging(void *lpPos);
bool HandleGetMinMaxInfo(void *mmInfo);
virtual WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXLRESULT MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual bool MSWTranslateMessage(WXMSG *msg) wxOVERRIDE;
virtual void MSWDestroyWindow() wxOVERRIDE;
bool ResetWindowStyle(void *vrect);
void OnIdle(wxIdleEvent& event);
protected:
virtual void DoGetScreenPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoGetPosition(int *x, int *y) const wxOVERRIDE;
virtual void DoSetSize(int x, int y, int width, int height, int sizeFlags) wxOVERRIDE;
virtual void DoSetClientSize(int width, int height) wxOVERRIDE;
virtual void InternalSetMenuBar() wxOVERRIDE;
virtual bool IsMDIChild() const wxOVERRIDE { return true; }
virtual void DetachMenuBar() wxOVERRIDE;
virtual WXHICON GetDefaultIcon() const wxOVERRIDE;
// common part of all ctors
void Init();
private:
bool m_needsResize; // flag which tells us to artificially resize the frame
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMDIChildFrame);
};
// ---------------------------------------------------------------------------
// wxMDIClientWindow
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMDIClientWindow : public wxMDIClientWindowBase
{
public:
wxMDIClientWindow() { Init(); }
// Note: this is virtual, to allow overridden behaviour.
virtual bool CreateClient(wxMDIParentFrame *parent,
long style = wxVSCROLL | wxHSCROLL) wxOVERRIDE;
// Explicitly call default scroll behaviour
void OnScroll(wxScrollEvent& event);
protected:
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
void Init() { m_scrollX = m_scrollY = 0; }
int m_scrollX, m_scrollY;
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMDIClientWindow);
};
#endif // _WX_MSW_MDI_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/libraries.h | /*
* Name: wx/msw/libraries.h
* Purpose: Pragmas for linking libs conditionally
* Author: Michael Wetherell
* Modified by:
* Copyright: (c) 2005 Michael Wetherell
* Licence: wxWindows licence
*/
#ifndef _WX_MSW_LIBRARIES_H_
#define _WX_MSW_LIBRARIES_H_
/*
* Notes:
*
* In general the preferred place to add libs is in the bakefiles. This file
* can be used where libs must be added conditionally, for those compilers that
* support a way to do that.
*/
#if defined __VISUALC__ && wxUSE_ACCESSIBILITY
#pragma comment(lib, "oleacc")
#endif
#if defined __VISUALC__ && wxUSE_UXTHEME
#pragma comment(lib, "uxtheme")
#endif
#endif /* _WX_MSW_LIBRARIES_H_ */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/subwin.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/subwin.h
// Purpose: helper for implementing the controls with subwindows
// Author: Vadim Zeitlin
// Modified by:
// Created: 2004-12-11
// Copyright: (c) 2004 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_SUBWIN_H_
#define _WX_MSW_SUBWIN_H_
#include "wx/msw/private.h"
// ----------------------------------------------------------------------------
// wxSubwindows contains all HWNDs making part of a single wx control
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxSubwindows
{
public:
// the number of subwindows can be specified either as parameter to ctor or
// later in Create()
wxSubwindows(size_t n = 0) { Init(); if ( n ) Create(n); }
// allocate enough space for the given number of windows
void Create(size_t n)
{
wxASSERT_MSG( !m_hwnds, wxT("Create() called twice?") );
m_count = n;
m_hwnds = (HWND *)calloc(n, sizeof(HWND));
m_ids = new wxWindowIDRef[n];
}
// non-virtual dtor, this class is not supposed to be used polymorphically
~wxSubwindows()
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
::DestroyWindow(m_hwnds[n]);
}
free(m_hwnds);
delete [] m_ids;
}
// get the number of subwindows
size_t GetCount() const { return m_count; }
// access a given window
HWND& Get(size_t n)
{
wxASSERT_MSG( n < m_count, wxT("subwindow index out of range") );
return m_hwnds[n];
}
HWND operator[](size_t n) const
{
return const_cast<wxSubwindows *>(this)->Get(n);
}
// initialize the given window: id will be stored in wxWindowIDRef ensuring
// that it is not reused while this object exists
void Set(size_t n, HWND hwnd, wxWindowID id)
{
wxASSERT_MSG( n < m_count, wxT("subwindow index out of range") );
m_hwnds[n] = hwnd;
m_ids[n] = id;
}
// check if we have this window
bool HasWindow(HWND hwnd)
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] == hwnd )
return true;
}
return false;
}
// methods which are forwarded to all subwindows
// ---------------------------------------------
// show/hide everything
void Show(bool show)
{
int sw = show ? SW_SHOW : SW_HIDE;
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
::ShowWindow(m_hwnds[n], sw);
}
}
// enable/disable everything
void Enable(bool enable)
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
::EnableWindow(m_hwnds[n], enable);
}
}
// set font for all windows
void SetFont(const wxFont& font)
{
HFONT hfont = GetHfontOf(font);
wxCHECK_RET( hfont, wxT("invalid font") );
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
{
::SendMessage(m_hwnds[n], WM_SETFONT, (WPARAM)hfont, 0);
// otherwise the window might not be redrawn correctly
::InvalidateRect(m_hwnds[n], NULL, FALSE /* don't erase bg */);
}
}
}
// add all windows to update region to force redraw
void Refresh()
{
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
{
::InvalidateRect(m_hwnds[n], NULL, FALSE /* don't erase bg */);
}
}
}
// find the bounding box for all windows
wxRect GetBoundingBox() const
{
wxRect r;
for ( size_t n = 0; n < m_count; n++ )
{
if ( m_hwnds[n] )
{
RECT rc;
::GetWindowRect(m_hwnds[n], &rc);
r.Union(wxRectFromRECT(rc));
}
}
return r;
}
private:
void Init()
{
m_count = 0;
m_hwnds = NULL;
m_ids = NULL;
}
// number of elements in m_hwnds array
size_t m_count;
// the HWNDs we contain
HWND *m_hwnds;
// the IDs of the windows
wxWindowIDRef *m_ids;
wxDECLARE_NO_COPY_CLASS(wxSubwindows);
};
// convenient macro to forward a few methods which are usually propagated to
// subwindows to a wxSubwindows object
//
// parameters should be:
// - cname the name of the class implementing these methods
// - base the name of its base class
// - subwins the name of the member variable of type wxSubwindows *
#define WX_FORWARD_STD_METHODS_TO_SUBWINDOWS(cname, base, subwins) \
bool cname::ContainsHWND(WXHWND hWnd) const \
{ \
return subwins && subwins->HasWindow((HWND)hWnd); \
} \
\
bool cname::Show(bool show) \
{ \
if ( !base::Show(show) ) \
return false; \
\
if ( subwins ) \
subwins->Show(show); \
\
return true; \
} \
\
bool cname::Enable(bool enable) \
{ \
if ( !base::Enable(enable) ) \
return false; \
\
if ( subwins ) \
subwins->Enable(enable); \
\
return true; \
} \
\
bool cname::SetFont(const wxFont& font) \
{ \
if ( !base::SetFont(font) ) \
return false; \
\
if ( subwins ) \
subwins->SetFont(font); \
\
return true; \
} \
\
bool cname::SetForegroundColour(const wxColour& colour) \
{ \
if ( !base::SetForegroundColour(colour) ) \
return false; \
\
if ( subwins ) \
subwins->Refresh(); \
\
return true; \
} \
\
bool cname::SetBackgroundColour(const wxColour& colour) \
{ \
if ( !base::SetBackgroundColour(colour) ) \
return false; \
\
if ( subwins ) \
subwins->Refresh(); \
\
return true; \
} \
#endif // _WX_MSW_SUBWIN_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/stackwalk.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/stackwalk.h
// Purpose: wxStackWalker for MSW
// Author: Vadim Zeitlin
// Modified by:
// Created: 2005-01-08
// Copyright: (c) 2005 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_STACKWALK_H_
#define _WX_MSW_STACKWALK_H_
#include "wx/arrstr.h"
// these structs are declared in windows headers
struct _CONTEXT;
struct _EXCEPTION_POINTERS;
// and these in dbghelp.h
struct _SYMBOL_INFO;
struct _SYMBOL_INFOW;
#if wxUSE_UNICODE
#define wxSYMBOL_INFO _SYMBOL_INFOW
#else // !wxUSE_UNICODE
#define wxSYMBOL_INFO _SYMBOL_INFO
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
// ----------------------------------------------------------------------------
// wxStackFrame
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStackFrame : public wxStackFrameBase
{
private:
wxStackFrame *ConstCast() const
{ return const_cast<wxStackFrame *>(this); }
size_t DoGetParamCount() const { return m_paramTypes.GetCount(); }
public:
wxStackFrame(size_t level, void *address, size_t addrFrame)
: wxStackFrameBase(level, address)
{
m_hasName =
m_hasLocation = false;
m_addrFrame = addrFrame;
}
virtual size_t GetParamCount() const
{
ConstCast()->OnGetParam();
return DoGetParamCount();
}
virtual bool
GetParam(size_t n, wxString *type, wxString *name, wxString *value) const;
// callback used by OnGetParam(), don't call directly
void OnParam(wxSYMBOL_INFO *pSymInfo);
protected:
virtual void OnGetName();
virtual void OnGetLocation();
void OnGetParam();
// helper for debug API: it wants to have addresses as DWORDs
size_t GetSymAddr() const
{
return reinterpret_cast<size_t>(m_address);
}
private:
bool m_hasName,
m_hasLocation;
size_t m_addrFrame;
wxArrayString m_paramTypes,
m_paramNames,
m_paramValues;
};
// ----------------------------------------------------------------------------
// wxStackWalker
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxStackWalker : public wxStackWalkerBase
{
public:
// we don't use ctor argument, it is for compatibility with Unix version
// only
wxStackWalker(const char * WXUNUSED(argv0) = NULL) { }
virtual void Walk(size_t skip = 1, size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
#if wxUSE_ON_FATAL_EXCEPTION
virtual void WalkFromException(size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
#endif // wxUSE_ON_FATAL_EXCEPTION
// enumerate stack frames from the given context
void WalkFrom(const _CONTEXT *ctx, size_t skip = 1, size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
void WalkFrom(const _EXCEPTION_POINTERS *ep, size_t skip = 1, size_t maxDepth = wxSTACKWALKER_MAX_DEPTH);
};
#endif // _WX_MSW_STACKWALK_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/iniconf.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/iniconf.h
// Purpose: INI-file based wxConfigBase implementation
// Author: Vadim Zeitlin
// Modified by:
// Created: 27.07.98
// Copyright: (c) 1998 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_INICONF_H_
#define _WX_MSW_INICONF_H_
#include "wx/defs.h"
#if wxUSE_CONFIG && wxUSE_INICONF
// ----------------------------------------------------------------------------
// wxIniConfig is a wxConfig implementation which uses MS Windows INI files to
// store the data. Because INI files don't really support arbitrary nesting of
// groups, we do the following:
// (1) in win.ini file we store all entries in the [vendor] section and
// the value group1/group2/key is mapped to the value group1_group2_key
// in this section, i.e. all path separators are replaced with underscore
// (2) in appname.ini file we map group1/group2/group3/key to the entry
// group2_group3_key in [group1]
//
// Of course, it might lead to indesirable results if '_' is also used in key
// names (i.e. group/key is the same as group_key) and also GetPath() result
// may be not what you would expect it to be.
//
// Another limitation: the keys and section names are never case-sensitive
// which might differ from wxFileConfig it it was compiled with
// wxCONFIG_CASE_SENSITIVE option.
// ----------------------------------------------------------------------------
// for this class, "local" file is the file appname.ini and the global file
// is the [vendor] subsection of win.ini (default for "vendor" is to be the
// same as appname). The file name (strAppName parameter) may, in fact,
// contain the full path to the file. If it doesn't, the file is searched for
// in the Windows directory.
class WXDLLIMPEXP_CORE wxIniConfig : public wxConfigBase
{
public:
// ctor & dtor
// if strAppName doesn't contain the extension and is not an absolute path,
// ".ini" is appended to it. if strVendor is empty, it's taken to be the
// same as strAppName.
wxIniConfig(const wxString& strAppName = wxEmptyString, const wxString& strVendor = wxEmptyString,
const wxString& localFilename = wxEmptyString, const wxString& globalFilename = wxEmptyString, long style = wxCONFIG_USE_LOCAL_FILE);
virtual ~wxIniConfig();
// implement inherited pure virtual functions
virtual void SetPath(const wxString& strPath) wxOVERRIDE;
virtual const wxString& GetPath() const wxOVERRIDE;
virtual bool GetFirstGroup(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextGroup (wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetFirstEntry(wxString& str, long& lIndex) const wxOVERRIDE;
virtual bool GetNextEntry (wxString& str, long& lIndex) const wxOVERRIDE;
virtual size_t GetNumberOfEntries(bool bRecursive = false) const wxOVERRIDE;
virtual size_t GetNumberOfGroups(bool bRecursive = false) const wxOVERRIDE;
virtual bool HasGroup(const wxString& strName) const wxOVERRIDE;
virtual bool HasEntry(const wxString& strName) const wxOVERRIDE;
// return true if the current group is empty
bool IsEmpty() const;
virtual bool Flush(bool bCurrentOnly = false) wxOVERRIDE;
virtual bool RenameEntry(const wxString& oldName, const wxString& newName) wxOVERRIDE;
virtual bool RenameGroup(const wxString& oldName, const wxString& newName) wxOVERRIDE;
virtual bool DeleteEntry(const wxString& Key, bool bGroupIfEmptyAlso = true) wxOVERRIDE;
virtual bool DeleteGroup(const wxString& szKey) wxOVERRIDE;
virtual bool DeleteAll() wxOVERRIDE;
protected:
// read/write
bool DoReadString(const wxString& key, wxString *pStr) const wxOVERRIDE;
bool DoReadLong(const wxString& key, long *plResult) const wxOVERRIDE;
bool DoReadBinary(const wxString& key, wxMemoryBuffer *buf) const wxOVERRIDE;
bool DoWriteString(const wxString& key, const wxString& szValue) wxOVERRIDE;
bool DoWriteLong(const wxString& key, long lValue) wxOVERRIDE;
bool DoWriteBinary(const wxString& key, const wxMemoryBuffer& buf) wxOVERRIDE;
private:
// helpers
wxString GetPrivateKeyName(const wxString& szKey) const;
wxString GetKeyName(const wxString& szKey) const;
wxString m_strLocalFilename; // name of the private INI file
wxString m_strGroup, // current group in appname.ini file
m_strPath; // the rest of the path (no trailing '_'!)
wxDECLARE_NO_COPY_CLASS(wxIniConfig);
wxDECLARE_ABSTRACT_CLASS(wxIniConfig);
};
#endif // wxUSE_CONFIG && wxUSE_INICONF
#endif // _WX_MSW_INICONF_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/private.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/private.h
// Purpose: Private declarations: as this header is only included by
// wxWidgets itself, it may contain identifiers which don't start
// with "wx".
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PRIVATE_H_
#define _WX_PRIVATE_H_
#include "wx/msw/wrapwin.h"
#include "wx/log.h"
#if wxUSE_GUI
#include "wx/window.h"
#endif // wxUSE_GUI
class WXDLLIMPEXP_FWD_CORE wxFont;
class WXDLLIMPEXP_FWD_CORE wxWindow;
class WXDLLIMPEXP_FWD_CORE wxWindowBase;
// ---------------------------------------------------------------------------
// private constants
// ---------------------------------------------------------------------------
// 260 was taken from windef.h
#ifndef MAX_PATH
#define MAX_PATH 260
#endif
// ---------------------------------------------------------------------------
// standard icons from the resources
// ---------------------------------------------------------------------------
#if wxUSE_GUI
extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_FRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_MDIPARENTFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxSTD_MDICHILDFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_FRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_MDIPARENTFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HICON) wxDEFAULT_MDICHILDFRAME_ICON;
extern WXDLLIMPEXP_DATA_CORE(HFONT) wxSTATUS_LINE_FONT;
#endif // wxUSE_GUI
// ---------------------------------------------------------------------------
// global data
// ---------------------------------------------------------------------------
extern WXDLLIMPEXP_DATA_BASE(HINSTANCE) wxhInstance;
extern "C"
{
WXDLLIMPEXP_BASE HINSTANCE wxGetInstance();
}
WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
// ---------------------------------------------------------------------------
// define things missing from some compilers' headers
// ---------------------------------------------------------------------------
// this defines a CASTWNDPROC macro which casts a pointer to the type of a
// window proc
#if defined(STRICT) || defined(__GNUC__)
typedef WNDPROC WndProcCast;
#else
typedef FARPROC WndProcCast;
#endif
#define CASTWNDPROC (WndProcCast)
// ---------------------------------------------------------------------------
// misc macros
// ---------------------------------------------------------------------------
#if wxUSE_GUI
#define MEANING_CHARACTER '0'
#define DEFAULT_ITEM_WIDTH 100
#define DEFAULT_ITEM_HEIGHT 80
// Return the height of a native text control corresponding to the given
// character height (as returned by GetCharHeight() or wxGetCharSize()).
//
// The wxWindow parameter must be valid and used for getting the DPI.
inline int wxGetEditHeightFromCharHeight(int cy, const wxWindow* w)
{
// The value 8 here is empiric, i.e. it's not necessarily correct, but
// seems to work relatively well.
return cy + w->FromDIP(8);
}
// Compatibility macro used in the existing code. It assumes that it's called
// from a method of wxWindow-derived object.
#define EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy) \
wxGetEditHeightFromCharHeight((cy), this)
// Generic subclass proc, for panel item moving/sizing and intercept
// EDIT control VK_RETURN messages
extern LONG APIENTRY
wxSubclassedGenericControlProc(WXHWND hWnd, WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
#endif // wxUSE_GUI
// ---------------------------------------------------------------------------
// useful macros and functions
// ---------------------------------------------------------------------------
// a wrapper macro for ZeroMemory()
#define wxZeroMemory(obj) ::ZeroMemory(&obj, sizeof(obj))
// This one is a macro so that it can be tested with #ifdef, it will be
// undefined if it cannot be implemented for a given compiler.
// Vc++, bcc, dmc, ow, mingw akk have _get_osfhandle() and Cygwin has
// get_osfhandle. Others are currently unknown, e.g. Salford, Intel, Visual
// Age.
#if defined(__CYGWIN__)
#define wxGetOSFHandle(fd) ((HANDLE)get_osfhandle(fd))
#elif defined(__VISUALC__) \
|| defined(__BORLANDC__) \
|| defined(__MINGW32__)
#define wxGetOSFHandle(fd) ((HANDLE)_get_osfhandle(fd))
#define wxOpenOSFHandle(h, flags) (_open_osfhandle(wxPtrToUInt(h), flags))
wxDECL_FOR_STRICT_MINGW32(FILE*, _fdopen, (int, const char*))
#define wx_fdopen _fdopen
#endif
// close the handle in the class dtor
template <wxUIntPtr INVALID_VALUE>
class AutoHANDLE
{
public:
explicit AutoHANDLE(HANDLE handle = InvalidHandle()) : m_handle(handle) { }
bool IsOk() const { return m_handle != InvalidHandle(); }
operator HANDLE() const { return m_handle; }
~AutoHANDLE() { if ( IsOk() ) DoClose(); }
void Close()
{
wxCHECK_RET(IsOk(), wxT("Handle must be valid"));
DoClose();
m_handle = InvalidHandle();
}
protected:
// We need this helper function because integer INVALID_VALUE is not
// implicitly convertible to HANDLE, which is a pointer.
static HANDLE InvalidHandle()
{
return reinterpret_cast<HANDLE>(INVALID_VALUE);
}
void DoClose()
{
if ( !::CloseHandle(m_handle) )
wxLogLastError(wxT("CloseHandle"));
}
WXHANDLE m_handle;
};
// a template to make initializing Windows structs less painful: it zeros all
// the struct fields and also sets cbSize member to the correct value (and so
// can be only used with structures which have this member...)
template <class T>
struct WinStruct : public T
{
WinStruct()
{
::ZeroMemory(this, sizeof(T));
// explicit qualification is required here for this to be valid C++
this->cbSize = sizeof(T);
}
};
// Macros for converting wxString to the type expected by API functions.
//
// Normally it is enough to just use wxString::t_str() which is implicitly
// convertible to LPCTSTR, but in some cases an explicit conversion is required.
//
// In such cases wxMSW_CONV_LPCTSTR() should be used. But if an API function
// takes a non-const pointer, wxMSW_CONV_LPTSTR() which casts away the
// constness (but doesn't make it possible to really modify the returned
// pointer, of course) should be used. And if a string is passed as LPARAM, use
// wxMSW_CONV_LPARAM() which does the required ugly reinterpret_cast<> too.
#define wxMSW_CONV_LPCTSTR(s) static_cast<const wxChar *>((s).t_str())
#define wxMSW_CONV_LPTSTR(s) const_cast<wxChar *>(wxMSW_CONV_LPCTSTR(s))
#define wxMSW_CONV_LPARAM(s) reinterpret_cast<LPARAM>(wxMSW_CONV_LPCTSTR(s))
#if wxUSE_GUI
#include "wx/gdicmn.h"
#include "wx/colour.h"
// make conversion from wxColour and COLORREF a bit less painful
inline COLORREF wxColourToRGB(const wxColour& c)
{
return RGB(c.Red(), c.Green(), c.Blue());
}
inline COLORREF wxColourToPalRGB(const wxColour& c)
{
return PALETTERGB(c.Red(), c.Green(), c.Blue());
}
inline wxColour wxRGBToColour(COLORREF rgb)
{
return wxColour(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
}
inline void wxRGBToColour(wxColour& c, COLORREF rgb)
{
c.Set(GetRValue(rgb), GetGValue(rgb), GetBValue(rgb));
}
// get the standard colour map for some standard colours - see comment in this
// function to understand why is it needed and when should it be used
//
// it returns a wxCOLORMAP (can't use COLORMAP itself here as comctl32.dll
// might be not included/available) array of size wxSTD_COLOUR_MAX
//
// NB: if you change these colours, update wxBITMAP_STD_COLOURS in the
// resources as well: it must have the same number of pixels!
enum wxSTD_COLOUR
{
wxSTD_COL_BTNTEXT,
wxSTD_COL_BTNSHADOW,
wxSTD_COL_BTNFACE,
wxSTD_COL_BTNHIGHLIGHT,
wxSTD_COL_MAX
};
struct WXDLLIMPEXP_CORE wxCOLORMAP
{
COLORREF from, to;
};
// this function is implemented in src/msw/window.cpp
extern wxCOLORMAP *wxGetStdColourMap();
// create a wxRect from Windows RECT
inline wxRect wxRectFromRECT(const RECT& rc)
{
return wxRect(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
}
// copy Windows RECT to our wxRect
inline void wxCopyRECTToRect(const RECT& rc, wxRect& rect)
{
rect = wxRectFromRECT(rc);
}
// and vice versa
inline void wxCopyRectToRECT(const wxRect& rect, RECT& rc)
{
// note that we don't use wxRect::GetRight() as it is one of compared to
// wxRectFromRECT() above
rc.top = rect.y;
rc.left = rect.x;
rc.right = rect.x + rect.width;
rc.bottom = rect.y + rect.height;
}
// translations between HIMETRIC units (which OLE likes) and pixels (which are
// liked by all the others) - implemented in msw/utilsexc.cpp
extern void HIMETRICToPixel(LONG *x, LONG *y);
extern void HIMETRICToPixel(LONG *x, LONG *y, HDC hdcRef);
extern void PixelToHIMETRIC(LONG *x, LONG *y);
extern void PixelToHIMETRIC(LONG *x, LONG *y, HDC hdcRef);
// Windows convention of the mask is opposed to the wxWidgets one, so we need
// to invert the mask each time we pass one/get one to/from Windows
extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w = 0, int h = 0);
// Creates an icon or cursor depending from a bitmap
//
// The bitmap must be valid and it should have a mask. If it doesn't, a default
// mask is created using light grey as the transparent colour.
extern HICON wxBitmapToHICON(const wxBitmap& bmp);
// Same requirements as above apply and the bitmap must also have the correct
// size.
extern
HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY);
#if wxUSE_OWNER_DRAWN
// Draw the bitmap in specified state (this is used by owner drawn controls)
enum wxDSBStates
{
wxDSB_NORMAL = 0,
wxDSB_SELECTED,
wxDSB_DISABLED
};
extern
BOOL wxDrawStateBitmap(HDC hDC, HBITMAP hBitmap, int x, int y, UINT uState);
#endif // wxUSE_OWNER_DRAWN
// get the current state of SHIFT/CTRL/ALT keys
inline bool wxIsModifierDown(int vk)
{
// GetKeyState() returns different negative values on WinME and WinNT,
// so simply test for negative value.
return ::GetKeyState(vk) < 0;
}
inline bool wxIsShiftDown()
{
return wxIsModifierDown(VK_SHIFT);
}
inline bool wxIsCtrlDown()
{
return wxIsModifierDown(VK_CONTROL);
}
inline bool wxIsAltDown()
{
return wxIsModifierDown(VK_MENU);
}
inline bool wxIsAnyModifierDown()
{
return wxIsShiftDown() || wxIsCtrlDown() || wxIsAltDown();
}
// wrapper around GetWindowRect() and GetClientRect() APIs doing error checking
// for Win32
inline RECT wxGetWindowRect(HWND hwnd)
{
RECT rect;
if ( !::GetWindowRect(hwnd, &rect) )
{
wxLogLastError(wxT("GetWindowRect"));
}
return rect;
}
inline RECT wxGetClientRect(HWND hwnd)
{
RECT rect;
if ( !::GetClientRect(hwnd, &rect) )
{
wxLogLastError(wxT("GetClientRect"));
}
return rect;
}
// ---------------------------------------------------------------------------
// small helper classes
// ---------------------------------------------------------------------------
// create an instance of this class and use it as the HDC for screen, will
// automatically release the DC going out of scope
class ScreenHDC
{
public:
ScreenHDC() { m_hdc = ::GetDC(NULL); }
~ScreenHDC() { ::ReleaseDC(NULL, m_hdc); }
operator HDC() const { return m_hdc; }
private:
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(ScreenHDC);
};
// the same as ScreenHDC but for window DCs
class WindowHDC
{
public:
WindowHDC() : m_hwnd(NULL), m_hdc(NULL) { }
WindowHDC(HWND hwnd) { m_hdc = ::GetDC(m_hwnd = hwnd); }
~WindowHDC() { if ( m_hwnd && m_hdc ) { ::ReleaseDC(m_hwnd, m_hdc); } }
operator HDC() const { return m_hdc; }
private:
HWND m_hwnd;
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(WindowHDC);
};
// the same as ScreenHDC but for memory DCs: creates the HDC compatible with
// the given one (screen by default) in ctor and destroys it in dtor
class MemoryHDC
{
public:
MemoryHDC(HDC hdc = 0) { m_hdc = ::CreateCompatibleDC(hdc); }
~MemoryHDC() { ::DeleteDC(m_hdc); }
operator HDC() const { return m_hdc; }
private:
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(MemoryHDC);
};
// a class which selects a GDI object into a DC in its ctor and deselects in
// dtor
class SelectInHDC
{
private:
void DoInit(HGDIOBJ hgdiobj) { m_hgdiobj = ::SelectObject(m_hdc, hgdiobj); }
public:
SelectInHDC() : m_hdc(NULL), m_hgdiobj(NULL) { }
SelectInHDC(HDC hdc, HGDIOBJ hgdiobj) : m_hdc(hdc) { DoInit(hgdiobj); }
void Init(HDC hdc, HGDIOBJ hgdiobj)
{
wxASSERT_MSG( !m_hdc, wxT("initializing twice?") );
m_hdc = hdc;
DoInit(hgdiobj);
}
~SelectInHDC() { if ( m_hdc ) ::SelectObject(m_hdc, m_hgdiobj); }
// return true if the object was successfully selected
operator bool() const { return m_hgdiobj != 0; }
private:
HDC m_hdc;
HGDIOBJ m_hgdiobj;
wxDECLARE_NO_COPY_CLASS(SelectInHDC);
};
// a class which cleans up any GDI object
class AutoGDIObject
{
protected:
AutoGDIObject() { m_gdiobj = NULL; }
AutoGDIObject(HGDIOBJ gdiobj) : m_gdiobj(gdiobj) { }
~AutoGDIObject() { if ( m_gdiobj ) ::DeleteObject(m_gdiobj); }
void InitGdiobj(HGDIOBJ gdiobj)
{
wxASSERT_MSG( !m_gdiobj, wxT("initializing twice?") );
m_gdiobj = gdiobj;
}
HGDIOBJ GetObject() const { return m_gdiobj; }
private:
HGDIOBJ m_gdiobj;
};
// TODO: all this asks for using a AutoHandler<T, CreateFunc> template...
// a class for temporary brushes
class AutoHBRUSH : private AutoGDIObject
{
public:
AutoHBRUSH(COLORREF col)
: AutoGDIObject(::CreateSolidBrush(col)) { }
operator HBRUSH() const { return (HBRUSH)GetObject(); }
};
// a class for temporary fonts
class AutoHFONT : private AutoGDIObject
{
private:
public:
AutoHFONT()
: AutoGDIObject() { }
AutoHFONT(const LOGFONT& lf)
: AutoGDIObject(::CreateFontIndirect(&lf)) { }
void Init(const LOGFONT& lf) { InitGdiobj(::CreateFontIndirect(&lf)); }
operator HFONT() const { return (HFONT)GetObject(); }
};
// a class for temporary pens
class AutoHPEN : private AutoGDIObject
{
public:
AutoHPEN(COLORREF col)
: AutoGDIObject(::CreatePen(PS_SOLID, 0, col)) { }
operator HPEN() const { return (HPEN)GetObject(); }
};
// classes for temporary bitmaps
class AutoHBITMAP : private AutoGDIObject
{
public:
AutoHBITMAP()
: AutoGDIObject() { }
AutoHBITMAP(HBITMAP hbmp) : AutoGDIObject(hbmp) { }
void Init(HBITMAP hbmp) { InitGdiobj(hbmp); }
operator HBITMAP() const { return (HBITMAP)GetObject(); }
};
class CompatibleBitmap : public AutoHBITMAP
{
public:
CompatibleBitmap(HDC hdc, int w, int h)
: AutoHBITMAP(::CreateCompatibleBitmap(hdc, w, h))
{
}
};
class MonoBitmap : public AutoHBITMAP
{
public:
MonoBitmap(int w, int h)
: AutoHBITMAP(::CreateBitmap(w, h, 1, 1, 0))
{
}
};
// class automatically destroys the region object
class AutoHRGN : private AutoGDIObject
{
public:
AutoHRGN(HRGN hrgn) : AutoGDIObject(hrgn) { }
operator HRGN() const { return (HRGN)GetObject(); }
};
// Class automatically freeing ICONINFO struct fields after retrieving it using
// GetIconInfo().
class AutoIconInfo : public ICONINFO
{
public:
AutoIconInfo() { wxZeroMemory(*this); }
bool GetFrom(HICON hIcon)
{
if ( !::GetIconInfo(hIcon, this) )
{
wxLogLastError(wxT("GetIconInfo"));
return false;
}
return true;
}
~AutoIconInfo()
{
if ( hbmColor )
::DeleteObject(hbmColor);
if ( hbmMask )
::DeleteObject(hbmMask);
}
};
// class sets the specified clipping region during its life time
class HDCClipper
{
public:
HDCClipper(HDC hdc, HRGN hrgn)
: m_hdc(hdc)
{
if ( !::SelectClipRgn(hdc, hrgn) )
{
wxLogLastError(wxT("SelectClipRgn"));
}
}
~HDCClipper()
{
::SelectClipRgn(m_hdc, NULL);
}
private:
HDC m_hdc;
wxDECLARE_NO_COPY_CLASS(HDCClipper);
};
// set the given map mode for the life time of this object
class HDCMapModeChanger
{
public:
HDCMapModeChanger(HDC hdc, int mm)
: m_hdc(hdc)
{
m_modeOld = ::SetMapMode(hdc, mm);
if ( !m_modeOld )
{
wxLogLastError(wxT("SelectClipRgn"));
}
}
~HDCMapModeChanger()
{
if ( m_modeOld )
::SetMapMode(m_hdc, m_modeOld);
}
private:
HDC m_hdc;
int m_modeOld;
wxDECLARE_NO_COPY_CLASS(HDCMapModeChanger);
};
#define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
// smart pointer using GlobalAlloc/GlobalFree()
class GlobalPtr
{
public:
// default ctor, call Init() later
GlobalPtr()
{
m_hGlobal = NULL;
}
// allocates a block of given size
void Init(size_t size, unsigned flags = GMEM_MOVEABLE)
{
m_hGlobal = ::GlobalAlloc(flags, size);
if ( !m_hGlobal )
{
wxLogLastError(wxT("GlobalAlloc"));
}
}
GlobalPtr(size_t size, unsigned flags = GMEM_MOVEABLE)
{
Init(size, flags);
}
~GlobalPtr()
{
if ( m_hGlobal && ::GlobalFree(m_hGlobal) )
{
wxLogLastError(wxT("GlobalFree"));
}
}
// implicit conversion
operator HGLOBAL() const { return m_hGlobal; }
private:
HGLOBAL m_hGlobal;
wxDECLARE_NO_COPY_CLASS(GlobalPtr);
};
// when working with global pointers (which is unfortunately still necessary
// sometimes, e.g. for clipboard) it is important to unlock them exactly as
// many times as we lock them which just asks for using a "smart lock" class
class GlobalPtrLock
{
public:
// default ctor, use Init() later -- should only be used if the HGLOBAL can
// be NULL (in which case Init() shouldn't be called)
GlobalPtrLock()
{
m_hGlobal = NULL;
m_ptr = NULL;
}
// initialize the object, may be only called if we were created using the
// default ctor; HGLOBAL must not be NULL
void Init(HGLOBAL hGlobal)
{
m_hGlobal = hGlobal;
// NB: GlobalLock() is a macro, not a function, hence don't use the
// global scope operator with it (and neither with GlobalUnlock())
m_ptr = GlobalLock(hGlobal);
if ( !m_ptr )
{
wxLogLastError(wxT("GlobalLock"));
}
}
// initialize the object, HGLOBAL must not be NULL
GlobalPtrLock(HGLOBAL hGlobal)
{
Init(hGlobal);
}
~GlobalPtrLock()
{
if ( m_hGlobal && !GlobalUnlock(m_hGlobal) )
{
// this might happen simply because the block became unlocked
DWORD dwLastError = ::GetLastError();
if ( dwLastError != NO_ERROR )
{
wxLogApiError(wxT("GlobalUnlock"), dwLastError);
}
}
}
void *Get() const { return m_ptr; }
operator void *() const { return m_ptr; }
private:
HGLOBAL m_hGlobal;
void *m_ptr;
wxDECLARE_NO_COPY_CLASS(GlobalPtrLock);
};
// register the class when it is first needed and unregister it in dtor
class ClassRegistrar
{
public:
// ctor doesn't register the class, call Initialize() for this
ClassRegistrar() { m_registered = -1; }
// return true if the class is already registered
bool IsInitialized() const { return m_registered != -1; }
// return true if the class had been already registered
bool IsRegistered() const { return m_registered == 1; }
// try to register the class if not done yet, return true on success
bool Register(const WNDCLASS& wc)
{
// we should only be called if we hadn't been initialized yet
wxASSERT_MSG( m_registered == -1,
wxT("calling ClassRegistrar::Register() twice?") );
m_registered = ::RegisterClass(&wc) ? 1 : 0;
if ( !IsRegistered() )
{
wxLogLastError(wxT("RegisterClassEx()"));
}
else
{
m_clsname = wc.lpszClassName;
}
return m_registered == 1;
}
// get the name of the registered class (returns empty string if not
// registered)
const wxString& GetName() const { return m_clsname; }
// unregister the class if it had been registered
~ClassRegistrar()
{
if ( IsRegistered() )
{
if ( !::UnregisterClass(m_clsname.t_str(), wxGetInstance()) )
{
wxLogLastError(wxT("UnregisterClass"));
}
}
}
private:
// initial value is -1 which means that we hadn't tried registering the
// class yet, it becomes true or false (1 or 0) when Initialize() is called
int m_registered;
// the name of the class, only non empty if it had been registered
wxString m_clsname;
};
// ---------------------------------------------------------------------------
// macros to make casting between WXFOO and FOO a bit easier: the GetFoo()
// returns Foo cast to the Windows type for ourselves, while GetFooOf() takes
// an argument which should be a pointer or reference to the object of the
// corresponding class (this depends on the macro)
// ---------------------------------------------------------------------------
#define GetHwnd() ((HWND)GetHWND())
#define GetHwndOf(win) ((HWND)((win)->GetHWND()))
// old name
#define GetWinHwnd GetHwndOf
#define GetHdc() ((HDC)GetHDC())
#define GetHdcOf(dc) ((HDC)(dc).GetHDC())
#define GetHbitmap() ((HBITMAP)GetHBITMAP())
#define GetHbitmapOf(bmp) ((HBITMAP)(bmp).GetHBITMAP())
#define GetHicon() ((HICON)GetHICON())
#define GetHiconOf(icon) ((HICON)(icon).GetHICON())
#define GetHaccel() ((HACCEL)GetHACCEL())
#define GetHaccelOf(table) ((HACCEL)((table).GetHACCEL()))
#define GetHbrush() ((HBRUSH)GetResourceHandle())
#define GetHbrushOf(brush) ((HBRUSH)(brush).GetResourceHandle())
#define GetHmenu() ((HMENU)GetHMenu())
#define GetHmenuOf(menu) ((HMENU)(menu)->GetHMenu())
#define GetHcursor() ((HCURSOR)GetHCURSOR())
#define GetHcursorOf(cursor) ((HCURSOR)(cursor).GetHCURSOR())
#define GetHfont() ((HFONT)GetHFONT())
#define GetHfontOf(font) ((HFONT)(font).GetHFONT())
#define GetHimagelist() ((HIMAGELIST)GetHIMAGELIST())
#define GetHimagelistOf(imgl) ((HIMAGELIST)(imgl)->GetHIMAGELIST())
#define GetHpalette() ((HPALETTE)GetHPALETTE())
#define GetHpaletteOf(pal) ((HPALETTE)(pal).GetHPALETTE())
#define GetHpen() ((HPEN)GetResourceHandle())
#define GetHpenOf(pen) ((HPEN)(pen).GetResourceHandle())
#define GetHrgn() ((HRGN)GetHRGN())
#define GetHrgnOf(rgn) ((HRGN)(rgn).GetHRGN())
#endif // wxUSE_GUI
// ---------------------------------------------------------------------------
// global functions
// ---------------------------------------------------------------------------
// return the full path of the given module
inline wxString wxGetFullModuleName(HMODULE hmod)
{
wxString fullname;
if ( !::GetModuleFileName
(
hmod,
wxStringBuffer(fullname, MAX_PATH),
MAX_PATH
) )
{
wxLogLastError(wxT("GetModuleFileName"));
}
return fullname;
}
// return the full path of the program file
inline wxString wxGetFullModuleName()
{
return wxGetFullModuleName((HMODULE)wxGetInstance());
}
// return the run-time version of the OS in a format similar to
// WINVER/_WIN32_WINNT compile-time macros:
//
// 0x0501 Windows XP, 2003
// 0x0502 Windows XP SP2, 2003 SP1
// 0x0600 Windows Vista, 2008
// 0x0601 Windows 7
// 0x0602 Windows 8 (currently also returned for 8.1 if program does not have a manifest indicating 8.1 support)
// 0x0603 Windows 8.1 (currently only returned for 8.1 if program has a manifest indicating 8.1 support)
// 0x1000 Windows 10 (currently only returned for 10 if program has a manifest indicating 10 support)
//
// for the other Windows versions wxWinVersion_Unknown is currently returned.
enum wxWinVersion
{
wxWinVersion_3 = 0x0300,
wxWinVersion_NT3 = wxWinVersion_3,
wxWinVersion_4 = 0x0400,
wxWinVersion_95 = wxWinVersion_4,
wxWinVersion_NT4 = wxWinVersion_4,
wxWinVersion_98 = 0x0410,
wxWinVersion_5 = 0x0500,
wxWinVersion_ME = wxWinVersion_5,
wxWinVersion_NT5 = wxWinVersion_5,
wxWinVersion_2000 = wxWinVersion_5,
wxWinVersion_XP = 0x0501,
wxWinVersion_2003 = 0x0501,
wxWinVersion_XP_SP2 = 0x0502,
wxWinVersion_2003_SP1 = 0x0502,
wxWinVersion_6 = 0x0600,
wxWinVersion_Vista = wxWinVersion_6,
wxWinVersion_NT6 = wxWinVersion_6,
wxWinVersion_7 = 0x601,
wxWinVersion_8 = 0x602,
wxWinVersion_8_1 = 0x603,
wxWinVersion_10 = 0x1000,
// Any version we can't recognize will be later than the last currently
// known one, so give it a value greater than any in the known range.
wxWinVersion_Unknown = 0x7fff
};
WXDLLIMPEXP_BASE wxWinVersion wxGetWinVersion();
#if wxUSE_GUI && defined(__WXMSW__)
// cursor stuff
extern HCURSOR wxGetCurrentBusyCursor(); // from msw/utils.cpp
extern const wxCursor *wxGetGlobalCursor(); // from msw/cursor.cpp
// GetCursorPos can fail without populating the POINT. This falls back to GetMessagePos.
WXDLLIMPEXP_CORE void wxGetCursorPosMSW(POINT* pt);
WXDLLIMPEXP_CORE void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font);
WXDLLIMPEXP_CORE void wxFillLogFont(LOGFONT *logFont, const wxFont *font);
WXDLLIMPEXP_CORE wxFont wxCreateFontFromLogFont(const LOGFONT *logFont);
WXDLLIMPEXP_CORE wxFontEncoding wxGetFontEncFromCharSet(int charset);
WXDLLIMPEXP_CORE void wxSliderEvent(WXHWND control, WXWORD wParam, WXWORD pos);
WXDLLIMPEXP_CORE void wxScrollBarEvent(WXHWND hbar, WXWORD wParam, WXWORD pos);
// Find maximum size of window/rectangle
extern WXDLLIMPEXP_CORE void wxFindMaxSize(WXHWND hwnd, RECT *rect);
// Safely get the window text (i.e. without using fixed size buffer)
extern WXDLLIMPEXP_CORE wxString wxGetWindowText(WXHWND hWnd);
// get the window class name
extern WXDLLIMPEXP_CORE wxString wxGetWindowClass(WXHWND hWnd);
// get the window id (should be unsigned, hence this is not wxWindowID which
// is, for mainly historical reasons, signed)
extern WXDLLIMPEXP_CORE int wxGetWindowId(WXHWND hWnd);
// check if hWnd's WNDPROC is wndProc. Return true if yes, false if they are
// different
//
// wndProc parameter is unused and only kept for compatibility
extern WXDLLIMPEXP_CORE
bool wxCheckWindowWndProc(WXHWND hWnd, WXWNDPROC wndProc = NULL);
// Does this window style specify any border?
inline bool wxStyleHasBorder(long style)
{
return (style & (wxSIMPLE_BORDER | wxRAISED_BORDER |
wxSUNKEN_BORDER | wxDOUBLE_BORDER)) != 0;
}
inline bool wxHasWindowExStyle(const wxWindowMSW *win, long style)
{
return (::GetWindowLong(GetHwndOf(win), GWL_EXSTYLE) & style) != 0;
}
// Common helper of wxUpdate{,Edit}LayoutDirection() below: sets or clears the
// given flag(s) depending on wxLayoutDirection and returns true if the flags
// really changed.
inline bool
wxUpdateExStyleForLayoutDirection(WXHWND hWnd,
wxLayoutDirection dir,
LONG_PTR flagsForRTL)
{
wxCHECK_MSG( hWnd, false,
wxS("Can't set layout direction for invalid window") );
const LONG_PTR styleOld = ::GetWindowLongPtr(hWnd, GWL_EXSTYLE);
LONG_PTR styleNew = styleOld;
switch ( dir )
{
case wxLayout_LeftToRight:
styleNew &= ~flagsForRTL;
break;
case wxLayout_RightToLeft:
styleNew |= flagsForRTL;
break;
case wxLayout_Default:
wxFAIL_MSG(wxS("Invalid layout direction"));
}
if ( styleNew == styleOld )
return false;
::SetWindowLongPtr(hWnd, GWL_EXSTYLE, styleNew);
return true;
}
// Update layout direction flag for a generic window.
//
// See below for the special version that must be used with EDIT controls.
//
// Returns true if the layout direction did change.
inline bool wxUpdateLayoutDirection(WXHWND hWnd, wxLayoutDirection dir)
{
return wxUpdateExStyleForLayoutDirection(hWnd, dir, WS_EX_LAYOUTRTL);
}
// Update layout direction flag for an EDIT control.
//
// Returns true if anything changed or false if the direction flag was already
// set to the desired direction (which can't be wxLayout_Default).
inline bool wxUpdateEditLayoutDirection(WXHWND hWnd, wxLayoutDirection dir)
{
return wxUpdateExStyleForLayoutDirection(hWnd, dir,
WS_EX_RIGHT |
WS_EX_RTLREADING |
WS_EX_LEFTSCROLLBAR);
}
// Companion of the above function checking if an EDIT control uses RTL.
inline wxLayoutDirection wxGetEditLayoutDirection(WXHWND hWnd)
{
wxCHECK_MSG( hWnd, wxLayout_Default, wxS("invalid window") );
// While we set 3 style bits above, we're only really interested in one of
// them here. In particularly, don't check for WS_EX_RIGHT as it can be set
// for a right-aligned control even if it doesn't use RTL. And while we
// could test WS_EX_LEFTSCROLLBAR, this doesn't really seem useful.
const LONG_PTR style = ::GetWindowLongPtr(hWnd, GWL_EXSTYLE);
return style & WS_EX_RTLREADING ? wxLayout_RightToLeft
: wxLayout_LeftToRight;
}
// ----------------------------------------------------------------------------
// functions mapping HWND to wxWindow
// ----------------------------------------------------------------------------
// this function simply checks whether the given hwnd corresponds to a wxWindow
// and returns either that window if it does or NULL otherwise
extern WXDLLIMPEXP_CORE wxWindow* wxFindWinFromHandle(HWND hwnd);
// find the window for HWND which is part of some wxWindow, i.e. unlike
// wxFindWinFromHandle() above it will also work for "sub controls" of a
// wxWindow.
//
// returns the wxWindow corresponding to the given HWND or NULL.
extern WXDLLIMPEXP_CORE wxWindow *wxGetWindowFromHWND(WXHWND hwnd);
// Get the size of an icon
extern WXDLLIMPEXP_CORE wxSize wxGetHiconSize(HICON hicon);
WXDLLIMPEXP_CORE void wxDrawLine(HDC hdc, int x1, int y1, int x2, int y2);
// fill the client rect of the given window on the provided dc using this brush
inline void wxFillRect(HWND hwnd, HDC hdc, HBRUSH hbr)
{
RECT rc;
::GetClientRect(hwnd, &rc);
::FillRect(hdc, &rc, hbr);
}
// ----------------------------------------------------------------------------
// 32/64 bit helpers
// ----------------------------------------------------------------------------
// note that the casts to LONG_PTR here are required even on 32-bit machines
// for the 64-bit warning mode of later versions of MSVC (C4311/4312)
inline WNDPROC wxGetWindowProc(HWND hwnd)
{
return (WNDPROC)(LONG_PTR)::GetWindowLongPtr(hwnd, GWLP_WNDPROC);
}
inline void *wxGetWindowUserData(HWND hwnd)
{
return (void *)(LONG_PTR)::GetWindowLongPtr(hwnd, GWLP_USERDATA);
}
inline WNDPROC wxSetWindowProc(HWND hwnd, WNDPROC func)
{
return (WNDPROC)(LONG_PTR)::SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)func);
}
inline void *wxSetWindowUserData(HWND hwnd, void *data)
{
return (void *)(LONG_PTR)::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)data);
}
#endif // wxUSE_GUI && __WXMSW__
#endif // _WX_PRIVATE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/accel.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/accel.h
// Purpose: wxAcceleratorTable class
// Author: Julian Smart
// Modified by:
// Created: 31/7/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ACCEL_H_
#define _WX_ACCEL_H_
class WXDLLIMPEXP_FWD_CORE wxWindow;
// ----------------------------------------------------------------------------
// the accel table has all accelerators for a given window or menu
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxAcceleratorTable : public wxObject
{
public:
// default ctor
wxAcceleratorTable() { }
// load from .rc resource (Windows specific)
wxAcceleratorTable(const wxString& resource);
// initialize from array
wxAcceleratorTable(int n, const wxAcceleratorEntry entries[]);
bool Ok() const { return IsOk(); }
bool IsOk() const;
void SetHACCEL(WXHACCEL hAccel);
WXHACCEL GetHACCEL() const;
// translate the accelerator, return true if done
bool Translate(wxWindow *window, WXMSG *msg) const;
private:
wxDECLARE_DYNAMIC_CLASS(wxAcceleratorTable);
};
#endif
// _WX_ACCEL_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/scrolbar.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/scrolbar.h
// Purpose: wxScrollBar class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_SCROLBAR_H_
#define _WX_SCROLBAR_H_
// Scrollbar item
class WXDLLIMPEXP_CORE wxScrollBar: public wxScrollBarBase
{
public:
wxScrollBar() { m_pageSize = 0; m_viewSize = 0; m_objectSize = 0; }
virtual ~wxScrollBar();
wxScrollBar(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr)
{
Create(parent, id, pos, size, style, validator, name);
}
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxSB_HORIZONTAL,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxScrollBarNameStr);
int GetThumbPosition() const wxOVERRIDE;
int GetThumbSize() const wxOVERRIDE { return m_pageSize; }
int GetPageSize() const wxOVERRIDE { return m_viewSize; }
int GetRange() const wxOVERRIDE { return m_objectSize; }
virtual void SetThumbPosition(int viewStart) wxOVERRIDE;
virtual void SetScrollbar(int position, int thumbSize, int range, int pageSize,
bool refresh = true) wxOVERRIDE;
// needed for RTTI
void SetThumbSize( int s ) { SetScrollbar( GetThumbPosition() , s , GetRange() , GetPageSize() , true ) ; }
void SetPageSize( int s ) { SetScrollbar( GetThumbPosition() , GetThumbSize() , GetRange() , s , true ) ; }
void SetRange( int s ) { SetScrollbar( GetThumbPosition() , GetThumbSize() , s , GetPageSize() , true ) ; }
void Command(wxCommandEvent& event) wxOVERRIDE;
virtual bool MSWOnScroll(int orientation, WXWORD wParam,
WXWORD pos, WXHWND control) wxOVERRIDE;
// override wxControl version to not use solid background here
virtual WXHBRUSH MSWControlColor(WXHDC pDC, WXHWND hWnd) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
int m_pageSize;
int m_viewSize;
int m_objectSize;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxScrollBar);
};
#endif
// _WX_SCROLBAR_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/dde.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dde.h
// Purpose: DDE class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DDE_H_
#define _WX_DDE_H_
#include "wx/ipcbase.h"
/*
* Mini-DDE implementation
Most transactions involve a topic name and an item name (choose these
as befits your application).
A client can:
- ask the server to execute commands (data) associated with a topic
- request data from server by topic and item
- poke data into the server
- ask the server to start an advice loop on topic/item
- ask the server to stop an advice loop
A server can:
- respond to execute, request, poke and advice start/stop
- send advise data to client
Note that this limits the server in the ways it can send data to the
client, i.e. it can't send unsolicited information.
*
*/
class WXDLLIMPEXP_FWD_BASE wxDDEServer;
class WXDLLIMPEXP_FWD_BASE wxDDEClient;
class WXDLLIMPEXP_BASE wxDDEConnection : public wxConnectionBase
{
public:
wxDDEConnection(void *buffer, size_t size); // use external buffer
wxDDEConnection(); // use internal buffer
virtual ~wxDDEConnection();
// implement base class pure virtual methods
virtual const void *Request(const wxString& item,
size_t *size = NULL,
wxIPCFormat format = wxIPC_TEXT) wxOVERRIDE;
virtual bool StartAdvise(const wxString& item) wxOVERRIDE;
virtual bool StopAdvise(const wxString& item) wxOVERRIDE;
virtual bool Disconnect() wxOVERRIDE;
protected:
virtual bool DoExecute(const void *data, size_t size, wxIPCFormat format) wxOVERRIDE;
virtual bool DoPoke(const wxString& item, const void *data, size_t size,
wxIPCFormat format) wxOVERRIDE;
virtual bool DoAdvise(const wxString& item, const void *data, size_t size,
wxIPCFormat format) wxOVERRIDE;
public:
wxString m_topicName;
wxDDEServer* m_server;
wxDDEClient* m_client;
WXHCONV m_hConv;
const void* m_sendingData;
int m_dataSize;
wxIPCFormat m_dataType;
wxDECLARE_NO_COPY_CLASS(wxDDEConnection);
wxDECLARE_DYNAMIC_CLASS(wxDDEConnection);
};
class WXDLLIMPEXP_BASE wxDDEServer : public wxServerBase
{
public:
wxDDEServer();
bool Create(const wxString& server_name) wxOVERRIDE;
virtual ~wxDDEServer();
virtual wxConnectionBase *OnAcceptConnection(const wxString& topic) wxOVERRIDE;
// Find/delete wxDDEConnection corresponding to the HCONV
wxDDEConnection *FindConnection(WXHCONV conv);
bool DeleteConnection(WXHCONV conv);
wxString& GetServiceName() const { return (wxString&) m_serviceName; }
wxDDEConnectionList& GetConnections() const
{ return (wxDDEConnectionList&) m_connections; }
protected:
int m_lastError;
wxString m_serviceName;
wxDDEConnectionList m_connections;
wxDECLARE_DYNAMIC_CLASS(wxDDEServer);
};
class WXDLLIMPEXP_BASE wxDDEClient: public wxClientBase
{
public:
wxDDEClient();
virtual ~wxDDEClient();
bool ValidHost(const wxString& host) wxOVERRIDE;
// Call this to make a connection. Returns NULL if cannot.
virtual wxConnectionBase *MakeConnection(const wxString& host,
const wxString& server,
const wxString& topic) wxOVERRIDE;
// Tailor this to return own connection.
virtual wxConnectionBase *OnMakeConnection() wxOVERRIDE;
// Find/delete wxDDEConnection corresponding to the HCONV
wxDDEConnection *FindConnection(WXHCONV conv);
bool DeleteConnection(WXHCONV conv);
wxDDEConnectionList& GetConnections() const
{ return (wxDDEConnectionList&) m_connections; }
protected:
int m_lastError;
wxDDEConnectionList m_connections;
wxDECLARE_DYNAMIC_CLASS(wxDDEClient);
};
void WXDLLIMPEXP_BASE wxDDEInitialize();
void WXDLLIMPEXP_BASE wxDDECleanUp();
#endif // _WX_DDE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/dirdlg.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dirdlg.h
// Purpose: wxDirDialog class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DIRDLG_H_
#define _WX_DIRDLG_H_
class WXDLLIMPEXP_CORE wxDirDialog : public wxDirDialogBase
{
public:
wxDirDialog(wxWindow *parent,
const wxString& message = wxDirSelectorPromptStr,
const wxString& defaultPath = wxEmptyString,
long style = wxDD_DEFAULT_STYLE,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
const wxString& name = wxDirDialogNameStr);
void SetPath(const wxString& path) wxOVERRIDE;
virtual int ShowModal() wxOVERRIDE;
private:
// The real implementations of ShowModal(), used for Windows versions
// before and since Vista.
int ShowSHBrowseForFolder(WXHWND owner);
int ShowIFileDialog(WXHWND owner);
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxDirDialog);
};
#endif
// _WX_DIRDLG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/webview_missing.h | /////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/webview_missing.h
// Purpose: Definitions / classes commonly missing used by wxWebViewIE
// Author: Steven Lamerton
// Copyright: (c) 2012 Steven Lamerton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/*
* Classes and definitions used by wxWebViewIE vary in their
* completeness between compilers and versions of compilers.
* We implement our own versions here which should work
* for all compilers. The definitions are taken from the
* mingw-w64 headers which are public domain.
*/
/* urlmon.h */
struct IHTMLElement;
struct IHTMLDocument2;
#ifndef REFRESH_NORMAL
#define REFRESH_NORMAL 0
#endif
#ifndef REFRESH_COMPLETELY
#define REFRESH_COMPLETELY 3
#endif
typedef enum __wxMIDL_IBindStatusCallback_0006
{
wxBSCF_FIRSTDATANOTIFICATION = 0x1,
wxBSCF_INTERMEDIATEDATANOTIFICATION = 0x2,
wxBSCF_LASTDATANOTIFICATION = 0x4,
wxBSCF_DATAFULLYAVAILABLE = 0x8,
wxBSCF_AVAILABLEDATASIZEUNKNOWN = 0x10
} wxBSCF;
EXTERN_C const IID CLSID_FileProtocol;
typedef struct _tagwxBINDINFO
{
ULONG cbSize;
LPWSTR szExtraInfo;
STGMEDIUM stgmedData;
DWORD grfBindInfoF;
DWORD dwBindVerb;
LPWSTR szCustomVerb;
DWORD cbstgmedData;
DWORD dwOptions;
DWORD dwOptionsFlags;
DWORD dwCodePage;
SECURITY_ATTRIBUTES securityAttributes;
IID iid;
IUnknown *pUnk;
DWORD dwReserved;
} wxBINDINFO;
typedef struct _tagwxPROTOCOLDATA
{
DWORD grfFlags;
DWORD dwState;
LPVOID pData;
ULONG cbData;
} wxPROTOCOLDATA;
class wxIInternetBindInfo : public IUnknown
{
public:
virtual HRESULT wxSTDCALL GetBindInfo(DWORD *grfBINDF, wxBINDINFO *pbindinfo) = 0;
virtual HRESULT wxSTDCALL GetBindString(ULONG ulStringType, LPOLESTR *ppwzStr,
ULONG cEl, ULONG *pcElFetched) = 0;
};
class wxIInternetProtocolSink : public IUnknown
{
public:
virtual HRESULT wxSTDCALL Switch(wxPROTOCOLDATA *pProtocolData) = 0;
virtual HRESULT wxSTDCALL ReportProgress(ULONG ulStatusCode,
LPCWSTR szStatusText) = 0;
virtual HRESULT wxSTDCALL ReportData(DWORD grfBSCF, ULONG ulProgress,
ULONG ulProgressMax) = 0;
virtual HRESULT wxSTDCALL ReportResult(HRESULT hrResult, DWORD dwError,
LPCWSTR szResult) = 0;
};
class wxIInternetProtocolRoot : public IUnknown
{
public:
virtual HRESULT wxSTDCALL Start(LPCWSTR szUrl, wxIInternetProtocolSink *pOIProtSink,
wxIInternetBindInfo *pOIBindInfo, DWORD grfPI,
HANDLE_PTR dwReserved) = 0;
virtual HRESULT wxSTDCALL Continue(wxPROTOCOLDATA *pProtocolData) = 0;
virtual HRESULT wxSTDCALL Abort(HRESULT hrReason, DWORD dwOptions) = 0;
virtual HRESULT wxSTDCALL Terminate(DWORD dwOptions) = 0;
virtual HRESULT wxSTDCALL Suspend(void) = 0;
virtual HRESULT wxSTDCALL Resume(void) = 0;
};
class wxIInternetProtocol : public wxIInternetProtocolRoot
{
public:
virtual HRESULT wxSTDCALL Read(void *pv, ULONG cb, ULONG *pcbRead) = 0;
virtual HRESULT wxSTDCALL Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin,
ULARGE_INTEGER *plibNewPosition) = 0;
virtual HRESULT wxSTDCALL LockRequest(DWORD dwOptions) = 0;
virtual HRESULT wxSTDCALL UnlockRequest(void) = 0;
};
class wxIInternetSession : public IUnknown
{
public:
virtual HRESULT wxSTDCALL RegisterNameSpace(IClassFactory *pCF, REFCLSID rclsid,
LPCWSTR pwzProtocol,
ULONG cPatterns,
const LPCWSTR *ppwzPatterns,
DWORD dwReserved) = 0;
virtual HRESULT wxSTDCALL UnregisterNameSpace(IClassFactory *pCF,
LPCWSTR pszProtocol) = 0;
virtual HRESULT wxSTDCALL RegisterMimeFilter(IClassFactory *pCF,
REFCLSID rclsid,
LPCWSTR pwzType) = 0;
virtual HRESULT wxSTDCALL UnregisterMimeFilter(IClassFactory *pCF,
LPCWSTR pwzType) = 0;
virtual HRESULT wxSTDCALL CreateBinding(LPBC pBC, LPCWSTR szUrl,
IUnknown *pUnkOuter, IUnknown **ppUnk,
wxIInternetProtocol **ppOInetProt,
DWORD dwOption) = 0;
virtual HRESULT wxSTDCALL SetSessionOption(DWORD dwOption, LPVOID pBuffer,
DWORD dwBufferLength,
DWORD dwReserved) = 0;
virtual HRESULT wxSTDCALL GetSessionOption(DWORD dwOption, LPVOID pBuffer,
DWORD *pdwBufferLength,
DWORD dwReserved) = 0;
};
/* end of urlmon.h */
/* mshtmhst.h */
typedef enum _tagwxDOCHOSTUIFLAG
{
DOCHOSTUIFLAG_DIALOG = 0x1,
DOCHOSTUIFLAG_DISABLE_HELP_MENU = 0x2,
DOCHOSTUIFLAG_NO3DBORDER = 0x4,
DOCHOSTUIFLAG_SCROLL_NO = 0x8,
DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE = 0x10,
DOCHOSTUIFLAG_OPENNEWWIN = 0x20,
DOCHOSTUIFLAG_DISABLE_OFFSCREEN = 0x40,
DOCHOSTUIFLAG_FLAT_SCROLLBAR = 0x80,
DOCHOSTUIFLAG_DIV_BLOCKDEFAULT = 0x100,
DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY = 0x200,
DOCHOSTUIFLAG_OVERRIDEBEHAVIORFACTORY = 0x400,
DOCHOSTUIFLAG_CODEPAGELINKEDFONTS = 0x800,
DOCHOSTUIFLAG_URL_ENCODING_DISABLE_UTF8 = 0x1000,
DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8 = 0x2000,
DOCHOSTUIFLAG_ENABLE_FORMS_AUTOCOMPLETE = 0x4000,
DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION = 0x10000,
DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION = 0x20000,
DOCHOSTUIFLAG_THEME = 0x40000,
DOCHOSTUIFLAG_NOTHEME = 0x80000,
DOCHOSTUIFLAG_NOPICS = 0x100000,
DOCHOSTUIFLAG_NO3DOUTERBORDER = 0x200000,
DOCHOSTUIFLAG_DISABLE_EDIT_NS_FIXUP = 0x400000,
DOCHOSTUIFLAG_LOCAL_MACHINE_ACCESS_CHECK = 0x800000,
DOCHOSTUIFLAG_DISABLE_UNTRUSTEDPROTOCOL = 0x1000000,
DOCHOSTUIFLAG_ENABLE_REDIRECT_NOTIFICATION = 0x4000000
} DOCHOSTUIFLAG;
typedef struct _tagwxDOCHOSTUIINFO
{
ULONG cbSize;
DWORD dwFlags;
DWORD dwDoubleClick;
OLECHAR *pchHostCss;
OLECHAR *pchHostNS;
} DOCHOSTUIINFO;
class wxIDocHostUIHandler : public IUnknown
{
public:
virtual HRESULT wxSTDCALL ShowContextMenu(DWORD dwID, POINT *ppt,
IUnknown *pcmdtReserved,
IDispatch *pdispReserved) = 0;
virtual HRESULT wxSTDCALL GetHostInfo(DOCHOSTUIINFO *pInfo) = 0;
virtual HRESULT wxSTDCALL ShowUI(DWORD dwID,
IOleInPlaceActiveObject *pActiveObject,
IOleCommandTarget *pCommandTarget,
IOleInPlaceFrame *pFrame,
IOleInPlaceUIWindow *pDoc) = 0;
virtual HRESULT wxSTDCALL HideUI(void) = 0;
virtual HRESULT wxSTDCALL UpdateUI(void) = 0;
virtual HRESULT wxSTDCALL EnableModeless(BOOL fEnable) = 0;
virtual HRESULT wxSTDCALL OnDocWindowActivate(BOOL fActivate) = 0;
virtual HRESULT wxSTDCALL OnFrameWindowActivate(BOOL fActivate) = 0;
virtual HRESULT wxSTDCALL ResizeBorder(LPCRECT prcBorder,
IOleInPlaceUIWindow *pUIWindow,
BOOL fRameWindow) = 0;
virtual HRESULT wxSTDCALL TranslateAccelerator(LPMSG lpMsg,
const GUID *pguidCmdGroup,
DWORD nCmdID) = 0;
virtual HRESULT wxSTDCALL GetOptionKeyPath(LPOLESTR *pchKey,
DWORD dw) = 0;
virtual HRESULT wxSTDCALL GetDropTarget(IDropTarget *pDropTarget,
IDropTarget **ppDropTarget) = 0;
virtual HRESULT wxSTDCALL GetExternal(IDispatch **ppDispatch) = 0;
virtual HRESULT wxSTDCALL TranslateUrl(DWORD dwTranslate,
OLECHAR *pchURLIn,
OLECHAR **ppchURLOut) = 0;
virtual HRESULT wxSTDCALL FilterDataObject(IDataObject *pDO,
IDataObject **ppDORet) = 0;
};
/* end of mshtmhst.h */
/* mshtml.h */
typedef enum _tagwxPOINTER_GRAVITY
{
wxPOINTER_GRAVITY_Left = 0,
wxPOINTER_GRAVITY_Right = 1,
wxPOINTER_GRAVITY_Max = 2147483647
} wxPOINTER_GRAVITY;
typedef enum _tagwxELEMENT_ADJACENCY
{
wxELEM_ADJ_BeforeBegin = 0,
wxELEM_ADJ_AfterBegin = 1,
wxELEM_ADJ_BeforeEnd = 2,
wxELEM_ADJ_AfterEnd = 3,
wxELEMENT_ADJACENCY_Max = 2147483647
} wxELEMENT_ADJACENCY;
typedef enum _tagwxMARKUP_CONTEXT_TYPE
{
wxCONTEXT_TYPE_None = 0,
wxCONTEXT_TYPE_Text = 1,
wxCONTEXT_TYPE_EnterScope = 2,
wxCONTEXT_TYPE_ExitScope = 3,
wxCONTEXT_TYPE_NoScope = 4,
wxMARKUP_CONTEXT_TYPE_Max = 2147483647
} wxMARKUP_CONTEXT_TYPE;
typedef enum _tagwxFINDTEXT_FLAGS
{
wxFINDTEXT_BACKWARDS = 0x1,
wxFINDTEXT_WHOLEWORD = 0x2,
wxFINDTEXT_MATCHCASE = 0x4,
wxFINDTEXT_RAW = 0x20000,
wxFINDTEXT_MATCHDIAC = 0x20000000,
wxFINDTEXT_MATCHKASHIDA = 0x40000000,
wxFINDTEXT_MATCHALEFHAMZA = 0x80000000,
wxFINDTEXT_FLAGS_Max = 2147483647
} wxFINDTEXT_FLAGS;
typedef enum _tagwxMOVEUNIT_ACTION
{
wxMOVEUNIT_PREVCHAR = 0,
wxMOVEUNIT_NEXTCHAR = 1,
wxMOVEUNIT_PREVCLUSTERBEGIN = 2,
wxMOVEUNIT_NEXTCLUSTERBEGIN = 3,
wxMOVEUNIT_PREVCLUSTEREND = 4,
wxMOVEUNIT_NEXTCLUSTEREND = 5,
wxMOVEUNIT_PREVWORDBEGIN = 6,
wxMOVEUNIT_NEXTWORDBEGIN = 7,
wxMOVEUNIT_PREVWORDEND = 8,
wxMOVEUNIT_NEXTWORDEND = 9,
wxMOVEUNIT_PREVPROOFWORD = 10,
wxMOVEUNIT_NEXTPROOFWORD = 11,
wxMOVEUNIT_NEXTURLBEGIN = 12,
wxMOVEUNIT_PREVURLBEGIN = 13,
wxMOVEUNIT_NEXTURLEND = 14,
wxMOVEUNIT_PREVURLEND = 15,
wxMOVEUNIT_PREVSENTENCE = 16,
wxMOVEUNIT_NEXTSENTENCE = 17,
wxMOVEUNIT_PREVBLOCK = 18,
wxMOVEUNIT_NEXTBLOCK = 19,
wxMOVEUNIT_ACTION_Max = 2147483647
} wxMOVEUNIT_ACTION;
typedef enum _tagwxELEMENT_TAG_ID
{
wxTAGID_NULL = 0, wxTAGID_UNKNOWN = 1, wxTAGID_A = 2, wxTAGID_ACRONYM = 3,
wxTAGID_ADDRESS = 4, wxTAGID_APPLET = 5, wxTAGID_AREA = 6, wxTAGID_B = 7,
wxTAGID_BASE = 8, wxTAGID_BASEFONT = 9, wxTAGID_BDO = 10,
wxTAGID_BGSOUND = 11, wxTAGID_BIG = 12, wxTAGID_BLINK = 13,
wxTAGID_BLOCKQUOTE = 14, wxTAGID_BODY = 15, wxTAGID_BR = 16,
wxTAGID_BUTTON = 17, wxTAGID_CAPTION = 18, wxTAGID_CENTER = 19,
wxTAGID_CITE = 20, wxTAGID_CODE = 21, wxTAGID_COL = 22,
wxTAGID_COLGROUP = 23, wxTAGID_COMMENT = 24, wxTAGID_COMMENT_RAW = 25,
wxTAGID_DD = 26, wxTAGID_DEL = 27, wxTAGID_DFN = 28, wxTAGID_DIR = 29,
wxTAGID_DIV = 30, wxTAGID_DL = 31, wxTAGID_DT = 32, wxTAGID_EM = 33,
wxTAGID_EMBED = 34, wxTAGID_FIELDSET = 35, wxTAGID_FONT = 36,
wxTAGID_FORM = 37, wxTAGID_FRAME = 38, wxTAGID_FRAMESET = 39,
wxTAGID_GENERIC = 40, wxTAGID_H1 = 41, wxTAGID_H2 = 42, wxTAGID_H3 = 43,
wxTAGID_H4 = 44, wxTAGID_H5 = 45, wxTAGID_H6 = 46, wxTAGID_HEAD = 47,
wxTAGID_HR = 48, wxTAGID_HTML = 49, wxTAGID_I = 50, wxTAGID_IFRAME = 51,
wxTAGID_IMG = 52, wxTAGID_INPUT = 53, wxTAGID_INS = 54, wxTAGID_KBD = 55,
wxTAGID_LABEL = 56, wxTAGID_LEGEND = 57, wxTAGID_LI = 58, wxTAGID_LINK = 59,
wxTAGID_LISTING = 60, wxTAGID_MAP = 61, wxTAGID_MARQUEE = 62,
wxTAGID_MENU = 63, wxTAGID_META = 64, wxTAGID_NEXTID = 65,
wxTAGID_NOBR = 66, wxTAGID_NOEMBED = 67, wxTAGID_NOFRAMES = 68,
wxTAGID_NOSCRIPT = 69, wxTAGID_OBJECT = 70, wxTAGID_OL = 71,
wxTAGID_OPTION = 72, wxTAGID_P = 73, wxTAGID_PARAM = 74,
wxTAGID_PLAINTEXT = 75, wxTAGID_PRE = 76, wxTAGID_Q = 77, wxTAGID_RP = 78,
wxTAGID_RT = 79, wxTAGID_RUBY = 80, wxTAGID_S = 81, wxTAGID_SAMP = 82,
wxTAGID_SCRIPT = 83, wxTAGID_SELECT = 84, wxTAGID_SMALL = 85,
wxTAGID_SPAN = 86, wxTAGID_STRIKE = 87, wxTAGID_STRONG = 88,
wxTAGID_STYLE = 89, wxTAGID_SUB = 90, wxTAGID_SUP = 91, wxTAGID_TABLE = 92,
wxTAGID_TBODY = 93, wxTAGID_TC = 94, wxTAGID_TD = 95, wxTAGID_TEXTAREA = 96,
wxTAGID_TFOOT = 97, wxTAGID_TH = 98, wxTAGID_THEAD = 99,
wxTAGID_TITLE = 100, wxTAGID_TR = 101, wxTAGID_TT = 102, wxTAGID_U = 103,
wxTAGID_UL = 104, wxTAGID_VAR = 105, wxTAGID_WBR = 106, wxTAGID_XMP = 107,
wxTAGID_ROOT = 108, wxTAGID_OPTGROUP = 109, wxTAGID_COUNT = 110,
wxTAGID_LAST_PREDEFINED = 10000, wxELEMENT_TAG_ID_Max = 2147483647
} wxELEMENT_TAG_ID;
struct wxIHTMLStyle : public IDispatch
{
public:
virtual HRESULT wxSTDCALL put_fontFamily(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontFamily(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontVariant(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontVariant(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontWeight(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_fontWeight(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_fontSize(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_fontSize(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_font(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_font(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_color(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_color(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_background(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_background(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_backgroundColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundImage(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundRepeat(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundRepeat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundAttachment(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundAttachment(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundPosition(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_backgroundPosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundPositionX(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionX(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_backgroundPositionY(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionY(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_wordSpacing(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_wordSpacing(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_letterSpacing(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_letterSpacing(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_textDecoration(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_textDecoration(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationNone(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationNone(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationUnderline(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationUnderline(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationOverline(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationOverline(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationLineThrough(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationLineThrough(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_textDecorationBlink(VARIANT_BOOL v) = 0;
virtual HRESULT wxSTDCALL get_textDecorationBlink(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL put_verticalAlign(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_verticalAlign(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_textTransform(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_textTransform(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_textAlign(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_textAlign(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_textIndent(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_textIndent(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_lineHeight(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_lineHeight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginTop(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginRight(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginBottom(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_marginLeft(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_marginLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_margin(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_margin(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_paddingTop(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_paddingRight(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_paddingBottom(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_paddingLeft(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_paddingLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_padding(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_padding(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_border(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_border(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTop(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderTop(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderRight(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderRight(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottom(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderBottom(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeft(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderLeft(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderColor(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderColor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTopColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderTopColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderRightColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderRightColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottomColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderBottomColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeftColor(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderLeftColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderWidth(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderWidth(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTopWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderTopWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderRightWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderRightWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottomWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderBottomWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeftWidth(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_borderLeftWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_borderStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderTopStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderTopStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderRightStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderRightStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderBottomStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderBottomStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_borderLeftStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_borderLeftStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_width(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_width(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_height(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_height(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_styleFloat(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_styleFloat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_clear(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_clear(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_display(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_display(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_visibility(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_visibility(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStyleType(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStyleType(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStylePosition(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStylePosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStyleImage(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStyleImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_listStyle(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_listStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_whiteSpace(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_whiteSpace(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_top(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_top(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_left(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_left(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_position(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_zIndex(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_zIndex(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_overflow(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_overflow(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_pageBreakBefore(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_pageBreakBefore(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_pageBreakAfter(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_pageBreakAfter(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_cssText(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_cssText(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_pixelTop(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelTop(long *p) = 0;
virtual HRESULT wxSTDCALL put_pixelLeft(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelLeft(long *p) = 0;
virtual HRESULT wxSTDCALL put_pixelWidth(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelWidth(long *p) = 0;
virtual HRESULT wxSTDCALL put_pixelHeight(long v) = 0;
virtual HRESULT wxSTDCALL get_pixelHeight(long *p) = 0;
virtual HRESULT wxSTDCALL put_posTop(float v) = 0;
virtual HRESULT wxSTDCALL get_posTop(float *p) = 0;
virtual HRESULT wxSTDCALL put_posLeft(float v) = 0;
virtual HRESULT wxSTDCALL get_posLeft(float *p) = 0;
virtual HRESULT wxSTDCALL put_posWidth(float v) = 0;
virtual HRESULT wxSTDCALL get_posWidth(float *p) = 0;
virtual HRESULT wxSTDCALL put_posHeight(float v) = 0;
virtual HRESULT wxSTDCALL get_posHeight(float *p) = 0;
virtual HRESULT wxSTDCALL put_cursor(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_cursor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_clip(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_clip(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_filter(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_filter(BSTR *p) = 0;
virtual HRESULT wxSTDCALL setAttribute(BSTR strAttributeName, VARIANT AttributeValue, LONG lFlags = 1) = 0;
virtual HRESULT wxSTDCALL getAttribute(BSTR strAttributeName, LONG lFlags, VARIANT *AttributeValue) = 0;
virtual HRESULT wxSTDCALL removeAttribute(BSTR strAttributeName, LONG lFlags, VARIANT_BOOL *pfSuccess) = 0;
virtual HRESULT wxSTDCALL toString(BSTR *String) = 0;
};
struct wxIHTMLCurrentStyle : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_position(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_styleFloat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_color(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_fontFamily(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_fontStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_fontVariant(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_fontWeight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_fontSize(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionX(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundPositionY(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundRepeat(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderLeftColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderTopColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderRightColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderBottomColor(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderTopStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderRightStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderBottomStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderLeftStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderTopWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderRightWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderBottomWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_borderLeftWidth(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_left(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_top(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_width(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_height(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_paddingBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_textAlign(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textDecoration(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_display(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_visibility(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_zIndex(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_letterSpacing(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_lineHeight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_textIndent(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_verticalAlign(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_backgroundAttachment(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_marginTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_marginRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_marginBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_marginLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clear(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_listStyleType(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_listStylePosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_listStyleImage(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_clipTop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clipRight(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clipBottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_clipLeft(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_overflow(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_pageBreakBefore(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_pageBreakAfter(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_cursor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_tableLayout(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderCollapse(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_direction(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_behavior(BSTR *p) = 0;
virtual HRESULT wxSTDCALL getAttribute(BSTR strAttributeName, LONG lFlags, VARIANT *AttributeValue) = 0;
virtual HRESULT wxSTDCALL get_unicodeBidi(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_right(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_bottom(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_imeMode(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_rubyAlign(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_rubyPosition(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_rubyOverhang(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textAutospace(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_lineBreak(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_wordBreak(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textJustify(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textJustifyTrim(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textKashida(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_blockDirection(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridChar(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridLine(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridMode(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_layoutGridType(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderStyle(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderColor(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_borderWidth(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_padding(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_margin(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_accelerator(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_overflowX(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_overflowY(BSTR *p) = 0;
virtual HRESULT wxSTDCALL get_textTransform(BSTR *p) = 0;
};
struct wxIHTMLRect : public IDispatch
{
public:
virtual HRESULT wxSTDCALL put_left(long v) = 0;
virtual HRESULT wxSTDCALL get_left(long *p) = 0;
virtual HRESULT wxSTDCALL put_top(long v) = 0;
virtual HRESULT wxSTDCALL get_top(long *p) = 0;
virtual HRESULT wxSTDCALL put_right(long v) = 0;
virtual HRESULT wxSTDCALL get_right(long *p) = 0;
virtual HRESULT wxSTDCALL put_bottom(long v) = 0;
virtual HRESULT wxSTDCALL get_bottom(long *p) = 0;
};
struct wxIHTMLRectCollection : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_length(long *p) = 0;
virtual HRESULT wxSTDCALL get__newEnum(IUnknown **p) = 0;
virtual HRESULT wxSTDCALL item(VARIANT *pvarIndex, VARIANT *pvarResult) = 0;
};
struct wxIHTMLFiltersCollection : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_length(long *p) = 0;
virtual HRESULT wxSTDCALL get__newEnum(IUnknown **p) = 0;
virtual HRESULT wxSTDCALL item(VARIANT *pvarIndex, VARIANT *pvarResult) = 0;
};
struct wxIHTMLElementCollection : public IDispatch
{
public:
virtual HRESULT wxSTDCALL toString(BSTR *String) = 0;
virtual HRESULT wxSTDCALL put_length(long v) = 0;
virtual HRESULT wxSTDCALL get_length(long *p) = 0;
virtual HRESULT wxSTDCALL get__newEnum(IUnknown **p) = 0;
virtual HRESULT wxSTDCALL item(VARIANT name, VARIANT index, IDispatch **pdisp) = 0;
virtual HRESULT wxSTDCALL tags(VARIANT tagName, IDispatch **pdisp) = 0;
};
struct wxIHTMLElement2 : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_scopeName(BSTR *p) = 0;
virtual HRESULT wxSTDCALL setCapture(VARIANT_BOOL containerCapture = -1) = 0;
virtual HRESULT wxSTDCALL releaseCapture(void) = 0;
virtual HRESULT wxSTDCALL put_onlosecapture(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onlosecapture(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL componentFromPoint(long x, long y, BSTR *component) = 0;
virtual HRESULT wxSTDCALL doScroll(VARIANT component) = 0;
virtual HRESULT wxSTDCALL put_onscroll(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onscroll(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondrag(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondrag(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragend(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragend(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragenter(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragenter(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragover(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragover(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondragleave(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondragleave(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_ondrop(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_ondrop(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforecut(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforecut(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_oncut(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncut(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforecopy(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforecopy(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_oncopy(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncopy(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforepaste(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforepaste(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onpaste(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onpaste(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_currentStyle(wxIHTMLCurrentStyle **p) = 0;
virtual HRESULT wxSTDCALL put_onpropertychange(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onpropertychange(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL getClientRects(wxIHTMLRectCollection **pRectCol) = 0;
virtual HRESULT wxSTDCALL getBoundingClientRect(wxIHTMLRect **pRect) = 0;
virtual HRESULT wxSTDCALL setExpression(BSTR propname, BSTR expression, BSTR language) = 0;
virtual HRESULT wxSTDCALL getExpression(BSTR propname, VARIANT *expression) = 0;
virtual HRESULT wxSTDCALL removeExpression(BSTR propname, VARIANT_BOOL *pfSuccess) = 0;
virtual HRESULT wxSTDCALL put_tabIndex(short v) = 0;
virtual HRESULT wxSTDCALL get_tabIndex(short *p) = 0;
virtual HRESULT wxSTDCALL focus(void) = 0;
virtual HRESULT wxSTDCALL put_accessKey(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_accessKey(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_onblur(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onblur(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onfocus(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onfocus(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onresize(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onresize(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL blur(void) = 0;
virtual HRESULT wxSTDCALL addFilter(IUnknown *pUnk) = 0;
virtual HRESULT wxSTDCALL removeFilter(IUnknown *pUnk) = 0;
virtual HRESULT wxSTDCALL get_clientHeight(long *p) = 0;
virtual HRESULT wxSTDCALL get_clientWidth(long *p) = 0;
virtual HRESULT wxSTDCALL get_clientTop(long *p) = 0;
virtual HRESULT wxSTDCALL get_clientLeft(long *p) = 0;
virtual HRESULT wxSTDCALL attachEvent(BSTR event, IDispatch *pDisp, VARIANT_BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL detachEvent(BSTR event, IDispatch *pDisp) = 0;
virtual HRESULT wxSTDCALL get_readyState(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onreadystatechange(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onreadystatechange(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onrowsdelete(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onrowsdelete(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_onrowsinserted(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onrowsinserted(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_oncellchange(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncellchange(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL put_dir(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_dir(BSTR *p) = 0;
virtual HRESULT wxSTDCALL createControlRange(IDispatch **range) = 0;
virtual HRESULT wxSTDCALL get_scrollHeight(long *p) = 0;
virtual HRESULT wxSTDCALL get_scrollWidth(long *p) = 0;
virtual HRESULT wxSTDCALL put_scrollTop(long v) = 0;
virtual HRESULT wxSTDCALL get_scrollTop(long *p) = 0;
virtual HRESULT wxSTDCALL put_scrollLeft(long v) = 0;
virtual HRESULT wxSTDCALL get_scrollLeft(long *p) = 0;
virtual HRESULT wxSTDCALL clearAttributes(void) = 0;
virtual HRESULT wxSTDCALL mergeAttributes(IHTMLElement *mergeThis) = 0;
virtual HRESULT wxSTDCALL put_oncontextmenu(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_oncontextmenu(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL insertAdjacentElement(BSTR where, IHTMLElement *insertedElement, IHTMLElement **inserted) = 0;
virtual HRESULT wxSTDCALL applyElement(IHTMLElement *apply, BSTR where, IHTMLElement **applied) = 0;
virtual HRESULT wxSTDCALL getAdjacentText(BSTR where, BSTR *text) = 0;
virtual HRESULT wxSTDCALL replaceAdjacentText(BSTR where, BSTR newText, BSTR *oldText) = 0;
virtual HRESULT wxSTDCALL get_canHaveChildren(VARIANT_BOOL *p) = 0;
virtual HRESULT wxSTDCALL addBehavior(BSTR bstrUrl, VARIANT *pvarFactory, long *pCookie) = 0;
virtual HRESULT wxSTDCALL removeBehavior(long cookie, VARIANT_BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL get_runtimeStyle(wxIHTMLStyle **p) = 0;
virtual HRESULT wxSTDCALL get_behaviorUrns(IDispatch **p) = 0;
virtual HRESULT wxSTDCALL put_tagUrn(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_tagUrn(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_onbeforeeditfocus(VARIANT v) = 0;
virtual HRESULT wxSTDCALL get_onbeforeeditfocus(VARIANT *p) = 0;
virtual HRESULT wxSTDCALL get_readyStateValue(long *p) = 0;
virtual HRESULT wxSTDCALL getElementsByTagName(BSTR v,
wxIHTMLElementCollection **pelColl) = 0;
};
struct wxIHTMLTxtRange : public IDispatch
{
public:
virtual HRESULT wxSTDCALL get_htmlText(BSTR *p) = 0;
virtual HRESULT wxSTDCALL put_text(BSTR v) = 0;
virtual HRESULT wxSTDCALL get_text(BSTR *p) = 0;
virtual HRESULT wxSTDCALL parentElement(IHTMLElement **parent) = 0;
virtual HRESULT wxSTDCALL duplicate(wxIHTMLTxtRange **Duplicate) = 0;
virtual HRESULT wxSTDCALL inRange(wxIHTMLTxtRange *Range, VARIANT_BOOL *InRange) = 0;
virtual HRESULT wxSTDCALL isEqual(wxIHTMLTxtRange *Range, VARIANT_BOOL *IsEqual) = 0;
virtual HRESULT wxSTDCALL scrollIntoView(VARIANT_BOOL fStart = -1) = 0;
virtual HRESULT wxSTDCALL collapse(VARIANT_BOOL Start = -1) = 0;
virtual HRESULT wxSTDCALL expand(BSTR Unit, VARIANT_BOOL *Success) = 0;
virtual HRESULT wxSTDCALL move(BSTR Unit, long Count, long *ActualCount) = 0;
virtual HRESULT wxSTDCALL moveStart(BSTR Unit, long Count, long *ActualCount) = 0;
virtual HRESULT wxSTDCALL moveEnd(BSTR Unit, long Count, long *ActualCount) = 0;
virtual HRESULT wxSTDCALL select(void) = 0;
virtual HRESULT wxSTDCALL pasteHTML(BSTR html) = 0;
virtual HRESULT wxSTDCALL moveToElementText(IHTMLElement *element) = 0;
virtual HRESULT wxSTDCALL setEndPoint(BSTR how, wxIHTMLTxtRange *SourceRange) = 0;
virtual HRESULT wxSTDCALL compareEndPoints(BSTR how, wxIHTMLTxtRange *SourceRange, long *ret) = 0;
virtual HRESULT wxSTDCALL findText(BSTR String, long count, long Flags, VARIANT_BOOL *Success) = 0;
virtual HRESULT wxSTDCALL moveToPoint(long x, long y) = 0;
virtual HRESULT wxSTDCALL getBookmark(BSTR *Boolmark) = 0;
virtual HRESULT wxSTDCALL moveToBookmark(BSTR Bookmark, VARIANT_BOOL *Success) = 0;
virtual HRESULT wxSTDCALL queryCommandSupported(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandEnabled(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandState(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandIndeterm(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL queryCommandText(BSTR cmdID, BSTR *pcmdText) = 0;
virtual HRESULT wxSTDCALL queryCommandValue(BSTR cmdID, VARIANT *pcmdValue) = 0;
virtual HRESULT wxSTDCALL execCommand(BSTR cmdID, VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet) = 0;
virtual HRESULT wxSTDCALL execCommandShowHelp(BSTR cmdID, VARIANT_BOOL *pfRet) = 0;
};
struct wxIMarkupContainer : public IUnknown
{
public:
virtual HRESULT wxSTDCALL OwningDoc(IHTMLDocument2 **ppDoc) = 0;
};
struct wxIMarkupPointer : public IUnknown
{
public:
virtual HRESULT wxSTDCALL OwningDoc(IHTMLDocument2 **ppDoc) = 0;
virtual HRESULT wxSTDCALL Gravity(wxPOINTER_GRAVITY *pGravity) = 0;
virtual HRESULT wxSTDCALL SetGravity(wxPOINTER_GRAVITY Gravity) = 0;
virtual HRESULT wxSTDCALL Cling(BOOL *pfCling) = 0;
virtual HRESULT wxSTDCALL SetCling(BOOL fCLing) = 0;
virtual HRESULT wxSTDCALL Unposition(void) = 0;
virtual HRESULT wxSTDCALL IsPositioned(BOOL *pfPositioned) = 0;
virtual HRESULT wxSTDCALL GetContainer(wxIMarkupContainer **ppContainer) = 0;
virtual HRESULT wxSTDCALL MoveAdjacentToElement(IHTMLElement *pElement, wxELEMENT_ADJACENCY eAdj) = 0;
virtual HRESULT wxSTDCALL MoveToPointer(wxIMarkupPointer *pPointer) = 0;
virtual HRESULT wxSTDCALL MoveToContainer(wxIMarkupContainer *pContainer, BOOL fAtStart) = 0;
virtual HRESULT wxSTDCALL Left(BOOL fMove, wxMARKUP_CONTEXT_TYPE *pContext, IHTMLElement **ppElement, long *pcch, OLECHAR *pchText) = 0;
virtual HRESULT wxSTDCALL Right(BOOL fMove, wxMARKUP_CONTEXT_TYPE *pContext, IHTMLElement **ppElement, long *pcch, OLECHAR *pchText) = 0;
virtual HRESULT wxSTDCALL CurrentScope(IHTMLElement **ppElemCurrent) = 0;
virtual HRESULT wxSTDCALL IsLeftOf(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsLeftOfOrEqualTo(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsRightOf(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsRightOfOrEqualTo(wxIMarkupPointer *pPointerThat, BOOL *pfResult) = 0;
virtual HRESULT wxSTDCALL IsEqualTo(wxIMarkupPointer *pPointerThat, BOOL *pfAreEqual) = 0;
virtual HRESULT wxSTDCALL MoveUnit(wxMOVEUNIT_ACTION muAction) = 0;
virtual HRESULT wxSTDCALL FindText(OLECHAR *pchFindText, DWORD dwFlags, wxIMarkupPointer *pIEndMatch, wxIMarkupPointer *pIEndSearch) = 0;
};
struct wxIMarkupServices : public IUnknown
{
public:
virtual HRESULT wxSTDCALL CreateMarkupPointer(wxIMarkupPointer **ppPointer) = 0;
virtual HRESULT wxSTDCALL CreateMarkupContainer(wxIMarkupContainer **ppMarkupContainer) = 0;
virtual HRESULT wxSTDCALL CreateElement(wxELEMENT_TAG_ID tagID, OLECHAR *pchAttributes, IHTMLElement **ppElement) = 0;
virtual HRESULT wxSTDCALL CloneElement(IHTMLElement *pElemCloneThis, IHTMLElement **ppElementTheClone) = 0;
virtual HRESULT wxSTDCALL InsertElement(IHTMLElement *pElementInsert, wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL RemoveElement(IHTMLElement *pElementRemove) = 0;
virtual HRESULT wxSTDCALL Remove(wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL Copy(wxIMarkupPointer *pPointerSourceStart, wxIMarkupPointer *pPointerSourceFinish, wxIMarkupPointer *pPointerTarget) = 0;
virtual HRESULT wxSTDCALL Move(wxIMarkupPointer *pPointerSourceStart, wxIMarkupPointer *pPointerSourceFinish, wxIMarkupPointer *pPointerTarget) = 0;
virtual HRESULT wxSTDCALL InsertText(OLECHAR *pchText, long cch, wxIMarkupPointer *pPointerTarget) = 0;
virtual HRESULT wxSTDCALL ParseString(OLECHAR *pchHTML, DWORD dwFlags, wxIMarkupContainer **ppContainerResult, wxIMarkupPointer *ppPointerStart, wxIMarkupPointer *ppPointerFinish) = 0;
virtual HRESULT wxSTDCALL ParseGlobal(HGLOBAL hglobalHTML, DWORD dwFlags, wxIMarkupContainer **ppContainerResult, wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL IsScopedElement(IHTMLElement *pElement, BOOL *pfScoped) = 0;
virtual HRESULT wxSTDCALL GetElementTagId(IHTMLElement *pElement, wxELEMENT_TAG_ID *ptagId) = 0;
virtual HRESULT wxSTDCALL GetTagIDForName(BSTR bstrName, wxELEMENT_TAG_ID *ptagId) = 0;
virtual HRESULT wxSTDCALL GetNameForTagID(wxELEMENT_TAG_ID tagId, BSTR *pbstrName) = 0;
virtual HRESULT wxSTDCALL MovePointersToRange(wxIHTMLTxtRange *pIRange, wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish) = 0;
virtual HRESULT wxSTDCALL MoveRangeToPointers(wxIMarkupPointer *pPointerStart, wxIMarkupPointer *pPointerFinish, wxIHTMLTxtRange *pIRange) = 0;
virtual HRESULT wxSTDCALL BeginUndoUnit(OLECHAR *pchTitle) = 0;
virtual HRESULT wxSTDCALL EndUndoUnit(void) = 0;
};
/* end of mshtml.h */
/* WinInet.h */
#ifndef HTTP_STATUS_BAD_REQUEST
#define HTTP_STATUS_BAD_REQUEST 400
#endif
#ifndef HTTP_STATUS_DENIED
#define HTTP_STATUS_DENIED 401
#endif
#ifndef HTTP_STATUS_PAYMENT_REQ
#define HTTP_STATUS_PAYMENT_REQ 402
#endif
#ifndef HTTP_STATUS_FORBIDDEN
#define HTTP_STATUS_FORBIDDEN 403
#endif
#ifndef HTTP_STATUS_NOT_FOUND
#define HTTP_STATUS_NOT_FOUND 404
#endif
#ifndef HTTP_STATUS_BAD_METHOD
#define HTTP_STATUS_BAD_METHOD 405
#endif
#ifndef HTTP_STATUS_NONE_ACCEPTABLE
#define HTTP_STATUS_NONE_ACCEPTABLE 406
#endif
#ifndef HTTP_STATUS_PROXY_AUTH_REQ
#define HTTP_STATUS_PROXY_AUTH_REQ 407
#endif
#ifndef HTTP_STATUS_REQUEST_TIMEOUT
#define HTTP_STATUS_REQUEST_TIMEOUT 408
#endif
#ifndef HTTP_STATUS_CONFLICT
#define HTTP_STATUS_CONFLICT 409
#endif
#ifndef HTTP_STATUS_GONE
#define HTTP_STATUS_GONE 410
#endif
#ifndef HTTP_STATUS_LENGTH_REQUIRED
#define HTTP_STATUS_LENGTH_REQUIRED 411
#endif
#ifndef HTTP_STATUS_PRECOND_FAILED
#define HTTP_STATUS_PRECOND_FAILED 412
#endif
#ifndef HTTP_STATUS_REQUEST_TOO_LARGE
#define HTTP_STATUS_REQUEST_TOO_LARGE 413
#endif
#ifndef HTTP_STATUS_URI_TOO_LONG
#define HTTP_STATUS_URI_TOO_LONG 414
#endif
#ifndef HTTP_STATUS_UNSUPPORTED_MEDIA
#define HTTP_STATUS_UNSUPPORTED_MEDIA 415
#endif
#ifndef HTTP_STATUS_RETRY_WITH
#define HTTP_STATUS_RETRY_WITH 449
#endif
#ifndef HTTP_STATUS_SERVER_ERROR
#define HTTP_STATUS_SERVER_ERROR 500
#endif
#ifndef HTTP_STATUS_NOT_SUPPORTED
#define HTTP_STATUS_NOT_SUPPORTED 501
#endif
#ifndef HTTP_STATUS_BAD_GATEWAY
#define HTTP_STATUS_BAD_GATEWAY 502
#endif
#ifndef HTTP_STATUS_SERVICE_UNAVAIL
#define HTTP_STATUS_SERVICE_UNAVAIL 503
#endif
#ifndef HTTP_STATUS_GATEWAY_TIMEOUT
#define HTTP_STATUS_GATEWAY_TIMEOUT 504
#endif
#ifndef HTTP_STATUS_VERSION_NOT_SUP
#define HTTP_STATUS_VERSION_NOT_SUP 505
#endif
/* end of WinInet.h */
/* ShObjldl_core.h */
typedef enum _wxNWMF
{
wxNWMF_UNLOADING = 0x1,
wxNWMF_USERINITED = 0x2,
wxNWMF_FIRST = 0x4,
wxNWMF_OVERRIDEKEY = 0x8,
wxNWMF_SHOWHELP = 0x10,
wxNWMF_HTMLDIALOG = 0x20,
wxNWMF_FROMDIALOGCHILD = 0x40,
wxNWMF_USERREQUESTED = 0x80,
wxNWMF_USERALLOWED = 0x100,
wxNWMF_FORCEWINDOW = 0x10000,
wxNWMF_FORCETAB = 0x20000,
wxNWMF_SUGGESTWINDOW = 0x40000,
wxNWMF_SUGGESTTAB = 0x80000,
wxNWMF_INACTIVETAB = 0x100000
} _wxNWMF;
/* end of ShObjldl_core.h */
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/choice.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/choice.h
// Purpose: wxChoice class
// Author: Julian Smart
// Modified by: Vadim Zeitlin to derive from wxChoiceBase
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHOICE_H_
#define _WX_CHOICE_H_
struct tagCOMBOBOXINFO;
// ----------------------------------------------------------------------------
// Choice item
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxChoice : public wxChoiceBase
{
public:
// ctors
wxChoice() { Init(); }
virtual ~wxChoice();
wxChoice(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Init();
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxChoice(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Init();
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
virtual bool Show(bool show = true) wxOVERRIDE;
virtual void SetLabel(const wxString& label) wxOVERRIDE;
virtual unsigned int GetCount() const wxOVERRIDE;
virtual int GetSelection() const wxOVERRIDE;
virtual int GetCurrentSelection() const wxOVERRIDE;
virtual void SetSelection(int n) wxOVERRIDE;
virtual int FindString(const wxString& s, bool bCase = false) const wxOVERRIDE;
virtual wxString GetString(unsigned int n) const wxOVERRIDE;
virtual void SetString(unsigned int n, const wxString& s) wxOVERRIDE;
virtual wxVisualAttributes GetDefaultAttributes() const wxOVERRIDE
{
return GetClassDefaultAttributes(GetWindowVariant());
}
static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
// MSW only
virtual bool MSWCommand(WXUINT param, WXWORD id) wxOVERRIDE;
WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) wxOVERRIDE;
virtual WXHBRUSH MSWControlColor(WXHDC hDC, WXHWND hWnd) wxOVERRIDE;
virtual bool MSWShouldPreProcessMessage(WXMSG *pMsg) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
// returns true if the platform should explicitly apply a theme border
virtual bool CanApplyThemeBorder() const wxOVERRIDE { return false; }
protected:
// choose the default border for this window
virtual wxBorder GetDefaultBorder() const wxOVERRIDE { return wxBORDER_NONE; }
// common part of all ctors
void Init()
{
m_lastAcceptedSelection =
m_pendingSelection = wxID_NONE;
m_heightOwn = wxDefaultCoord;
}
virtual void DoDeleteOneItem(unsigned int n) wxOVERRIDE;
virtual void DoClear() wxOVERRIDE;
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type) wxOVERRIDE;
virtual void DoMoveWindow(int x, int y, int width, int height) wxOVERRIDE;
virtual void DoSetItemClientData(unsigned int n, void* clientData) wxOVERRIDE;
virtual void* DoGetItemClientData(unsigned int n) const wxOVERRIDE;
// MSW implementation
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual void DoGetSize(int *w, int *h) const wxOVERRIDE;
virtual void DoSetSize(int x, int y,
int width, int height,
int sizeFlags = wxSIZE_AUTO) wxOVERRIDE;
virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const wxOVERRIDE;
// Show or hide the popup part of the control.
void MSWDoPopupOrDismiss(bool show);
// update the height of the drop down list to fit the number of items we
// have (without changing the visible height)
void MSWUpdateDropDownHeight();
// set the height of the visible part of the control to m_heightOwn
void MSWUpdateVisibleHeight();
// create and initialize the control
bool CreateAndInit(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name);
// free all memory we have (used by Clear() and dtor)
void Free();
// set the height for simple combo box
int SetHeightSimpleComboBox(int nItems) const;
#if wxUSE_DEFERRED_SIZING
virtual void MSWEndDeferWindowPos() wxOVERRIDE;
#endif // wxUSE_DEFERRED_SIZING
// These variables are only used while the drop down is opened.
//
// The first one contains the item that had been originally selected before
// the drop down was opened and the second one the item we should select
// when the drop down is closed again.
int m_lastAcceptedSelection,
m_pendingSelection;
// the height of the control itself if it was set explicitly or
// wxDefaultCoord if it hadn't
int m_heightOwn;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxChoice);
};
#endif // _WX_CHOICE_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/bitmap.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/bitmap.h
// Purpose: wxBitmap class
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#include "wx/msw/gdiimage.h"
#include "wx/math.h"
#include "wx/palette.h"
class WXDLLIMPEXP_FWD_CORE wxBitmap;
class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;
class WXDLLIMPEXP_FWD_CORE wxBitmapRefData;
class WXDLLIMPEXP_FWD_CORE wxControl;
class WXDLLIMPEXP_FWD_CORE wxCursor;
class WXDLLIMPEXP_FWD_CORE wxDC;
#if wxUSE_WXDIB
class WXDLLIMPEXP_FWD_CORE wxDIB;
#endif
class WXDLLIMPEXP_FWD_CORE wxIcon;
class WXDLLIMPEXP_FWD_CORE wxMask;
class WXDLLIMPEXP_FWD_CORE wxPalette;
class WXDLLIMPEXP_FWD_CORE wxPixelDataBase;
// What kind of transparency should a bitmap copied from an icon or cursor
// have?
enum wxBitmapTransparency
{
wxBitmapTransparency_Auto, // default: copy alpha if the source has it
wxBitmapTransparency_None, // never create alpha
wxBitmapTransparency_Always // always use alpha
};
// ----------------------------------------------------------------------------
// wxBitmap: a mono or colour bitmap
// NOTE: for wxMSW we don't use the wxBitmapBase base class declared in bitmap.h!
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmap : public wxGDIImage,
public wxBitmapHelpers
{
public:
// default ctor creates an invalid bitmap, you must Create() it later
wxBitmap() { }
// Initialize with raw data
wxBitmap(const char bits[], int width, int height, int depth = 1);
// Initialize with XPM data
wxBitmap(const char* const* data);
#ifdef wxNEEDS_CHARPP
wxBitmap(char** data)
{
*this = wxBitmap(const_cast<const char* const*>(data));
}
#endif
// Load a file or resource
wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
// New constructor for generalised creation from data
wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth = 1);
// Create a new, uninitialized bitmap of the given size and depth (if it
// is omitted, will create a bitmap compatible with the display)
//
// NB: this ctor will create a DIB for 24 and 32bpp bitmaps, use ctor
// taking a DC argument if you want to force using DDB in this case
wxBitmap(int width, int height, int depth = -1) { (void)Create(width, height, depth); }
wxBitmap(const wxSize& sz, int depth = -1) { (void)Create(sz, depth); }
// Create a bitmap compatible with the given DC
wxBitmap(int width, int height, const wxDC& dc);
#if wxUSE_IMAGE
// Convert from wxImage
wxBitmap(const wxImage& image, int depth = -1, double WXUNUSED(scale) = 1.0)
{ (void)CreateFromImage(image, depth); }
// Create a DDB compatible with the given DC from wxImage
wxBitmap(const wxImage& image, const wxDC& dc)
{ (void)CreateFromImage(image, dc); }
#endif // wxUSE_IMAGE
// we must have this, otherwise icons are silently copied into bitmaps using
// the copy ctor but the resulting bitmap is invalid!
wxBitmap(const wxIcon& icon,
wxBitmapTransparency transp = wxBitmapTransparency_Auto)
{
CopyFromIcon(icon, transp);
}
// Convert from wxCursor
explicit wxBitmap(const wxCursor& cursor)
{
(void)CopyFromCursor(cursor, wxBitmapTransparency_Auto);
}
#if wxUSE_IMAGE
wxBitmap& operator=(const wxImage& image)
{
return *this = wxBitmap(image);
}
#endif // wxUSE_IMAGE
wxBitmap& operator=(const wxIcon& icon)
{
(void)CopyFromIcon(icon);
return *this;
}
#if WXWIN_COMPATIBILITY_3_0
// This assignment operator is not portable as it is not implemented in any
// other ports.
wxDEPRECATED_MSG("Don't assign wxCursor to an existing wxBitmap, create a new wxBitmap from wxCursor instead.")
wxBitmap& operator=(const wxCursor& cursor)
{
(void)CopyFromCursor(cursor);
return *this;
}
#endif // WXWIN_COMPATIBILITY_3_0
virtual ~wxBitmap();
#if wxUSE_IMAGE
wxImage ConvertToImage() const;
wxBitmap ConvertToDisabled(unsigned char brightness = 255) const;
#endif // wxUSE_IMAGE
// get the given part of bitmap
wxBitmap GetSubBitmap( const wxRect& rect ) const;
// NB: This should not be called from user code. It is for wx internal
// use only.
wxBitmap GetSubBitmapOfHDC( const wxRect& rect, WXHDC hdc ) const;
// copies the contents and mask of the given (colour) icon to the bitmap
bool CopyFromIcon(const wxIcon& icon,
wxBitmapTransparency transp = wxBitmapTransparency_Auto);
// copies the contents and mask of the given cursor to the bitmap
bool CopyFromCursor(const wxCursor& cursor,
wxBitmapTransparency transp = wxBitmapTransparency_Auto);
#if wxUSE_WXDIB
// copies from a device independent bitmap
bool CopyFromDIB(const wxDIB& dib);
bool IsDIB() const;
bool ConvertToDIB();
#endif
virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
virtual bool Create(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH)
{ return Create(sz.GetWidth(), sz.GetHeight(), depth); }
virtual bool Create(int width, int height, const wxDC& dc);
virtual bool Create(const void* data, wxBitmapType type, int width, int height, int depth = 1);
virtual bool CreateScaled(int w, int h, int d, double logicalScale)
{ return Create(wxRound(w*logicalScale), wxRound(h*logicalScale), d); }
virtual bool LoadFile(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
virtual bool SaveFile(const wxString& name, wxBitmapType type, const wxPalette *cmap = NULL) const;
wxBitmapRefData *GetBitmapData() const
{ return (wxBitmapRefData *)m_refData; }
// raw bitmap access support functions
void *GetRawData(wxPixelDataBase& data, int bpp);
void UngetRawData(wxPixelDataBase& data);
#if wxUSE_PALETTE
wxPalette* GetPalette() const;
void SetPalette(const wxPalette& palette);
#endif // wxUSE_PALETTE
wxMask *GetMask() const;
void SetMask(wxMask *mask);
// these functions are internal and shouldn't be used, they risk to
// disappear in the future
bool HasAlpha() const;
void UseAlpha(bool use = true);
void ResetAlpha() { UseAlpha(false); }
// support for scaled bitmaps
virtual double GetScaleFactor() const { return 1.0; }
virtual double GetScaledWidth() const { return GetWidth() / GetScaleFactor(); }
virtual double GetScaledHeight() const { return GetHeight() / GetScaleFactor(); }
virtual wxSize GetScaledSize() const
{ return wxSize(wxRound(GetScaledWidth()), wxRound(GetScaledHeight())); }
// implementation only from now on
// -------------------------------
// Set alpha flag to true if this is a 32bpp bitmap which has any non-0
// values in its alpha channel.
void MSWUpdateAlpha();
public:
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_INLINE(void SetHBITMAP(WXHBITMAP bmp), SetHandle((WXHANDLE)bmp); )
#endif // WXWIN_COMPATIBILITY_3_0
WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
bool InitFromHBITMAP(WXHBITMAP bmp, int width, int height, int depth);
void ResetHBITMAP() { InitFromHBITMAP(NULL, 0, 0, 0); }
void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const;
protected:
virtual wxGDIImageRefData *CreateData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
// creates an uninitialized bitmap, called from Create()s above
bool DoCreate(int w, int h, int depth, WXHDC hdc);
#if wxUSE_IMAGE
// creates the bitmap from wxImage, supposed to be called from ctor
bool CreateFromImage(const wxImage& image, int depth);
// creates a DDB from wxImage, supposed to be called from ctor
bool CreateFromImage(const wxImage& image, const wxDC& dc);
// common part of the 2 methods above (hdc may be 0)
bool CreateFromImage(const wxImage& image, int depth, WXHDC hdc);
#endif // wxUSE_IMAGE
private:
// common part of CopyFromIcon/CopyFromCursor for Win32
bool
CopyFromIconOrCursor(const wxGDIImage& icon,
wxBitmapTransparency transp = wxBitmapTransparency_Auto);
wxDECLARE_DYNAMIC_CLASS(wxBitmap);
};
// ----------------------------------------------------------------------------
// wxMask: a mono bitmap used for drawing bitmaps transparently.
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxMask : public wxObject
{
public:
wxMask();
// Copy constructor
wxMask(const wxMask &mask);
// Construct a mask from a bitmap and a colour indicating the transparent
// area
wxMask(const wxBitmap& bitmap, const wxColour& colour);
// Construct a mask from a bitmap and a palette index indicating the
// transparent area
wxMask(const wxBitmap& bitmap, int paletteIndex);
// Construct a mask from a mono bitmap (copies the bitmap).
wxMask(const wxBitmap& bitmap);
// construct a mask from the givne bitmap handle
wxMask(WXHBITMAP hbmp) { m_maskBitmap = hbmp; }
virtual ~wxMask();
bool Create(const wxBitmap& bitmap, const wxColour& colour);
bool Create(const wxBitmap& bitmap, int paletteIndex);
bool Create(const wxBitmap& bitmap);
wxBitmap GetBitmap() const;
// Implementation
WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
protected:
WXHBITMAP m_maskBitmap;
wxDECLARE_DYNAMIC_CLASS(wxMask);
};
// ----------------------------------------------------------------------------
// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
// NOTE: for wxMSW we don't use the wxBitmapHandler class declared in bitmap.h!
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxBitmapHandler : public wxGDIImageHandler
{
public:
wxBitmapHandler() { }
wxBitmapHandler(const wxString& name, const wxString& ext, wxBitmapType type)
: wxGDIImageHandler(name, ext, type) { }
// implement wxGDIImageHandler's pure virtuals:
virtual bool Create(wxGDIImage *image,
const void* data,
wxBitmapType type,
int width, int height, int depth = 1) wxOVERRIDE;
virtual bool Load(wxGDIImage *image,
const wxString& name,
wxBitmapType type,
int desiredWidth, int desiredHeight) wxOVERRIDE;
virtual bool Save(const wxGDIImage *image,
const wxString& name,
wxBitmapType type) const wxOVERRIDE;
// make wxBitmapHandler compatible with the wxBitmapHandler interface
// declared in bitmap.h, even if it's derived from wxGDIImageHandler:
virtual bool Create(wxBitmap *bitmap,
const void* data,
wxBitmapType type,
int width, int height, int depth = 1);
virtual bool LoadFile(wxBitmap *bitmap,
const wxString& name,
wxBitmapType type,
int desiredWidth, int desiredHeight);
virtual bool SaveFile(const wxBitmap *bitmap,
const wxString& name,
wxBitmapType type,
const wxPalette *palette = NULL) const;
private:
wxDECLARE_DYNAMIC_CLASS(wxBitmapHandler);
};
#endif
// _WX_BITMAP_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/uxtheme.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/uxtheme.h
// Purpose: wxUxThemeEngine class: support for XP themes
// Author: John Platts, Vadim Zeitlin
// Modified by:
// Created: 2003
// Copyright: (c) 2003 John Platts, Vadim Zeitlin
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UXTHEME_H_
#define _WX_UXTHEME_H_
#include "wx/defs.h"
#if wxUSE_UXTHEME
#include "wx/msw/private.h" // we use GetHwndOf()
#include <uxtheme.h>
#if defined(DTPB_WINDOWDC)
// DTPB_WINDOWDC has been added for Vista so it's save to assume that an SDK
// including it has vssym32.h available
#define HAVE_VSSYM32
#endif
#if defined(HAVE_VSSYM32)
#include <vssym32.h>
#else
#include <tmschema.h>
#endif
// ----------------------------------------------------------------------------
// Definitions for legacy Windows SDKs
// ----------------------------------------------------------------------------
// Some defintions introduced with Windows Vista might be missing in older SDKs
// Missing defintions are added here for compatiblity
#ifndef VSCLASS_LISTVIEW
#define LISS_NORMAL 1
#define LISS_HOT 2
#define LISS_SELECTED 3
#define LISS_DISABLED 4
#define LISS_SELECTEDNOTFOCUS 5
#define LISS_HOTSELECTED 6
#endif
#ifndef DTT_TEXTCOLOR
#define DTT_TEXTCOLOR (1UL << 0) // crText has been specified
#define DTT_STATEID (1UL << 8) // IStateId has been specified
#endif
#ifndef DSS_HIDEPREFIX
#define DSS_HIDEPREFIX 0x0200
#define DSS_PREFIXONLY 0x0400
#endif
#ifndef TMT_FONT
#define TMT_FONT 210
#endif
#ifndef HAVE_VSSYM32
enum EXPANDOBUTTONSTATES {
TDLGEBS_NORMAL = 1,
TDLGEBS_HOVER = 2,
TDLGEBS_PRESSED = 3,
TDLGEBS_EXPANDEDNORMAL = 4,
TDLGEBS_EXPANDEDHOVER = 5,
TDLGEBS_EXPANDEDPRESSED = 6,
TDLGEBS_NORMALDISABLED = 7,
TDLGEBS_EXPANDEDDISABLED = 8,
};
enum TASKDIALOGPARTS {
TDLG_PRIMARYPANEL = 1,
TDLG_MAININSTRUCTIONPANE = 2,
TDLG_MAINICON = 3,
TDLG_CONTENTPANE = 4,
TDLG_CONTENTICON = 5,
TDLG_EXPANDEDCONTENT = 6,
TDLG_COMMANDLINKPANE = 7,
TDLG_SECONDARYPANEL = 8,
TDLG_CONTROLPANE = 9,
TDLG_BUTTONSECTION = 10,
TDLG_BUTTONWRAPPER = 11,
TDLG_EXPANDOTEXT = 12,
TDLG_EXPANDOBUTTON = 13,
TDLG_VERIFICATIONTEXT = 14,
TDLG_FOOTNOTEPANE = 15,
TDLG_FOOTNOTEAREA = 16,
TDLG_FOOTNOTESEPARATOR = 17,
TDLG_EXPANDEDFOOTERAREA = 18,
TDLG_PROGRESSBAR = 19,
TDLG_IMAGEALIGNMENT = 20,
TDLG_RADIOBUTTONPANE = 21,
};
#define CP_BACKGROUND 2
#define CP_TRANSPARENTBACKGROUND 3
#define CP_BORDER 4
#define CP_READONLY 5
#define CP_DROPDOWNBUTTONRIGHT 6
#define CP_DROPDOWNBUTTONLEFT 7
#define CP_CUEBANNER 8
#define RP_BACKGROUND 6
#define RP_SPLITTER 7
#define RP_SPLITTERVERT 8
enum BORDERSTATES {
CBB_NORMAL = 1,
CBB_HOT = 2,
CBB_FOCUSED = 3,
CBB_DISABLED = 4,
};
// The MENUPARTS enum is defined in MSVS 2005 SDK, even though it doesn't have
// vssym32.h, but it doesn't define the constants we use, so still define them,
// but make the enum unnamed for compatibility.
enum /* MENUPARTS -- FIXME-VC8: uncomment this when support for it is dropped */
{
MENU_MENUITEM_TMSCHEMA = 1,
MENU_SEPARATOR_TMSCHEMA = 6,
MENU_POPUPBACKGROUND = 9,
MENU_POPUPBORDERS = 10,
MENU_POPUPCHECK = 11,
MENU_POPUPCHECKBACKGROUND = 12,
MENU_POPUPGUTTER = 13,
MENU_POPUPITEM = 14,
MENU_POPUPSEPARATOR = 15,
MENU_POPUPSUBMENU = 16,
};
enum POPUPITEMSTATES
{
MPI_NORMAL = 1,
MPI_HOT = 2,
MPI_DISABLED = 3,
MPI_DISABLEDHOT = 4,
};
enum POPUPCHECKBACKGROUNDSTATES
{
MCB_DISABLED = 1,
MCB_NORMAL = 2,
MCB_BITMAP = 3,
};
enum POPUPCHECKSTATES
{
MC_CHECKMARKNORMAL = 1,
MC_CHECKMARKDISABLED = 2,
MC_BULLETNORMAL = 3,
MC_BULLETDISABLED = 4,
};
#endif
// ----------------------------------------------------------------------------
// End definitions for legacy Windows SDKs
// ----------------------------------------------------------------------------
// Amazingly, GetThemeFont() and GetThemeSysFont() functions use LOGFONTA under
// XP but LOGFONTW (even in non-Unicode build) under later versions of Windows.
// If we declare them as taking LOGFONT below, the code would be able to
// silently pass LOGFONTA to them in ANSI build and would crash at run-time
// under Windows Vista/7 because of a buffer overrun (LOGFONTA being smaller
// than LOGFONTW expected by these functions). If we we declare them as taking
// LOGFONTW, the code wouldn't work correctly under XP. So we use a special
// wxUxThemeFont class to encapsulate this and intentionally change the LOGFONT
// output parameters of the theme functions to take it instead.
class wxUxThemeFont
{
public:
// Trivial default ctor.
wxUxThemeFont() { }
#if wxUSE_UNICODE
// In Unicode build we always use LOGFONT anyhow so this class is
// completely trivial.
LPLOGFONTW GetPtr() { return &m_lfW; }
const LOGFONTW& GetLOGFONT() { return m_lfW; }
#else // !wxUSE_UNICODE
// Return either LOGFONTA or LOGFONTW pointer as required by the current
// Windows version.
LPLOGFONTW GetPtr()
{
return UseLOGFONTW() ? &m_lfW
: reinterpret_cast<LPLOGFONTW>(&m_lfA);
}
// This method returns LOGFONT (i.e. LOGFONTA in ANSI build and LOGFONTW in
// Unicode one) which can be used with other, normal, Windows or wx
// functions. Internally it may need to transform LOGFONTW to LOGFONTA.
const LOGFONTA& GetLOGFONT()
{
if ( UseLOGFONTW() )
{
// Most of the fields are the same in LOGFONTA and LOGFONTW so just
// copy everything by default.
memcpy(&m_lfA, &m_lfW, sizeof(m_lfA));
// But the face name must be converted from Unicode.
WideCharToMultiByte(CP_ACP, 0, m_lfW.lfFaceName, -1,
m_lfA.lfFaceName, sizeof(m_lfA.lfFaceName),
NULL, NULL);
}
return m_lfA;
}
private:
static bool UseLOGFONTW()
{
return wxGetWinVersion() >= wxWinVersion_Vista;
}
LOGFONTA m_lfA;
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
private:
LOGFONTW m_lfW;
wxDECLARE_NO_COPY_CLASS(wxUxThemeFont);
};
WXDLLIMPEXP_CORE bool wxUxThemeIsActive();
// ----------------------------------------------------------------------------
// wxUxThemeHandle: encapsulates ::Open/CloseThemeData()
// ----------------------------------------------------------------------------
class wxUxThemeHandle
{
public:
wxUxThemeHandle(const wxWindow *win, const wchar_t *classes)
{
m_hTheme = (HTHEME)::OpenThemeData(GetHwndOf(win), classes);
}
operator HTHEME() const { return m_hTheme; }
~wxUxThemeHandle()
{
if ( m_hTheme )
{
::CloseThemeData(m_hTheme);
}
}
private:
HTHEME m_hTheme;
wxDECLARE_NO_COPY_CLASS(wxUxThemeHandle);
};
#else // !wxUSE_UXTHEME
inline bool wxUxThemeIsActive() { return false; }
#endif // wxUSE_UXTHEME/!wxUSE_UXTHEME
#endif // _WX_UXTHEME_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/mfc.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/mfc.h
// Purpose: Helpers for applications using both wxWidgets and MFC
// Author: Julian Smart, Vadim Zeitlin
// Created: 2017-12-01 (mostly extracted from samples/mfc)
// Copyright: (c) 2017 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_MFC_H_
#define _WX_MSW_MFC_H_
#ifndef __AFXWIN_H__
#error "MFC headers must be included before including this file."
#endif
#include "wx/app.h"
#include "wx/evtloop.h"
#include "wx/window.h"
#include "wx/msw/winundef.h"
// ----------------------------------------------------------------------------
// MFC window class wrapping a window created by wxWidgets
// ----------------------------------------------------------------------------
class wxMFCWnd : public CWnd
{
public:
// If default ctor is used, Attach() must be called later.
wxMFCWnd()
{
}
// Combines default ctor and Attach().
explicit wxMFCWnd(wxWindow* w)
{
Attach(w);
}
void Attach(wxWindow* w)
{
CWnd::Attach(w->GetHWND());
}
~wxMFCWnd()
{
// Prevent MFC from destroying the wxWindow.
Detach();
}
};
// ----------------------------------------------------------------------------
// MFC application class forwarding everything to wxApp
// ----------------------------------------------------------------------------
// The template parameter here is an existing class deriving from CWinApp or,
// if there is no such class, just CWinApp itself.
template <typename T>
class wxMFCApp : public T
{
public:
typedef T BaseApp;
BOOL InitInstance() wxOVERRIDE
{
if ( !BaseApp::InitInstance() )
return FALSE;
if ( !wxEntryStart(m_hInstance) )
return FALSE;
if ( !wxTheApp || !wxTheApp->CallOnInit() )
return FALSE;
if ( !InitMainWnd() )
return FALSE;
return TRUE;
}
int ExitInstance() wxOVERRIDE
{
delete m_pMainWnd;
m_pMainWnd = NULL;
if ( wxTheApp )
wxTheApp->OnExit();
wxEntryCleanup();
return BaseApp::ExitInstance();
}
// Override this to provide messages pre-processing for wxWidgets windows.
BOOL PreTranslateMessage(MSG *msg) wxOVERRIDE
{
// Use the current event loop if there is one, or just fall back to the
// standard one otherwise, but make sure we pre-process messages in any
// case as otherwise many things would break (e.g. keyboard
// accelerators).
wxGUIEventLoop*
evtLoop = static_cast<wxGUIEventLoop *>(wxEventLoop::GetActive());
wxGUIEventLoop evtLoopStd;
if ( !evtLoop )
evtLoop = &evtLoopStd;
if ( evtLoop->PreProcessMessage(msg) )
return TRUE;
return BaseApp::PreTranslateMessage(msg);
}
BOOL OnIdle(LONG lCount) wxOVERRIDE
{
BOOL moreIdle = BaseApp::OnIdle(lCount);
if ( wxTheApp )
{
wxTheApp->ProcessPendingEvents();
if ( wxTheApp->ProcessIdle() )
moreIdle = TRUE;
}
return moreIdle;
}
protected:
// This virtual method can be overridden to create the main window using
// MFC code. The default implementation relies on wxApp::OnInit() creating
// a top level window which is then wrapped in an MFC window and used as
// the main window.
virtual BOOL InitMainWnd()
{
wxWindow* const w = wxTheApp->GetTopWindow();
if ( !w )
return FALSE;
// We need to initialize the main window to let the program continue
// running.
m_pMainWnd = new wxMFCWnd(w);
// We also need to reset m_pMainWnd when this window will be destroyed
// to prevent MFC from using an invalid HWND, which is probably not
// fatal but can result in at least asserts failures.
w->Bind(wxEVT_DESTROY, &wxMFCApp::OnMainWindowDestroyed, this);
// And we need to let wxWidgets know that it should exit the
// application when this window is closed, as OnRun(), which does this
// by default, won't be called when using MFC main message loop.
wxTheApp->SetExitOnFrameDelete(true);
return TRUE;
}
private:
void OnMainWindowDestroyed(wxWindowDestroyEvent& event)
{
event.Skip();
delete m_pMainWnd;
m_pMainWnd = NULL;
}
};
typedef wxMFCApp<CWinApp> wxMFCWinApp;
// ----------------------------------------------------------------------------
// wxWidgets application class to be used in MFC applications
// ----------------------------------------------------------------------------
class wxAppWithMFC : public wxApp
{
public:
void ExitMainLoop() wxOVERRIDE
{
// There is no wxEventLoop to exit, tell MFC to stop pumping messages
// instead.
::PostQuitMessage(0);
}
void WakeUpIdle() wxOVERRIDE
{
// As above, we can't wake up any wx event loop, so try to wake up the
// MFC one instead.
CWinApp* const mfcApp = AfxGetApp();
if ( mfcApp && mfcApp->m_pMainWnd )
{
::PostMessage(mfcApp->m_pMainWnd->m_hWnd, WM_NULL, 0, 0);
}
}
};
#endif // _WX_MSW_MFC_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/ctrlsub.h | ///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/ctrlsub.h
// Purpose: common functionality of wxItemContainer-derived controls
// Author: Vadim Zeitlin
// Created: 2007-07-25
// Copyright: (c) 2007 Vadim Zeitlin <[email protected]>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_CTRLSUB_H_
#define _WX_MSW_CTRLSUB_H_
// ----------------------------------------------------------------------------
// wxControlWithItems
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxControlWithItems : public wxControlWithItemsBase
{
public:
wxControlWithItems() { }
protected:
// preallocate memory for inserting the given new items into the control
// using the wm message (normally either LB_INITSTORAGE or CB_INITSTORAGE)
void MSWAllocStorage(const wxArrayStringsAdapter& items, unsigned wm);
// insert or append a string to the controls using the given message
// (one of {CB,LB}_{ADD,INSERT}STRING, pos must be 0 when appending)
int MSWInsertOrAppendItem(unsigned pos, const wxString& item, unsigned wm);
// normally the control containing the items is this window itself but if
// the derived control is composed of several windows, this method can be
// overridden to return the real list/combobox control
virtual WXHWND MSWGetItemsHWND() const { return GetHWND(); }
private:
wxDECLARE_ABSTRACT_CLASS(wxControlWithItems);
wxDECLARE_NO_COPY_CLASS(wxControlWithItems);
};
#endif // _WX_MSW_CTRLSUB_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/commandlinkbutton.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/commandlinkbutton.h
// Purpose: wxCommandLinkButton class
// Author: Rickard Westerlund
// Created: 2010-06-11
// Copyright: (c) 2010 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_COMMANDLINKBUTTON_H_
#define _WX_MSW_COMMANDLINKBUTTON_H_
// ----------------------------------------------------------------------------
// Command link button for wxMSW
// ----------------------------------------------------------------------------
// Derive from the generic version to be able to fall back to it during
// run-time if the command link buttons are not supported by the system we're
// running under.
class WXDLLIMPEXP_ADV wxCommandLinkButton : public wxGenericCommandLinkButton
{
public:
wxCommandLinkButton () : wxGenericCommandLinkButton() { }
wxCommandLinkButton(wxWindow *parent,
wxWindowID id,
const wxString& mainLabel = wxEmptyString,
const wxString& note = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr)
: wxGenericCommandLinkButton()
{
Create(parent, id, mainLabel, note, pos, size, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxString& mainLabel = wxEmptyString,
const wxString& note = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxButtonNameStr);
// overridden base class methods
// -----------------------------
// do the same thing as in the generic case here
virtual void SetLabel(const wxString& label) wxOVERRIDE
{
SetMainLabelAndNote(label.BeforeFirst('\n'), label.AfterFirst('\n'));
}
virtual void SetMainLabelAndNote(const wxString& mainLabel,
const wxString& note) wxOVERRIDE;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const wxOVERRIDE;
protected:
virtual wxSize DoGetBestSize() const wxOVERRIDE;
virtual bool HasNativeBitmap() const wxOVERRIDE;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCommandLinkButton);
};
#endif // _WX_MSW_COMMANDLINKBUTTON_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/dragimag.h | /////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/dragimag.h
// Purpose: wxDragImage class: a kind of a cursor, that can cope
// with more sophisticated images
// Author: Julian Smart
// Modified by:
// Created: 08/04/99
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DRAGIMAG_H_
#define _WX_DRAGIMAG_H_
#if wxUSE_DRAGIMAGE
#include "wx/bitmap.h"
#include "wx/icon.h"
#include "wx/cursor.h"
#include "wx/treectrl.h"
#include "wx/listctrl.h"
// If 1, use a simple wxCursor instead of ImageList_SetDragCursorImage
#define wxUSE_SIMPLER_DRAGIMAGE 0
/*
To use this class, create a wxDragImage when you start dragging, for example:
void MyTreeCtrl::OnBeginDrag(wxTreeEvent& event)
{
#ifdef __WXMSW__
::UpdateWindow((HWND) GetHWND()); // We need to implement this in wxWidgets
#endif
CaptureMouse();
m_dragImage = new wxDragImage(* this, itemId);
m_dragImage->BeginDrag(wxPoint(0, 0), this);
m_dragImage->Move(pt, this);
m_dragImage->Show(this);
...
}
In your OnMouseMove function, hide the image, do any display updating required,
then move and show the image again:
void MyTreeCtrl::OnMouseMove(wxMouseEvent& event)
{
if (m_dragMode == MY_TREE_DRAG_NONE)
{
event.Skip();
return;
}
// Prevent screen corruption by hiding the image
if (m_dragImage)
m_dragImage->Hide(this);
// Do some updating of the window, such as highlighting the drop target
...
#ifdef __WXMSW__
if (updateWindow)
::UpdateWindow((HWND) GetHWND());
#endif
// Move and show the image again
m_dragImage->Move(event.GetPosition(), this);
m_dragImage->Show(this);
}
Eventually we end the drag and delete the drag image.
void MyTreeCtrl::OnLeftUp(wxMouseEvent& event)
{
...
// End the drag and delete the drag image
if (m_dragImage)
{
m_dragImage->EndDrag(this);
delete m_dragImage;
m_dragImage = NULL;
}
ReleaseMouse();
}
*/
/*
Notes for Unix version:
Can we simply use cursors instead, creating a cursor dynamically, setting it into the window
in BeginDrag, and restoring the old cursor in EndDrag?
For a really bog-standard implementation, we could simply use a normal dragging cursor
and ignore the image.
*/
/*
* wxDragImage
*/
class WXDLLIMPEXP_CORE wxDragImage: public wxObject
{
public:
// Ctors & dtor
////////////////////////////////////////////////////////////////////////////
wxDragImage();
wxDragImage(const wxBitmap& image, const wxCursor& cursor = wxNullCursor)
{
Init();
Create(image, cursor);
}
wxDragImage(const wxIcon& image, const wxCursor& cursor = wxNullCursor)
{
Init();
Create(image, cursor);
}
wxDragImage(const wxString& str, const wxCursor& cursor = wxNullCursor)
{
Init();
Create(str, cursor);
}
#if wxUSE_TREECTRL
wxDragImage(const wxTreeCtrl& treeCtrl, wxTreeItemId& id)
{
Init();
Create(treeCtrl, id);
}
#endif
#if wxUSE_LISTCTRL
wxDragImage(const wxListCtrl& listCtrl, long id)
{
Init();
Create(listCtrl, id);
}
#endif
virtual ~wxDragImage();
// Attributes
////////////////////////////////////////////////////////////////////////////
// Operations
////////////////////////////////////////////////////////////////////////////
// Create a drag image from a bitmap and optional cursor
bool Create(const wxBitmap& image, const wxCursor& cursor = wxNullCursor);
// Create a drag image from an icon and optional cursor
bool Create(const wxIcon& image, const wxCursor& cursor = wxNullCursor);
// Create a drag image from a string and optional cursor
bool Create(const wxString& str, const wxCursor& cursor = wxNullCursor);
#if wxUSE_TREECTRL
// Create a drag image for the given tree control item
bool Create(const wxTreeCtrl& treeCtrl, wxTreeItemId& id);
#endif
#if wxUSE_LISTCTRL
// Create a drag image for the given list control item
bool Create(const wxListCtrl& listCtrl, long id);
#endif
// Begin drag. hotspot is the location of the drag position relative to the upper-left
// corner of the image.
bool BeginDrag(const wxPoint& hotspot, wxWindow* window, bool fullScreen = false, wxRect* rect = NULL);
// Begin drag. hotspot is the location of the drag position relative to the upper-left
// corner of the image. This is full screen only. fullScreenRect gives the
// position of the window on the screen, to restrict the drag to.
bool BeginDrag(const wxPoint& hotspot, wxWindow* window, wxWindow* fullScreenRect);
// End drag
bool EndDrag();
// Move the image: call from OnMouseMove. Pt is in window client coordinates if window
// is non-NULL, or in screen coordinates if NULL.
bool Move(const wxPoint& pt);
// Show the image
bool Show();
// Hide the image
bool Hide();
// Implementation
////////////////////////////////////////////////////////////////////////////
// Initialize variables
void Init();
// Returns the native image list handle
WXHIMAGELIST GetHIMAGELIST() const { return m_hImageList; }
#if !wxUSE_SIMPLER_DRAGIMAGE
// Returns the native image list handle for the cursor
WXHIMAGELIST GetCursorHIMAGELIST() const { return m_hCursorImageList; }
#endif
// don't use in new code, use versions without hot spot parameter
#if WXWIN_COMPATIBILITY_2_8
wxDEPRECATED_CONSTRUCTOR( wxDragImage(const wxBitmap& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED_CONSTRUCTOR( wxDragImage(const wxString& str, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED_CONSTRUCTOR( wxDragImage(const wxIcon& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED( bool Create(const wxBitmap& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED( bool Create(const wxIcon& image, const wxCursor& cursor, const wxPoint& cursorHotspot) );
wxDEPRECATED( bool Create(const wxString& str, const wxCursor& cursor, const wxPoint& cursorHotspot) );
#endif // WXWIN_COMPATIBILITY_2_8
protected:
WXHIMAGELIST m_hImageList;
#if wxUSE_SIMPLER_DRAGIMAGE
wxCursor m_oldCursor;
#else
WXHIMAGELIST m_hCursorImageList;
#endif
wxCursor m_cursor;
// wxPoint m_cursorHotspot; // Obsolete
wxPoint m_position;
wxWindow* m_window;
wxRect m_boundingRect;
bool m_fullScreen;
private:
wxDECLARE_DYNAMIC_CLASS(wxDragImage);
wxDECLARE_NO_COPY_CLASS(wxDragImage);
};
#endif // wxUSE_DRAGIMAGE
#endif
// _WX_DRAGIMAG_H_
| h |
rticonnextdds-usecases | data/projects/rticonnextdds-usecases/VehicleTracking/ExampleCode/thirdparty/wxWidgets-3.1.2/Linux/include/wx/msw/taskbar.h | /////////////////////////////////////////////////////////////////////////
// File: wx/msw/taskbar.h
// Purpose: Defines wxTaskBarIcon class for manipulating icons on the
// Windows task bar.
// Author: Julian Smart
// Modified by: Vaclav Slavik
// Created: 24/3/98
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////
#ifndef _WX_TASKBAR_H_
#define _WX_TASKBAR_H_
#include "wx/icon.h"
// private helper class:
class WXDLLIMPEXP_FWD_CORE wxTaskBarIconWindow;
class WXDLLIMPEXP_CORE wxTaskBarIcon : public wxTaskBarIconBase
{
public:
wxTaskBarIcon(wxTaskBarIconType iconType = wxTBI_DEFAULT_TYPE);
virtual ~wxTaskBarIcon();
// Accessors
bool IsOk() const { return true; }
bool IsIconInstalled() const { return m_iconAdded; }
// Operations
bool SetIcon(const wxIcon& icon, const wxString& tooltip = wxEmptyString) wxOVERRIDE;
bool RemoveIcon(void) wxOVERRIDE;
bool PopupMenu(wxMenu *menu) wxOVERRIDE;
// MSW-specific class methods
#if wxUSE_TASKBARICON_BALLOONS
// show a balloon notification (the icon must have been already initialized
// using SetIcon)
//
// title and text are limited to 63 and 255 characters respectively, msec
// is the timeout, in milliseconds, before the balloon disappears (will be
// clamped down to the allowed 10-30s range by Windows if it's outside it)
// and flags can include wxICON_ERROR/INFO/WARNING to show a corresponding
// icon
//
// return true if balloon was shown, false on error (incorrect parameters
// or function unsupported by OS)
bool ShowBalloon(const wxString& title,
const wxString& text,
unsigned msec = 0,
int flags = 0,
const wxIcon& icon = wxNullIcon);
#endif // wxUSE_TASKBARICON_BALLOONS
protected:
friend class wxTaskBarIconWindow;
long WindowProc(unsigned int msg, unsigned int wParam, long lParam);
void RegisterWindowMessages();
wxTaskBarIconWindow *m_win;
bool m_iconAdded;
wxIcon m_icon;
wxString m_strTooltip;
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTaskBarIcon);
};
#endif // _WX_TASKBAR_H_
| h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.