MRPT  1.9.9
WxSubsystem.h
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 #pragma once
10 
11 #include <mrpt/config.h>
12 #include <mrpt/gui/gui_frwds.h>
14 #include <mrpt/math/TPoint2D.h>
16 #include <future>
17 #include <map>
18 #include <mutex>
19 #include <queue>
20 #include <thread>
21 
22 #if MRPT_HAS_WXWIDGETS
23 
24 #include <wx/app.h>
25 #include <wx/artprov.h>
26 #include <wx/bitmap.h>
27 #include <wx/busyinfo.h>
28 #include <wx/colordlg.h>
29 #include <wx/dcmemory.h>
30 #include <wx/dirdlg.h>
31 #include <wx/filedlg.h>
32 #include <wx/frame.h>
33 #include <wx/image.h>
34 #include <wx/imaglist.h>
35 #include <wx/intl.h>
36 #include <wx/log.h>
37 #include <wx/menu.h>
38 #include <wx/msgdlg.h>
39 #include <wx/pen.h>
40 #include <wx/progdlg.h>
41 #include <wx/sizer.h>
42 #include <wx/statbmp.h>
43 #include <wx/statusbr.h>
44 #include <wx/string.h>
45 #include <wx/textdlg.h>
46 #include <wx/timer.h>
47 #include <wx/toolbar.h>
48 
49 // The wxMathPlot library
50 #include <mrpt/3rdparty/mathplot/mathplot.h>
51 
52 #if 0
53 // The wxFreeChart library
54 #include <wx/bars/barplot.h>
55 #include <wx/chartpanel.h>
56 
57 #include <wx/axis/categoryaxis.h>
58 #include <wx/axis/dateaxis.h>
59 #include <wx/axis/numberaxis.h>
60 
61 #include <wx/xy/xydataset.h>
62 #include <wx/xy/xyhistorenderer.h>
63 #include <wx/xy/xylinerenderer.h>
64 #include <wx/xy/xyplot.h>
65 #include <wx/xy/xysimpledataset.h>
66 
67 #include <wx/xyz/bubbleplot.h>
68 #include <wx/xyz/xyzdataset.h>
69 
70 #include <wx/category/categorydataset.h>
71 #include <wx/category/categorysimpledataset.h>
72 #endif
73 
74 #endif
75 #include <mrpt/gui/gui_frwds.h>
76 
77 namespace mrpt::gui
78 {
79 /** This class implements the GUI thread required for the wxWidgets-based GUI.
80  * This system is employed internally by gui::CDisplayWindow and
81  * gui::CDisplayWindow3D, and must be not used in any way directly by the MRPT
82  * user.
83  *
84  * The system works by creating a invisible wxFrame that process timer events
85  * where it checks a queue of requests sent from the main MRPT thread. The
86  * requests include the creation, deletion,... of windows (2D/3D). In that
87  * way, just one thread is required for all the GUI windows, and the wxWidgets
88  * is initialized and clean-up correctly.
89  *
90  * This header should be included just from the implementation files of
91  * CDisplayWindow and CDisplayWindow3D, since it uses wxWidgets classes.
92  *
93  * \sa gui::CDisplayWindow, gui::CDisplayWindow3D
94  * \ingroup mrpt_gui_grp
95  */
97 {
98 #if MRPT_HAS_WXWIDGETS
99 
100  public:
101  /** This method must be called in the destructor of the user class FROM THE
102  * MAIN THREAD, in order to wait for the shutdown of the wx thread if this
103  * was the last open window.
104  */
105  static void waitWxShutdownsIfNoWindows();
106 
107  /** Will be set to true at runtime if it's not detected a running wxApp
108  * instance.
109  * For console apps, we'll create a new thread and run wxEntry from there.
110  * For GUI apps (MRPT-based Windows are a part of a user wxWidget apps),
111  * we must leave the control of
112  * message dispatching to the current main loop, so we cannot create a
113  * different threads, making things a little different (hence this
114  * variable).
115  */
116  static bool isConsoleApp();
117 
118  /** An auxiliary global object used just to launch a final request to the
119  * wxSubsystem for shutdown:
120  */
122  {
123  public:
126  };
127 
129 
130  /** The main frame of the wxWidgets application
131  */
132  class CWXMainFrame : public wxFrame
133  {
135 
136  public:
137  CWXMainFrame(wxWindow* parent, wxWindowID id = -1);
138  ~CWXMainFrame() override;
139 
140  /** Atomically increments the number of windows created with the main
141  * frame as parent.
142  * \return The updated number of windows.
143  */
144  static int notifyWindowCreation();
145 
146  /** Atomically decrements the number of windows created with the main
147  * frame as parent.
148  * \return The updated number of windows (0 if the calling was the last
149  * one).
150  */
151  static int notifyWindowDestruction();
152 
153  static volatile CWXMainFrame* oneInstance;
154 
155  private:
156  static std::mutex cs_windowCount;
157  static int m_windowCount;
158 
159  wxTimer* m_theTimer;
160 
161  void OnTimerProcessRequests(wxTimerEvent& event);
162 
163  DECLARE_EVENT_TABLE()
164 
165  }; // end class CWXMainFrame
166 
168  {
169  /** The thread ID of wxMainThread, or 0 if it is not running. */
170  std::thread m_wxMainThreadId;
171  /** This is signaled when wxMainThread is ready. */
172  std::promise<void> m_semWxMainThreadReady;
173  std::promise<void> m_done;
174  /** The critical section for accessing "m_wxMainThreadId" */
175  std::mutex m_csWxMainThreadId;
176  };
177 
179 
180  /** This will be the "MAIN" of wxWidgets: It starts an application object
181  * and does not end until all the windows are closed.
182  * Only one instance of this thread can be running at a given instant, no
183  * matter how many windows are open.
184  */
185  static void wxMainThread();
186 
187  /** The data structure for each inter-thread request:
188  */
190  {
191  TRequestToWxMainThread() = default;
192 
193  /** Only one of source* can be non-nullptr, indicating the class that
194  * generated the request. */
196 
197  /** Only one of source* can be non-nullptr, indicating the class that
198  * generated the request. */
200 
201  /** Only one of source* can be non-nullptr, indicating the class that
202  * generated the request. */
204 
205  /** Only one of source* can be non-nullptr, indicating the class that
206  * generated the request. */
208 
209  /** Parameters, depending on OPCODE.
210  */
212 
213  /** Parameters, depending on OPCODE.
214  */
215  void *voidPtr{nullptr}, *voidPtr2{nullptr};
216  int x{400}, y{400};
217  bool boolVal{false};
220 
221  /** Valid codes are:
222  * For CDisplayWindow:
223  * - 200: Create a new 2D window, with caption "str" and initial
224  *size "x" & "y", and save the "wxFrame*" in the "void**" passed in
225  *voidPtr.
226  * - 201: Updates the image shown in the window, from a "wxImage*"
227  *passed in voidPtr2. The wxImage object will be freed with delete
228  *after that. voidPtr must be a "wxFrame*", a "CWindowDialog*"
229  *actually.
230  * - 202: Set position to x,y
231  * - 203: Change size to x,y
232  * - 204: Change title to "str"
233  * - 299: Delete the window associated with this source object.
234  *
235  * For CDisplayWindow3D:
236  * - 300: Create a new 3D window, with caption "str" and initial
237  *size "x" & "y", and save the "wxFrame*" in the "void**" passed in
238  *voidPtr.
239  * - 302: Set position to x,y
240  * - 303: Change size to x,y
241  * - 304: Change title to "str"
242  * - 350: Force refresh
243  * - 360: Add a 2D text message: vector_x: [0]:x, [1]:y, [2,3,4]:R
244  *G
245  *B, "x": enum of desired font. "y": unique index, "str": String.
246  * - 361: Clear all 2D text messages.
247  * - 362: Add a 2D text message (vectorized fonts)
248  * - 370: Change min/max range: min=vector_x[0], max=vector_x[1]
249  * - 399: Delete the window associated with this source object.
250  *
251  * For CDisplayWindowPlots:
252  * - 400: Create a new Plots window, with caption "str" and initial
253  *size "x" & "y",and save the "wxFrame*" in the "void**" passed in
254  *voidPtr.
255  * - 402: Set position to x,y
256  * - 403: Change size to x,y
257  * - 404: Change title to "str"
258  * - 499: Delete the window associated with this source object.
259  * - 410: Depending on "boolVal", enable/disable the mouse-zoom &
260  *pan
261  * - 411: Depending on "boolVal", enable/disable the aspect ratio
262  *fix
263  * - 412: Zoom over a rectangle vectorx[0-1] & vectory[0-1]
264  * - 413: Axis fit, with aspect ratio fix to boolVal.
265  * - 414: Clear all plot objects.
266  * - 420: Add/update a 2D line/points plot: x/y data=
267  *vector_x/vector_y, format string=str, plot name =plotName.
268  * - 421: Add/update a 2D ellipse: format string=str, plot name
269  *=plotName, vector_x[0,1]:X/Y center, vector_x[2]:quantiles,
270  *vector_y[0,1,2]: Covariance matrix entries 00,11,01,
271  *boolVal=showName?
272  * - 422: Add/update a bitmap: plot name =plotName,
273  *vector_x[0,1]:X/Y
274  *corner, vector_x[2,3]: X/Y widths, voidPtr2: pointer to a newly
275  *created wxImage with the bitmap.
276  * - 440: Insert submenu in the popup menu. plotName=menu label,
277  *x=user-defined ID.
278  * - 700: Shows a camera-pick-dialog and wait for user selection.
279  *"voidPtr" must point to a CSemaphore, which will be signaled twice
280  *(1st upon construction, 2nd upon dialog close); voidPtr2 must point
281  *to a "mrpt::gui::CPanelCameraSelection*" which will be filled with
282  *the selection (the panel must be deleted by the caller)
283  *
284  */
285  int OPCODE;
286  };
287 
288  /** Thread-safe method to return the next pending request, or nullptr if
289  * there is none (After usage, FREE the memory!)
290  */
292 
293  /** Thread-safe method to insert a new pending request (The memory must be
294  * dinamically allocated with "new T[1]", will be freed by receiver.)
295  */
297 
298  /** Thread-safe method to create one single instance of the main wxWidgets
299  * thread: it will create the thread only if it is not running yet.
300  */
301  static bool createOneInstanceMainThread();
302 
303  static wxBitmap getMRPTDefaultIcon();
304 
305  private:
306  /** Do not access directly to this, use the thread-safe functions
307  */
308  static std::queue<TRequestToWxMainThread*>* listPendingWxRequests;
309  static std::mutex* cs_listPendingWxRequests;
310 #endif
311 }; // End of class def.
312 
313 #if MRPT_HAS_WXWIDGETS
314 
315 /** The wx dialog for gui::CDisplayWindow
316  */
317 class CWindowDialog : public wxFrame
318 {
319  public:
320  /** A custom control to display the bitmap and avoid flicker
321  */
322  class wxMRPTImageControl : public wxPanel
323  {
324  protected:
325  wxBitmap* m_img;
326  std::mutex m_img_cs;
328 
329  public:
331  wxWindow* parent, wxWindowID winID, int x, int y, int width,
332  int height);
333  ~wxMRPTImageControl() override;
334 
336  // std::mutex m_mouse_cs;
337 
338  /** Assigns this image. This object has the ownship of the image and
339  * will delete it when appropriate. */
340  void AssignImage(wxBitmap* img);
341  void GetBitmap(wxBitmap& bmp);
342 
343  void OnPaint(wxPaintEvent& ev);
344  void OnMouseMove(wxMouseEvent& ev);
345  void OnMouseClick(wxMouseEvent& ev);
346  void OnChar(wxKeyEvent& ev);
347 
348  void OnEraseBackground(wxEraseEvent& ev)
349  { /* Do nothing */
350  }
351  };
352 
353  public:
356  wxWindowID id = -1,
357  const std::string& caption = std::string("[MRPT-CDisplayWindow]"),
358  wxSize initialSize = wxDefaultSize);
359  ~CWindowDialog() override;
360 
363 
364  // wxStaticBitmap *m_image;
366 
367  static const long ID_IMAGE_BITMAP;
368 
369  private:
370  void OnClose(wxCloseEvent& event);
371  void OnMenuClose(wxCommandEvent& event);
372  void OnMenuAbout(wxCommandEvent& event);
373  void OnMenuSave(wxCommandEvent& event);
374  void OnChar(wxKeyEvent& event);
375  void OnKeyDown(wxKeyEvent& event);
376  void OnResize(wxSizeEvent& event);
377  void OnMouseDown(wxMouseEvent& event);
378  void OnMouseMove(wxMouseEvent& event);
379 
380  DECLARE_EVENT_TABLE()
381 }; // end class CWindowDialog
382 
383 class C3DWindowDialog : public wxFrame
384 {
386 
387  public:
390  wxWindowID id = -1,
391  const std::string& caption = std::string("[MRPT-CDisplayWindow3D]"),
392  wxSize initialSize = wxDefaultSize);
393  ~C3DWindowDialog() override;
394 
397 
398  CMyGLCanvas_DisplayWindow3D* m_canvas;
399 
400  void clearTextMessages();
401  void addTextMessage(
402  const double x_frac, const double y_frac, const std::string& text,
403  const mrpt::img::TColorf& color, const size_t unique_index,
404  const mrpt::opengl::TOpenGLFont font);
405  void addTextMessage(
406  const double x_frac, const double y_frac, const std::string& text,
407  const mrpt::img::TColorf& color, const std::string& font_name,
408  const double font_size, const mrpt::opengl::TOpenGLFontStyle font_style,
409  const size_t unique_index, const double font_spacing,
410  const double font_kerning, const bool has_shadow,
411  const mrpt::img::TColorf& shadow_color);
412 
413  private:
414  void OnClose(wxCloseEvent& event);
415  void OnMenuClose(wxCommandEvent& event);
416  void OnMenuAbout(wxCommandEvent& event);
417  void OnChar(wxKeyEvent& event);
418  void OnResize(wxSizeEvent& event);
419 
420  static const long ID_MENUITEM1;
421  static const long ID_MENUITEM2;
422 
423  DECLARE_EVENT_TABLE()
424 };
425 
426 /** The wx dialog for gui::CDisplayWindowPlots
427  */
428 class CWindowDialogPlots : public wxFrame
429 {
430  public:
433  wxWindowID id = -1,
434  const std::string& caption = std::string("[MRPT-CDisplayWindowPlots]"),
435  wxSize initialSize = wxDefaultSize);
436  ~CWindowDialogPlots() override;
437 
440 
441  mpWindow* m_plot;
442  // wxChartPanel *m_chartPanel;
443  static const long ID_PLOT;
444  static const long ID_MENU_PRINT;
445  /** to know whether to insert a separator the first time. */
447  /** wxIDs to user IDs for submenus. */
448  std::map<long, long> m_ID2ID;
449  /** In graph coords */
451  /** In pixels */
453 
454  void OnMenuSelected(wxCommandEvent& ev);
455  void OnMouseMove(wxMouseEvent& event);
456 
457  /** Redirected from CDisplayWindowPlots::plot
458  */
459  void plot(
461  const std::string& lineFormat, const std::string& plotName);
462 
463  /** Redirected from CDisplayWindowPlots::plotEllipse
464  */
465  void plotEllipse(
467  const std::string& lineFormat, const std::string& plotName,
468  bool showName = false);
469 
470  /** Redirected from CDisplayWindowPlots::image
471  */
472  void image(
473  void* theWxImage, const float& x0, const float& y0, const float& w,
474  const float& h, const std::string& plotName);
475 
476  private:
477  void OnClose(wxCloseEvent& event);
478  void OnMenuPrint(wxCommandEvent& event);
479  void OnMenuClose(wxCommandEvent& event);
480  void OnMenuAbout(wxCommandEvent& event);
481  void OnChar(wxKeyEvent& event);
482  void OnResize(wxSizeEvent& event);
483  void OnMouseDown(wxMouseEvent& event);
484 
485  DECLARE_EVENT_TABLE()
486 }; // end class CWindowDialog
487 
488 #endif
489 
490 } // namespace mrpt::gui
An auxiliary global object used just to launch a final request to the wxSubsystem for shutdown: ...
Definition: WxSubsystem.h:121
std::map< long, long > m_ID2ID
wxIDs to user IDs for submenus.
Definition: WxSubsystem.h:448
static void pushPendingWxRequest(TRequestToWxMainThread *data)
Thread-safe method to insert a new pending request (The memory must be dinamically allocated with "ne...
void * voidPtr
Parameters, depending on OPCODE.
Definition: WxSubsystem.h:215
void OnMenuAbout(wxCommandEvent &event)
static TRequestToWxMainThread * popPendingWxRequest()
Thread-safe method to return the next pending request, or nullptr if there is none (After usage...
void OnClose(wxCloseEvent &event)
mrpt::gui::CDisplayWindow3D * source3D
Only one of source* can be non-nullptr, indicating the class that generated the request.
Definition: WxSubsystem.h:199
void OnMenuSave(wxCommandEvent &event)
friend class gui::CMyGLCanvas_DisplayWindow3D
Definition: WxSubsystem.h:385
void OnResize(wxSizeEvent &event)
The data structure for each inter-thread request:
Definition: WxSubsystem.h:189
void addTextMessage(const double x_frac, const double y_frac, const std::string &text, const mrpt::img::TColorf &color, const size_t unique_index, const mrpt::opengl::TOpenGLFont font)
Template for column vectors of dynamic size, compatible with Eigen.
Create a GUI window and display plots with MATLAB-like interfaces and commands.
static int notifyWindowCreation()
Atomically increments the number of windows created with the main frame as parent.
void AssignImage(wxBitmap *img)
Assigns this image.
void OnTimerProcessRequests(wxTimerEvent &event)
This method processes the pending requests from the main MRPT application thread. ...
static std::mutex * cs_listPendingWxRequests
Definition: WxSubsystem.h:309
std::thread m_wxMainThreadId
The thread ID of wxMainThread, or 0 if it is not running.
Definition: WxSubsystem.h:170
void OnMenuClose(wxCommandEvent &event)
The wx dialog for gui::CDisplayWindowPlots.
Definition: WxSubsystem.h:428
void OnMenuClose(wxCommandEvent &event)
wxPoint m_last_mouse_point
In pixels.
Definition: WxSubsystem.h:452
static wxBitmap getMRPTDefaultIcon()
CDisplayWindow3D * m_win3D
Definition: WxSubsystem.h:395
static volatile CWXMainFrame * oneInstance
Definition: WxSubsystem.h:153
C3DWindowDialog(CDisplayWindow3D *win3D, WxSubsystem::CWXMainFrame *parent, wxWindowID id=-1, const std::string &caption=std::string("[MRPT-CDisplayWindow3D]"), wxSize initialSize=wxDefaultSize)
std::mutex m_csWxMainThreadId
The critical section for accessing "m_wxMainThreadId".
Definition: WxSubsystem.h:175
static TWxMainThreadData & GetWxMainThreadInstance()
wxMRPTImageControl(wxWindow *parent, wxWindowID winID, int x, int y, int width, int height)
void OnResize(wxSizeEvent &event)
WxSubsystem::CWXMainFrame * m_mainFrame
Definition: WxSubsystem.h:439
int OPCODE
Valid codes are: For CDisplayWindow:
Definition: WxSubsystem.h:285
GLenum GLsizei width
Definition: glext.h:3535
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:4199
void OnChar(wxKeyEvent &event)
static std::queue< TRequestToWxMainThread * > * listPendingWxRequests
Do not access directly to this, use the thread-safe functions.
Definition: WxSubsystem.h:308
static const long ID_MENUITEM1
Definition: WxSubsystem.h:420
CWindowDialogPlots(CDisplayWindowPlots *winPlots, WxSubsystem::CWXMainFrame *parent, wxWindowID id=-1, const std::string &caption=std::string("[MRPT-CDisplayWindowPlots]"), wxSize initialSize=wxDefaultSize)
wxMRPTImageControl * m_image
Definition: WxSubsystem.h:365
CDisplayWindowPlots * m_winPlots
Definition: WxSubsystem.h:438
static const long ID_PLOT
Definition: WxSubsystem.h:443
void OnKeyDown(wxKeyEvent &event)
GLuint color
Definition: glext.h:8459
void OnMouseDown(wxMouseEvent &event)
void OnMenuClose(wxCommandEvent &event)
void OnMenuSelected(wxCommandEvent &ev)
CWXMainFrame(wxWindow *parent, wxWindowID id=-1)
A custom control to display the bitmap and avoid flicker.
Definition: WxSubsystem.h:322
mrpt::math::TPoint2D m_curCursorPos
In graph coords.
Definition: WxSubsystem.h:450
TOpenGLFont
Existing fonts for 2D texts in mrpt::opengl methods.
Definition: opengl_fonts.h:22
std::promise< void > m_semWxMainThreadReady
This is signaled when wxMainThread is ready.
Definition: WxSubsystem.h:172
GLint GLvoid * img
Definition: glext.h:3769
TOpenGLFontStyle
Different style for vectorized font rendering.
Definition: opengl_fonts.h:33
This class creates a window as a graphical user interface (GUI) for displaying images to the user...
void plot(const mrpt::math::CVectorFloat &x, const mrpt::math::CVectorFloat &y, const std::string &lineFormat, const std::string &plotName)
Redirected from CDisplayWindowPlots::plot.
The main frame of the wxWidgets application.
Definition: WxSubsystem.h:132
CDisplayWindow * m_win2D
Definition: WxSubsystem.h:361
The wx dialog for gui::CDisplayWindow.
Definition: WxSubsystem.h:317
bool sourceCameraSelectDialog
Only one of source* can be non-nullptr, indicating the class that generated the request.
Definition: WxSubsystem.h:207
void OnMouseMove(wxMouseEvent &event)
static void wxMainThread()
This will be the "MAIN" of wxWidgets: It starts an application object and does not end until all the ...
GLsizei const GLchar ** string
Definition: glext.h:4116
void image(void *theWxImage, const float &x0, const float &y0, const float &w, const float &h, const std::string &plotName)
Redirected from CDisplayWindowPlots::image.
void OnChar(wxKeyEvent &event)
void OnMouseMove(wxMouseEvent &event)
static void waitWxShutdownsIfNoWindows()
This method must be called in the destructor of the user class FROM THE MAIN THREAD, in order to wait for the shutdown of the wx thread if this was the last open window.
static const long ID_MENU_PRINT
Definition: WxSubsystem.h:444
WxSubsystem::CWXMainFrame * m_mainFrame
Definition: WxSubsystem.h:362
void OnResize(wxSizeEvent &event)
This class implements the GUI thread required for the wxWidgets-based GUI.
Definition: WxSubsystem.h:96
void OnClose(wxCloseEvent &event)
void OnMenuAbout(wxCommandEvent &event)
void plotEllipse(const mrpt::math::CVectorFloat &x, const mrpt::math::CVectorFloat &y, const std::string &lineFormat, const std::string &plotName, bool showName=false)
Redirected from CDisplayWindowPlots::plotEllipse.
A RGB color - floats in the range [0,1].
Definition: TColor.h:78
static const long ID_IMAGE_BITMAP
Definition: WxSubsystem.h:367
void OnMouseDown(wxMouseEvent &event)
CWindowDialog(CDisplayWindow *win2D, WxSubsystem::CWXMainFrame *parent, wxWindowID id=-1, const std::string &caption=std::string("[MRPT-CDisplayWindow]"), wxSize initialSize=wxDefaultSize)
static CAuxWxSubsystemShutdowner global_wxsubsystem_shutdown
Definition: WxSubsystem.h:128
mrpt::gui::CDisplayWindowPlots * sourcePlots
Only one of source* can be non-nullptr, indicating the class that generated the request.
Definition: WxSubsystem.h:203
GLenum GLint GLint y
Definition: glext.h:3542
static bool isConsoleApp()
Will be set to true at runtime if it&#39;s not detected a running wxApp instance.
Definition: WxSubsystem.cpp:53
void OnClose(wxCloseEvent &event)
Classes for creating GUI windows for 2D and 3D visualization.
Definition: about_box.h:14
void OnMenuPrint(wxCommandEvent &event)
GLenum GLint x
Definition: glext.h:3542
mrpt::gui::CDisplayWindow * source2D
Only one of source* can be non-nullptr, indicating the class that generated the request.
Definition: WxSubsystem.h:195
void OnMenuAbout(wxCommandEvent &event)
GLenum GLsizei GLsizei height
Definition: glext.h:3558
std::string str
Parameters, depending on OPCODE.
Definition: WxSubsystem.h:211
WxSubsystem::CWXMainFrame * m_mainFrame
Definition: WxSubsystem.h:396
Lightweight 2D point.
Definition: TPoint2D.h:31
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: glext.h:3550
static const long ID_MENUITEM2
Definition: WxSubsystem.h:421
static bool createOneInstanceMainThread()
Thread-safe method to create one single instance of the main wxWidgets thread: it will create the thr...
static int notifyWindowDestruction()
Atomically decrements the number of windows created with the main frame as parent.
CMyGLCanvas_DisplayWindow3D * m_canvas
Definition: WxSubsystem.h:398
A graphical user interface (GUI) for efficiently rendering 3D scenes in real-time.
bool m_firstSubmenu
to know whether to insert a separator the first time.
Definition: WxSubsystem.h:446



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: 4363012a5 Tue Nov 19 10:55:26 2019 +0100 at mar nov 19 11:00:13 CET 2019