A property page is a control container that appears as a form or a frame. A property page can appear by itself. Here is an example  In most other cases, a property page appears in a group with other pages. It functions like a group of pieces of paper placed on top of each other. Each piece is represented by a tab that allows the user to identify it:  To use a property page, the user clicks the header, also called tab, of the desired page. This brings that page up and sends the other(s) in the background:  If the user needs access to another page, he or she can click the desired tab, which would bring that page in front and send the previously selected page to the back. The pages are grouped and hosted by an object called a property sheet. Like a form, the property pages of a property sheet are simply used to carry or hold other controls. The major idea of using a property sheet is its ability to have many controls available in a relatively smaller area.
Property pages of a property sheet are also referred to as tab controls. To support property pages, the .NET Framework provides a class named TabControl. At design time, to add a property sheet to your application, in the Containers section of the Toolbox, click TabControl and click the form (or another container). If you want the property sheet to occupy the whole form or to occupy a section of it, you can specify this using the Dock property. To programmatically create a property sheet, create a handle to TabControl, allocate memory for it using the gcnew operator. Like all other objects, a tab control must have a name. After declaring the variable and initializing it, add it to the Controls collection of its container. Here is an example of creating a tab control: #include <windows.h>
#using <System.dll>
#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>
using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
public ref class CExercise : public Form
{
private:
TabControl ^ tclPropertySheet;
public:
CExercise()
{
InitializeComponent();
}
void InitializeComponent()
{
Size = System::Drawing::Size(345, 228);
tclPropertySheet = gcnew TabControl;
tclPropertySheet->Location = Point(14, 16);
tclPropertySheet->Size = System::Drawing::Size(310, 170);
Controls->Add(tclPropertySheet);
}
};
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
Application::Run(gcnew CExercise());
return 0;
}
This would produce:
As mentioned previously, a tab control is made of tabs. These are the actual objects that make up a tab control. A tab control can one or more of them. If you create only a tab control in your application, it is useless and doesn't play its intended role. To make it useful, you must add property pages to it.
To support property pages, the .NET Framework provides the TabPage class. Because the property pages completely depend on the tab control, the TabPage class is not represented in the Toolbox. If you want to add a tab page to a tab control, the TabControl class is equipped with a property named TabPages, which is of type TabPageCollection. TabPageCollection is a collection class that implements the IList, the ICollection, and the IEnumerable interfaces. If you create a tab control at design time by taking it from the Toolbox and adding it to a form, the tab control gets automatically equipped with two tabs. Here is an example:
At design time, to add a property page, you have various options:
If you create the tab pages at design time, like all other controls, the names of tab pages are cumulative. As you add them, the first would be named tabPage1, the second would be named tabPage2, etc. If you plan to programmatically refer to the tab pages, you should give them more explicit names. As done with any other control, to set the name of a property page, after selecting it, in the Properties window, change the value of the (Name) field. To programmatically create a property page, declare a handle to TabPage, allocate memory for it using the gcnew operator, and add it to the Controls collection of its eventual tab control. Here is an example: public ref class CExercise : public Form
{
private:
TabControl ^ tclPropertySheet;
TabPage ^ pgeController;
public:
CExercise()
{
InitializeComponent();
}
void InitializeComponent()
{
Size = System::Drawing::Size(345, 228);
tclPropertySheet = gcnew TabControl;
tclPropertySheet->Location = Point(14, 16);
tclPropertySheet->Size = System::Drawing::Size(310, 170);
pgeController = gcnew TabPage;
tclPropertySheet->Controls->Add(pgeController);
Controls->Add(tclPropertySheet);
}
};
This would produce:
Alternatively, you can create a handle to TabPage, allocate memory for it using the gcnew operator, and add it to the TabPages collection of its tab control. Here is an example: public ref class CExercise : public Form
{
private:
TabControl ^ tclPropertySheet;
TabPage ^ pgeController;
TabPage ^ pgeAccount;
public:
CExercise()
{
InitializeComponent();
}
void InitializeComponent()
{
Size = System::Drawing::Size(345, 228);
tclPropertySheet = gcnew TabControl;
tclPropertySheet->Location = Point(14, 16);
tclPropertySheet->Size = System::Drawing::Size(310, 170);
pgeController = gcnew TabPage;
tclPropertySheet->Controls->Add(pgeController);
pgeAccount = gcnew TabPage;
tclPropertySheet->TabPages->Add(pgeAccount);
Controls->Add(tclPropertySheet);
}
};
If you have added a page by mistake or you don't want a particular page anymore, you can remove it. To remove a property page, first click its tab to select it. Then,
To programmatically delete a tab control, call the Remove() method of the TabPages property.
Many of the effects you will need on pages have to be set on the TabControl control and not on individual pages. This means that, to manage the characteristics of pages, you will change the properties of the parent TabControl control. At any time, whether working on the TabControl control or on one of its tab pages, you should first know what object you are working on by selecting it. To select the TabControl control itself, you have two main options:
At run time, neither the user nor you would really need to select a tab control. On the other hand, with code, you can refer to the tab control using its name.
Before manipulating a tab page, you must first select it. You various options:
As described in our introduction, to select a property page, the user can click its tab. To programmatically select a tab page, you have various options. We mentioned already that the tab pages are added cumulatively. The application keeps track of their position. To keep track of the positions of the tab pages, the TabControl class is equipped with a property named SelectedIndex. Based on this, to select a tab page using its position, assign the desired index to this property. Here is an example: System::Void button1_Click(System::Object^ sender,
System::EventArgs^ e)
{
tabControl1->SelectedIndex = 1;
}
You can also call the TabControl::SelectTab() method. In this case, pass the tab index to the method. An alternative is to select a tab page using its object name. To support this, the TabControl class is equipped with the SelectedTab property. Using it, to select a tab page, assign its name to the SelectedTab property. Here is an example: System::Void button1_Click(System::Object^ sender,
System::EventArgs^ e)
{
tabControl1->SelectedTab = tabPage3;
}
You can also call the TabControl::SelectTab() method. In this case, pass the name of the tab to the method. Both the TabControl::SelectedIndex and the TabControl::SelectedTab property are read/write. This means that, besides selecting a property page, you can use them to find out what tab page is currently selected. To do this, simply get the value of the control at the time you are accessing it. |
|
|||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||
to display the TabPage Collection Editor dialog box that allows you
create and configure each page by clicking its Add button:
