Home>Programming>Programming with wxWidgets

Programming with wxWidgets

Welcome to TheCredence.com - You may like to subscribe to our RSS feed to stay updated.

wxWidgets is an open source cross-platform C++ programming toolkit that includes many features. It is most often used for developing applications with a GUI, but also provides features for networking, file access, and more. With versions available for Windows, Linux, Mac, and even some embedded devices, cross platform programming becomes much easier.

I am myself very new to wxWidgets but still have penned down a Beginners Tutorial on wxWidgets -

During this tutorial, a very simple text editor will be constructed that can load and save text files. The tutorial will focus on the application object, the main window, and the event table.

The Application
All wxWidgets applications are derived from wxApp, and simply need to override a single member, wxApp::OnInit, and create a window. As long as the window is open, the application is as well. The following code illustrates the code needed.

  1.  
  2. #include “wx/wx.h”class MyApplication : public wxApp
  3. {
  4. public:
  5. bool OnInit();</code>
  6.  
  7. };bool MyApplication::OnInit(){
  8.  
  9. // TODO: Show window
  10.  
  11. return false;
  12.  
  13. }IMPLEMENT_APP(MyApplication);
  14.  

The first line includes most of the header files needed for a wxWidgets application. Then a new class is derived from wxApp called MyApplication, and the MyApplication::OnInit() function is created. Finally, IMPLEMENT_APP(MyApplication), is needed to cause the application to run. This macro expands to the correct code for any given platform to actually start the application.

The Frame in wxWidgets
After creating the application, the window frame needs to be created and controls need to be created on it. The frame object is derived from wxFrame and, as shown below, includes several functions and the text control.

  1.  
  2. class MyFrame : public wxFrame
  3. {
  4. public:  MyFrame();  void OnNew(wxCommandEvent&amp; evt);
  5.  
  6. void OnOpen(wxCommandEvent&amp; evt);
  7.  
  8. void OnSave(wxCommandEvent&amp; evt);private:
  9.  
  10. void CreateWidgets();
  11.  
  12. wxTextCtrl* m_text;
  13. };
  14.  
  15. MyFrame::MyFrame() :
  16.  
  17. wxFrame(NULL, wxID_ANY, wxT("Sample Program"))
  18. {
  19.   CreateWidgets();
  20. }
  21.  
  22. void MyFrame::OnNew(wxCommandEvent&amp; WXUNUSED(evt))
  23. {
  24.   m_text-&gt;Clear();
  25. }
  26.  
  27. void MyFrame::OnOpen(wxCommandEvent&amp; WXUNUSED(evt))
  28. {
  29.   wxString file = ::wxFileSelector(wxT("Open file"));
  30.   if(file.IsEmpty() == false)
  31. 	m_text-&gt;LoadFile(file);
  32. }
  33.  
  34. void MyFrame::OnSave(wxCommandEvent&amp; WXUNUSED(evt))
  35. {
  36.   wxString file = ::wxFileSelector(wxT("Save file"));
  37.   if(file.IsEmpty() == false)
  38.     m_text-&gt;SaveFile(file);
  39. }
  40. void MyFrame::CreateWidgets()
  41. {
  42. // Create a text control
  43. m_text = new wxTextCtrl(this, wxID_ANY, wxEmptyString,
  44. wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_TAB |
  45. wxTE_PROCESS_ENTER | wxTE_MULTILINE);
  46. // Create file menu
  47.  
  48. wxMenu* fileMenu = new wxMenu();
  49. fileMenu-&gt;Append(wxID_NEW, wxT("New File"));
  50. fileMenu-&gt;Append(wxID_OPEN, wxT("Open File"));
  51. fileMenu-&gt;Append(wxID_SAVE, wxT("Save File"));
  52. // Create menu bar
  53. wxMenuBar* menuBar = new wxMenuBar();
  54. menuBar-&gt;Append(fileMenu, wxT("File"));
  55. // Set menu
  56. SetMenuBar(menuBar);
  57. }

All of that code creates the window. The constructor MyFrame::MyFrame calls the parent constructor wxFrame::wxFrame to create the frame and give it a name, and then it calls CreateWidgets, to create the contents of the frame. The MyFrame::CreateWidgets function creates a text control and a menu bar. In addition, function MyFrame::OnNew, MyFrame::OnOpen, and MyFrame::OnSave are implemented to clear, open, or save the text to a file. Also notice that text constants are enclosed in wxT(...). Since wxWidgets can compile in Unicode as well, wrapping text constants like this ensure that they are declare correctly.

The event Table in wxWidgets
The event table is used to route events from controls, menus, and anything else to the correct functions to handle the events. Without them, this application would not be able to load or save the text. The following changes are needed to implement the event table.

  1.  
  2. class MyFrame : public wxFrame
  3.  
  4. {
  5.  
  6. ...
  7.  
  8. ...DECLARE_EVENT_TABLE();
  9.  
  10. };
  11.  
  12. BEGIN_EVENT_TABLE(MyFrame, wxFrame)
  13.  
  14.   EVT_MENU(wxID_NEW, MyFrame::OnNew)
  15.  
  16.   EVT_MENU(wxID_OPEN, MyFrame::OnOpen)
  17.  
  18.   EVT_MENU(wxID_SAVE, MyFrame::OnSave)
  19.  
  20. END_EVENT_TABLE()

First, the event table for the frame is declared. Then the table is created, and the event ids wxID_NEW, wxID_OPEN, and wxID_SAVE are used to call the functions MyFrame::OnNew, MyFrame::OnOpen, and MyFrame::OnSave. The events generated by the menus will get processed by the correct functions.

Showing the frame
Now that the frame is complete, a small change is needed to the application. It needs to create the window frame, show it, and set it as the application top window.

  1.  
  2. bool MyApplication::OnInit()
  3.  
  4. {
  5.  
  6.   // Create and show the frame
  7.  
  8.   MyFrame* frame = new MyFrame();
  9.  
  10.   frame-&gt;Show();  SetTopWindow(frame);
  11.  
  12.   return true;
  13.  
  14. }

The complete code

  1.  
  2. #include "wx/wx.h"// Main window frame
  3. class MyFrame : public wxFrame
  4. {
  5. public:
  6. MyFrame();
  7.  
  8. void OnNew(wxCommandEvent&amp; evt);
  9.  
  10. void OnOpen(wxCommandEvent&amp; evt);
  11.  
  12. void OnSave(wxCommandEvent&amp; evt);
  13.  
  14. private:
  15. void CreateWidgets();
  16.  
  17. wxTextCtrl* m_text;
  18.  
  19. DECLARE_EVENT_TABLE();
  20. };
  21.  
  22. MyFrame::MyFrame() :
  23. wxFrame(NULL, wxID_ANY, wxT("Sample Program"))
  24. {
  25. CreateWidgets();
  26. }
  27.  
  28. void MyFrame::OnNew(wxCommandEvent&amp; WXUNUSED(evt))
  29. {
  30.  
  31. m_text-&gt;Clear();
  32. }
  33.  
  34. void MyFrame::OnOpen(wxCommandEvent&amp; WXUNUSED(evt))
  35. {
  36.  
  37. wxString file = ::wxFileSelector(wxT("Open file"));
  38.  
  39. if(file.IsEmpty() == false)
  40.  
  41. m_text-&gt;LoadFile(file);
  42. }
  43.  
  44. void MyFrame::OnSave(wxCommandEvent&amp; WXUNUSED(evt))
  45. {
  46. wxString file = ::wxFileSelector(wxT("Save file"));
  47.  
  48. if(file.IsEmpty() == false)
  49.  
  50. m_text-&gt;SaveFile(file);
  51.  
  52. }
  53.  
  54. void MyFrame::CreateWidgets()
  55. {
  56. // Create a text control
  57.  
  58. m_text = new wxTextCtrl(this, ID_TEXTCTRL, wxEmptyString,
  59.  
  60. wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_TAB |
  61.  
  62. wxTE_PROCESS_ENTER | wxTE_MULTILINE);
  63.  
  64. // Create file menu
  65.  
  66. wxMenu* fileMenu = new wxMenu();
  67.  
  68. fileMenu-&gt;Append(wxID_NEW, wxT("New File"));
  69.  
  70. fileMenu-&gt;Append(wxID_OPEN, wxT("Open File"));
  71.  
  72. fileMenu-&gt;Append(wxID_SAVE, wxT("Save File"));
  73.  
  74. // Create menu bar
  75.  
  76. wxMenuBar* menuBar = new wxMenuBar();
  77.  
  78. menuBar-&gt;Append(fileMenu, wxT("File"));
  79.  
  80. // Set menu
  81.  
  82. SetMenuBar(menuBar);
  83.  
  84. }
  85.  
  86. // Event table to route menu events to functions
  87.  
  88. BEGIN_EVENT_TABLE(MyFrame, wxFrame)
  89.  
  90. EVT_MENU(wxID_NEW, MyFrame::OnNew)
  91.  
  92. EVT_MENU(wxID_OPEN, MyFrame::OnOpen)
  93.  
  94. EVT_MENU(wxID_SAVE, MyFrame::OnSave)
  95.  
  96. END_EVENT_TABLE()
  97.  
  98. // Application
  99.  
  100. class MyApplication : public wxApp
  101. {
  102. public:
  103.  
  104. bool OnInit();
  105. };
  106.  
  107. bool MyApplication::OnInit()
  108. {
  109.  
  110. // Create and show the frame
  111.  
  112. MyFrame* frame = new MyFrame();
  113.  
  114. frame-&gt;Show();
  115.  
  116. SetTopWindow(frame);
  117.  
  118. return true;
  119. }
  120.  
  121. IMPLEMENT_APP(MyApplication);

Normally to write a cross-platform GUI application, separate code would be needed for each supported platform. For Windows, the code would use the Windows API or MFC. For Linux it would probably use GTK or QT, or directly use X11. wxWidgets allows a single code base to compile and work on multiple platforms with little to no changes in the code. In addition it provides a complete set of features for networking, file and database access, and much more. For any programmer, especially a programmer developing for different platforms, wxWidgets is surely a valuable toolkit.

I hope this tutorial on wxWidgets helps you in understanding what they are and how to do programming with them. For more info on them you can always check there Official website. All Non spam comments are as usual welcomed with open hands :) I would love to know How did you find the article and your inputs to it.

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading ... Loading ...
Subscribe in a reader |

Links you may find interesting -