Code::Blocks - User contributions [en]

WxSmith tutorial: Using wxPanel resources

2012-04-07T22:33:45Z

Bentcode: /* Adding the wxPanel using a "Custom" item */

[[Category:wxSmith Documentation]]
= Using wxPanel resources =

[Subsequent tutorials do not depend upon this one. If you find it confusing or not relevant to your needs, you can skip to the next without loss of continuity.]

In some cases, one resource must be split into a few smaller parts. Such a split gives a few advantages: it helps with multiple people working on the same project, it may give you a cleaner view over really complex resources and it may help to divide source code for logical parts in case of several functionalities in one window. In this tutorial I'll show you how to create such resources.

== Creating our playground ==

wxPanel resources can not live as independent items - they must be placed inside a frame or dialog. We can use the main resource created inside the wizard. Assuming that you've read the previous tutorials, creating a simple window shouldn't be a big problem for you :).

Let's start with something like this:

[[Image:wxs_tut05_001.png]]

== Adding the wxPanel using a "Custom" item ==

In this tutorial I'll show you two methods of embedding an external wxPanel inside another resource.
The first one uses a "Custom" item which can be used to add any kind of resource not known to wxSmith.

So let's create the wxPanel resource by using the wxSmith item on the Code::Blocks main menu. Note that using this embedding method will affect the initial configuration of the resource.
We want the id, size and position of our panel to be controlled by the parent resource so make sure that we add them into the panel's constructor:

[[Image:wxs_tut05_002.png]]

Now let's add some content into the panel:

[[Image:wxs_tut05_003.png]]

The final step is to add a "Custom" item into the main window and configure it properly. The custom icon is the last one in the "Standard palette" identified by this icon:

[[Image:wxs_tut05_004.png]]

A new item will be shown as a black square with three question marks on the top. Let's resize it a little bit:

[[Image:wxs_tut05_005.png]]

Now we need to adjust the custom item's properties.

The first thing we will adjust is the "Creating code" property. As the name says, here we will be able to adjust the way wxSmith adds the code responsible for creating this item. The default value is:

$(THIS) = new $(CLASS)($(PARENT),$(ID),$(POS),$(SIZE),$(STYLE),wxDefaultValidator,$(NAME));

You may find that there are some macros used. They are here to help you map other properties of this item into the creating code:
* $(THIS) is replaced by the name of the variable for this item
* $(CLASS) is replaced by the name of the item's class
* $(PARENT) is replaced by the name of the parent item (it's granted that it will be a pointer to a class derived from wxWindow)
* $(ID) is replaced by the value of the ID property
* $(POS) is replaced by the value of the position property (it may be adjusted by using drag boxes)
* $(SIZE) is replaced by the value of the size property (it may be adjusted by using drag boxes)
* $(STYLE) is replaced by the style property - since custom items doesn't have a predefined set of styles, it's treated as a normal string
* $(NAME) is replaced by the generated name (which is equivalent to the string representation of the item's identifier)

The default code template creates a standard item which uses the default set of properties. Let's replace it by a value corresponding to our panel's constructor:

$(THIS) = new $(CLASS)($(PARENT),$(ID),$(POS),$(SIZE));

Now we have to give the name of the header file with our external resource in the "Include file" property. I've created the wxPanel with the name "InternalPanel" so the header will be "InternalPanel.h". Also let's check the "Use "" for include..." since we're including a local file.

The last property to adjust is the "Class name" - we need to put the name of our panel here; in my case it's "InternalPanel". When we do this, our embedded resource is ready. While the resource view and the show preview continue to show the black square with three question marks, if you rebuild/run the project you will see the embedded resource;

[[Image:wxs_tut05_006.png]]

== Adding custom panel through standard wxPanel ==

The second way in which an external resource may be used is through a normal wxPanel.
If you look closer, you'll find that most of the items have a property called "Class name" - this is the name of the class which will be used as the item's type. By default it contains the name of the original class in wxWidgets. Changing it will notify wxSmith that a different class will be used instead.

So to put our own panel here we can add a "normal" panel into the main resource and change the class name to the name of our internal resource. So far it's easy but there's one requirement to this technique - our internal resource must have exactly the same constructor arguments as in the case of the "original" class.

So let's take a look at the wxWidgets documentation. Here's the declaration of wxPanel's constructor:

wxPanel( wxWindow* parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL, const wxString& name = "panel")

Now let's create our own internal resource. We will have to adjust constructor arguments as in the case of the previous method:

[[Image:wxs_tut05_007.png]]

Note that I've added custom arguments and turned off all default values (it's required since we cannot easily add default values of our custom args).

Now that our panel is ready we can add it to the main resource - let's add a "normal" panel first:

[[Image:wxs_tut05_008.png]]

and change "Class name" property to the name of our resource (in my case it's InternalResource2).

We still need to add #include "InternalResource2.h" into the sources to make our project compile. In the previous solution it was done automatically through properties. Now we don't have such a system so let's add it manually (remember to put our include outside wxSmith's code section, otherwise any change in the resource will remove our change). Note that we need to add it to the header file of the main resource:

//(*Headers(Tutorial5Dialog)
#include <wx/sizer.h>
#include <wx/panel.h>
#include "InternalPanel.h"
#include <wx/dialog.h>
//*)
'''#include "InternalResource2.h"'''

Now we can run our application:

[[Image:wxs_tut05_009.png]]

I've presented two easy methods of creating complex windows from smaller resources. Perhaps you could find other ways to do it (if you do so, you can extend this tutorial :) ). On wxSmith's wishlist there's also a nice feature request to allow adding external panels in a more natural way (just by a few clicks) which will probably make other methods obsolete. But I hope that I gave you enough information to build nice compound resources so far :)

----

<center>'''[[WxSmith tutorial: Working with multiple resources|Previous]] | [[WxSmith tutorials|Index]] | [[WxSmith tutorial: Accessing items in resource|Next]]'''</center>

WxSmith tutorial: Using wxPanel resources

2012-04-07T22:32:41Z

Bentcode: /* Adding the wxPanel using a "Custom" item */

[[Category:wxSmith Documentation]]
= Using wxPanel resources =

[Subsequent tutorials do not depend upon this one. If you find it confusing or not relevant to your needs, you can skip to the next without loss of continuity.]

In some cases, one resource must be split into a few smaller parts. Such a split gives a few advantages: it helps with multiple people working on the same project, it may give you a cleaner view over really complex resources and it may help to divide source code for logical parts in case of several functionalities in one window. In this tutorial I'll show you how to create such resources.

== Creating our playground ==

wxPanel resources can not live as independent items - they must be placed inside a frame or dialog. We can use the main resource created inside the wizard. Assuming that you've read the previous tutorials, creating a simple window shouldn't be a big problem for you :).

Let's start with something like this:

[[Image:wxs_tut05_001.png]]

== Adding the wxPanel using a "Custom" item ==

In this tutorial I'll show you two methods of embedding an external wxPanel inside another resource.
The first one uses a "Custom" item which can be used to add any kind of resource not known to wxSmith.

So let's create the wxPanel resource by using the wxSmith item on the Code::Blocks main menu. Note that using this embedding method will affect the initial configuration of the resource.
We want the id, size and position of our panel to be controlled by the parent resource so make sure that we add them into the panel's constructor:

[[Image:wxs_tut05_002.png]]

Now let's add some content into the panel:

[[Image:wxs_tut05_003.png]]

The final step is to add a "Custom" item into the main window and configure it properly. The custom icon is the last one in the "Standard palette" identified by this icon:

[[Image:wxs_tut05_004.png]]

A new item will be shown as a black square with three question marks on the top. Let's resize it a little bit:

[[Image:wxs_tut05_005.png]]

Now we need to adjust the custom item's properties.

The first thing we will adjust is the "Creating code" property. As the name says, here we will be able to adjust the way wxSmith adds the code responsible for creating this item. The default value is:

$(THIS) = new $(CLASS)($(PARENT),$(ID),$(POS),$(SIZE),$(STYLE),wxDefaultValidator,$(NAME));

You may find that there are some macros used. They are here to help you map other properties of this item into the creating code:
* $(THIS) is replaced by the name of the variable for this item
* $(CLASS) is replaced by the name of the item's class
* $(PARENT) is replaced by the name of the parent item (it's granted that it will be a pointer to a class derived from wxWindow)
* $(ID) is replaced by the value of the ID property
* $(POS) is replaced by the value of the position property (it may be adjusted by using drag boxes)
* $(SIZE) is replaced by the value of the size property (it may be adjusted by using drag boxes)
* $(STYLE) is replaced by the style property - since custom items doesn't have a predefined set of styles, it's treated as a normal string
* $(NAME) is replaced by the generated name (which is equivalent to the string representation of the item's identifier)

The default code template creates a standard item which uses the default set of properties. Let's replace it by a value corresponding to our panel's constructor:

$(THIS) = new $(CLASS)($(PARENT),$(ID),$(POS),$(SIZE));

Now we have to give the name of the header file with our external resource in the "Include file" property. I've created the wxPanel with the name "InternalPanel" so the header will be "InternalPanel.h". Also let's check the "Use "" for include..." since we're including a local file.

The last property to adjust is the "Class name" - we need to put the name of our panel here; in my case it's "InternalPanel". When we do this, our embedded resource is ready. While the resource view and the show preview continue to show the black square with three question marks, if you rebuild/run the project you will see;

[[Image:wxs_tut05_006.png]]

== Adding custom panel through standard wxPanel ==

The second way in which an external resource may be used is through a normal wxPanel.
If you look closer, you'll find that most of the items have a property called "Class name" - this is the name of the class which will be used as the item's type. By default it contains the name of the original class in wxWidgets. Changing it will notify wxSmith that a different class will be used instead.

So to put our own panel here we can add a "normal" panel into the main resource and change the class name to the name of our internal resource. So far it's easy but there's one requirement to this technique - our internal resource must have exactly the same constructor arguments as in the case of the "original" class.

So let's take a look at the wxWidgets documentation. Here's the declaration of wxPanel's constructor:

wxPanel( wxWindow* parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL, const wxString& name = "panel")

Now let's create our own internal resource. We will have to adjust constructor arguments as in the case of the previous method:

[[Image:wxs_tut05_007.png]]

Note that I've added custom arguments and turned off all default values (it's required since we cannot easily add default values of our custom args).

Now that our panel is ready we can add it to the main resource - let's add a "normal" panel first:

[[Image:wxs_tut05_008.png]]

and change "Class name" property to the name of our resource (in my case it's InternalResource2).

We still need to add #include "InternalResource2.h" into the sources to make our project compile. In the previous solution it was done automatically through properties. Now we don't have such a system so let's add it manually (remember to put our include outside wxSmith's code section, otherwise any change in the resource will remove our change). Note that we need to add it to the header file of the main resource:

//(*Headers(Tutorial5Dialog)
#include <wx/sizer.h>
#include <wx/panel.h>
#include "InternalPanel.h"
#include <wx/dialog.h>
//*)
'''#include "InternalResource2.h"'''

Now we can run our application:

[[Image:wxs_tut05_009.png]]

I've presented two easy methods of creating complex windows from smaller resources. Perhaps you could find other ways to do it (if you do so, you can extend this tutorial :) ). On wxSmith's wishlist there's also a nice feature request to allow adding external panels in a more natural way (just by a few clicks) which will probably make other methods obsolete. But I hope that I gave you enough information to build nice compound resources so far :)

----

<center>'''[[WxSmith tutorial: Working with multiple resources|Previous]] | [[WxSmith tutorials|Index]] | [[WxSmith tutorial: Accessing items in resource|Next]]'''</center>

WxSmith tutorial: Using wxPanel resources

2012-04-07T21:58:10Z

Bentcode: /* Adding the wxPanel using a "Custom" item */

[[Category:wxSmith Documentation]]
= Using wxPanel resources =

[Subsequent tutorials do not depend upon this one. If you find it confusing or not relevant to your needs, you can skip to the next without loss of continuity.]

In some cases, one resource must be split into a few smaller parts. Such a split gives a few advantages: it helps with multiple people working on the same project, it may give you a cleaner view over really complex resources and it may help to divide source code for logical parts in case of several functionalities in one window. In this tutorial I'll show you how to create such resources.

== Creating our playground ==

wxPanel resources can not live as independent items - they must be placed inside a frame or dialog. We can use the main resource created inside the wizard. Assuming that you've read the previous tutorials, creating a simple window shouldn't be a big problem for you :).

Let's start with something like this:

[[Image:wxs_tut05_001.png]]

== Adding the wxPanel using a "Custom" item ==

In this tutorial I'll show you two methods of embedding an external wxPanel inside another resource.
The first one uses a "Custom" item which can be used to add any kind of resource not known to wxSmith.

So let's create the wxPanel resource by using the wxSmith item on the Code::Blocks main menu. Note that using this embedding method will affect the initial configuration of the resource.
We want the id, size and position of our panel to be controlled by the parent resource so make sure that we add them into the panel's constructor:

[[Image:wxs_tut05_002.png]]

Now let's add some content into the panel:

[[Image:wxs_tut05_003.png]]

The final step is to add a "Custom" item into the main window and configure it properly. The custom icon is the last one in the "Standard palette" identified by this icon:

[[Image:wxs_tut05_004.png]]

A new item will be shown as a black square with three question marks on the top. Let's resize it a little bit:

[[Image:wxs_tut05_005.png]]

Now we need to adjust the custom item's properties.

The first thing we will adjust is the "Creating code" property. As the name says, here we will be able to adjust the way wxSmith adds the code responsible for creating this item. The default value is:

$(THIS) = new $(CLASS)($(PARENT),$(ID),$(POS),$(SIZE),$(STYLE),wxDefaultValidator,$(NAME));

You may find that there are some macros used. They are here to help you map other properties of this item into the creating code:
* $(THIS) is replaced by the name of the variable for this item
* $(CLASS) is replaced by the name of the item's class
* $(PARENT) is replaced by the name of the parent item (it's granted that it will be a pointer to a class derived from wxWindow)
* $(ID) is replaced by the value of the ID property
* $(POS) is replaced by the value of the position property (it may be adjusted by using drag boxes)
* $(SIZE) is replaced by the value of the size property (it may be adjusted by using drag boxes)
* $(STYLE) is replaced by the style property - since custom items doesn't have a predefined set of styles, it's treated as a normal string
* $(NAME) is replaced by the generated name (which is equivalent to the string representation of the item's identifier)

The default code template creates a standard item which uses the default set of properties. Let's replace it by a value corresponding to our panel's constructor:

$(THIS) = new $(CLASS)($(PARENT),$(ID),$(POS),$(SIZE));

Now we have to give the name of the header file with our external resource in the "Include file" property. I've created the wxPanel with the name "InternalPanel" so the header will be "InternalPanel.h". Also let's check the "Use "" for include..." since we're including a local file.

The last property to adjust is the "Class name" - we need to put the name of our panel here; in my case it's "InternalPanel". When we do this, our embedded resource is ready:

[[Image:wxs_tut05_006.png]]

== Adding custom panel through standard wxPanel ==

The second way in which an external resource may be used is through a normal wxPanel.
If you look closer, you'll find that most of the items have a property called "Class name" - this is the name of the class which will be used as the item's type. By default it contains the name of the original class in wxWidgets. Changing it will notify wxSmith that a different class will be used instead.

So to put our own panel here we can add a "normal" panel into the main resource and change the class name to the name of our internal resource. So far it's easy but there's one requirement to this technique - our internal resource must have exactly the same constructor arguments as in the case of the "original" class.

So let's take a look at the wxWidgets documentation. Here's the declaration of wxPanel's constructor:

wxPanel( wxWindow* parent, wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL, const wxString& name = "panel")

Now let's create our own internal resource. We will have to adjust constructor arguments as in the case of the previous method:

[[Image:wxs_tut05_007.png]]

Note that I've added custom arguments and turned off all default values (it's required since we cannot easily add default values of our custom args).

Now that our panel is ready we can add it to the main resource - let's add a "normal" panel first:

[[Image:wxs_tut05_008.png]]

and change "Class name" property to the name of our resource (in my case it's InternalResource2).

We still need to add #include "InternalResource2.h" into the sources to make our project compile. In the previous solution it was done automatically through properties. Now we don't have such a system so let's add it manually (remember to put our include outside wxSmith's code section, otherwise any change in the resource will remove our change). Note that we need to add it to the header file of the main resource:

//(*Headers(Tutorial5Dialog)
#include <wx/sizer.h>
#include <wx/panel.h>
#include "InternalPanel.h"
#include <wx/dialog.h>
//*)
'''#include "InternalResource2.h"'''

Now we can run our application:

[[Image:wxs_tut05_009.png]]

I've presented two easy methods of creating complex windows from smaller resources. Perhaps you could find other ways to do it (if you do so, you can extend this tutorial :) ). On wxSmith's wishlist there's also a nice feature request to allow adding external panels in a more natural way (just by a few clicks) which will probably make other methods obsolete. But I hope that I gave you enough information to build nice compound resources so far :)

----

<center>'''[[WxSmith tutorial: Working with multiple resources|Previous]] | [[WxSmith tutorials|Index]] | [[WxSmith tutorial: Accessing items in resource|Next]]'''</center>

WxSmith tutorial: Working with multiple resources

2012-04-07T21:17:29Z

Bentcode: /* Working with Multiple Windows */

[[Category:wxSmith Documentation]]
= Working with Multiple Windows =

In this tutorial, I'll show you how to create an application with more than one window. We will have, as usual, a main window; and in it we will create and show at the click of one button a wxFrame window and at the click of another button, a wxDialog window. One important difference between these two windows is that a wxDialog has the possibility of stopping the application until it is closed. It is generally used for asking the user a question or questions which demand answers before computation can proceed. Otherwise, the wxFrame generally has greater capabilities.

As usual, we will start with an empty project. Let's name the project "Tutorial_4". As always, remember to add the Close() statement. Check that the empty application compiles, runs and closes fine.

New windows can be added from the '''wxSmith''' menu item from the main menu of Code::Blocks. You can find there the following possibilities:

*'''Add wxPanel''' - this will add a new panel into the window
*'''Add wxFloatingFrame''' – this will add Floating frame window
*'''Add wxDialog''' - this adds a new dialog window
*'''Add wxFrame''' - this adds a new frame window.

Let's first add a new wxDialog. When you choose this option you will see the following window:

[[Image:wxs_tut04_001.png]]

Here we can set the following parameters:
*Class name - the name of the class which will be generated for the resource. It will also be the name of a resource
*Header file – the name of the header file with the class declaration
*Source file – the name of the source file with the class definition
*XRC file - if you check this option you can enter the name of an XRC file which will contain the XRC's structure (XRC files will be covered in a tutorial not yet written.)
*Add XRC file to autoload list - this option is available only with XRC files and notifies wxSmith that it should automatically load the XRC file when the application starts.

Now let's change the name of the window to something more distinctive like "FirstDialog". Note that if you change the class name, the names of the files are also updated. (More correctly, they are updated as long as you don't change them manually).

After clicking OK, you will be prompted for a list of build targets into which the new window will be added. Select both ''debug'' and ''release'', and we can continue.

A new dialog is automatically opened in the editor. In the top bar of the frame of the editor, note that there are two .wxs files available to the editor, Tutorial_4Frame.wks and the newly created FirstDialog1.wxs. Both are completely blank. Into FirstDialog.wxs let's add some simple content so that it looks like this in the editor:

[[Image:wxs_tut04_002.png]]

It is a good review exercise to figure out from this figure what has been done. It is very similar to what we did at the beginning of the previous tutorial. Before reading further, try your hand at making it. (To tell the truth, it doesn't matter much what you put in because all we are going to do with it is show it, But if you need a review, here is what I did: 1. Put a wxBoxSizer on the editor. 2. Put a wxPanel in the sizer (and remembered to turn on its Expand property). 3. Put on the panel a wxStaticBoxSizer, changed its orientation to Vertical, and set its label to “This is the first dialog.” 4. Into the StaticBoxSizer put first a wxTextCtrl and then a wxStaticText item.) At this point, the Show Preview button on the extreme right of the editor will show us what we have, while running the program will show nothing, because the application has no programming to show our dialog.

Now let's go back to the wxSmith item on the Code::Blocks menu and add a wxFrame window (FirstFrame) and add some content into it:

[[Image:wxs_tut04_003.png]]

Again, it is good review to make the window look like this, but the content is not critical for what follows.

== Using a Dialog Window Modally ==

Dialogs (but not frames) can be shown modally. When a dialog is shown modally, all other windows in the application are frozen until the dialog finishes its job. Modal dialogs are useful when the user must provide some information before computation can continue. For example, the window used to configure a new resource was shown modally.

Now let's try to invoke our dialog. Generally such dialogs will pop-up in reaction to some user action like choosing a menu option or clicking on a button. We will use a button since this approach is really easy. Let's switch into the main frame - the one that was opened right after creating the new project - and add a box sizer and button:

[[Image:wxs_tut04_004.png]]

Now we have to create an action for the button-click event. The easiest way is to double-click the button in the editor. wxSmith will automatically add a new event handler function:

void Tutorial_4Frame::OnButton1Click(wxCommandEvent& event)
{
}

If you don't see this code, scroll down to the end of the .cpp file.

In this frame, let's put the code to invoke our dialog:

<pre>
void Tutorial_4Frame::OnButton1Click(wxCommandEvent& event)
{
FirstDialog dialog(this);
dialog.ShowModal();
}
</pre>

In the first added line, we create the dialog's object and declare that ''this'' window (the main frame) is the parent of dialog. In the second line, we show the dialog modally. The call to ShowModal(), which is a function (or method) of the dialog, blocks everything else until the dialog is closed.

There's one more thing we need to add before our application will compile. Jump to the beginning of the file and add the following code after the first group of other includes:

#include "FirstDialog.h"

Note that you should '''not''' add it inside code which looks like this:

<pre>
//(*InternalHeaders(Tutorial_4Frame)
#include <wx/intl.h>
#include <wx/string.h>
//*)
</pre>

This is a block of code that is automatically generated by wxSmith. Every block starts with a //(*BlockName comment and ends with a //*). You may find other similar blocks in both header and source files. If you change their content, all changes will be lost next time you change something in the editor. These comments and everything inside them belong to wxSmith, so don't mess with them.

To sum up, the headers section should look like this:

<pre>
#include "wx_pch.h"
#include "Tutorial_4Main.h"
#include <wx/msgdlg.h>
#include "FirstDialog.h"

//(*InternalHeaders(Tutorial_4Frame)
#include <wx/intl.h>
#include <wx/string.h>
//*)
</pre>

Now we can compile and run our application. If you click the button on the main window, this dialog will pop-up:

[[Image:wxs_tut04_005.png]]

== Using Modeless Dialogs and Frame Windows ==

Another way to show a window is as a modeless window. In such cases, the new window does not block other windows in the application and two (or more) windows can cooperate in one application.
Before we add new code into our application there's one more thing you should know. Each window may exist only as long as its object (the instance of the resource's c++ class) exists. So we cannot use the same approach as in the case of a modal dialog. In modal mode, an object was created as a local variable of the event handler by the simple declaration statement

FirstDialog dialog(this);

We could do this only because the ShowModal method was blocking as long as the dialog was shown. Now with a wxFrame, which does not have the ShowModal possibility, we will have to create objects using the '''new''' operator of C++ because the objects must exist after leaving the handler function and also because windows not using modal mode will delete such objects automatically when the window is closed.

To allow creating the FirstFrame class we should add #include "FirstFrame.h" into the list of includes just as in the case of FirstDialog:
<pre>
#include "wx_pch.h"
#include "Tutorial_4Main.h"
#include <wx/msgdlg.h>
#include "FirstDialog.h"
#include "FirstFrame.h"

//(*InternalHeaders(Tutorial_4Frame)
#include <wx/intl.h>
#include <wx/string.h>
//*)

</pre>

Now let's add two more buttons to the main frame:
*Add new dialog
*Add new frame

We can also name the first button to show what it does:

[[Image:wxs_tut04_006.png]]

Now let's add a handler to the ''Add new dialog'' button:

<pre>
void Tutorial_4Frame::OnButton2Click(wxCommandEvent& event)
{
FirstDialog* dlg = new FirstDialog(this);
dlg->Show();
}
</pre>

Analogously, we can write the code for FirstFrame:

<pre>
void Tutorial_4Frame::OnButton3Click(wxCommandEvent& event)
{
FirstFrame* frm = new FirstFrame(this);
frm->Show();
}
</pre>

Now each time we click the ''Add new dialog'' or ''Add new frame'' button, a new window shows up.

This is the end of this tutorial. I hope that you learned some new and useful things. We have covered the use of two of the four things you can add to your project by using the wxSmith item on the Code::Blocks main menu. In the next tutorial, I'll show how to use another of the four, namely the wxPanel.

----

<center>'''[[WxSmith tutorial: Building more complex window|Previous]] | [[WxSmith tutorials|Index]] | [[WxSmith tutorial: Using wxPanel resources|Next]]'''</center>