Setting and Adding Properties to a Windows Form

Create a Windows form by using the Windows Forms Designer:

• Add and set properties on a Windows form.

The properties of an object provide a mechanism through which objects can expose their characteristics to the external world. In the following sections you will learn how to customize a form's appearance by using its properties. You will also learn how you can add your own properties to a form.

Using the Visual Designer to Set Windows Form Properties

A Windows form derives from several other classes, such as Object, Control, and so on, through a chain of inheritances. As a result of this inheritance, the Windows form inherits the properties of its parent classes in addition of its own specific properties. All these properties are available for easy manipulation through the Properties window in Visual Studio .NET. Step by Step 1.4 shows you how to manipulate some of these properties to get a feel for how they affect the behavior of a form.

[STAThread]
static void Main()
{
    Application.Run(new StepByStep1_4());
}

In Step by Step 1.4, you manipulate various properties of a form to change its visual appearance. When you invoke the Properties window for the form, you see a big list of properties that are available to you. These properties provide significant control over the characteristics of the form. Table 1.5 lists some of the important properties of the Form class.

The properties in Table 1.5 have various data types. You will find that some properties, such as FormBorderStyle, are enumeration types; some properties, such as Size, are of type struct, and their values are determined by the values of their contained members (for example, X and Y); other properties, such as MinimizeBox, accept a simple Boolean value. The Properties window provides a nice user interface for working with these values.

To increase your understanding about what's going on behind the scenes, it would be a good idea to switch to the code view, expand the Windows Form Designer Generated Code region, and analyze the generated code.

Setting Windows Form Properties Programmatically

Using the Windows Forms Designer is a quick and easy way to manipulate control properties, but the designer can only set the properties at design time. What would you do if wanted to change the appearance of a form at runtime? You could write your own code in the code view. In complex projects, as you need more functionality in an application, you will find yourself switching frequently to the code view. Sometimes you can learn a lot about the .NET Framework by using the code view because it gives you an opportunity to directly play with .NET Framework data structures.

Step by Step 1.5 lets you explore some more properties of a Windows form and programmatically code the properties that are used in Step by Step 1.4. Step by Step 1.5 also shows you how to create a form programmatically.

[STAThread]
static void Main()
{
    // Create StepByStep1_5 object
    // and set its properties
    StepByStep1_5 frm1_5 = new StepByStep1_5();
    frm1_5.BackColor = Color.AntiqueWhite;
    frm1_5.FormBorderStyle =
        FormBorderStyle.FixedSingle;
    frm1_5.Size = new Size(400,200);
    frm1_5.StartPosition =
       FormStartPosition.CenterScreen;
    frm1_5.MinimizeBox = false;
    Application.Run(frm1_5);
}

In Step by Step 1.5, when you add a new Windows form to a project, a new class representing that form is created. As you can see in the code in Step by Step 1.5, you first create an object of the class so that you can later modify the object's properties. The modified form object is then passed as a parameter to the Application.Run() method that invokes the form.

While you are typing code in the code view, you see Visual Studio .NET helping you with the properties and syntaxes via IntelliSense. You should also note that values for properties such as BackColor and FormBorderStyle are encapsulated in enumerated types. You can find out what enumerated type to use for a property by hovering your mouse pointer over a property name in the code view. This displays a ToolTip that helps you identify the type of a property.

If you compare the code that you write manually in Step by Step 1.5 with the code that is generated by the Windows Forms Designer in Step by Step 1.4, you should see that the most significant difference is that the designer includes all its code for setting form properties in the InitializeComponent() method.

You can alternatively place the code inside the form's constructor after the call to the InitializeComponent() method. Including the code in the constructor ensures that the code is executed every time an instance of the form is created. The effect in this case would be the same as the effect of placing the code in the InitializeComponent() method.

So far you have seen how to get and set properties for a Windows form. The Form class also provides a set of methods, and Step by Step 1.6 demonstrates how to use them.

STEP BY STEP 1.6 Invoking Methods of Windows Forms 1. Open the project 316C01. In the Solution Explorer right-click the project name and select Add, Add Windows Form from the context menu. Name the new form StepByStep1_6. 2. Right-click anywhere on the form and select View Code from the context menu. In the code view, insert the following code just after the Windows Form Designer Generated Code region: [STAThread] static void Main() { // Create StepByStep1_6 object // and set its properties StepByStep1_6 frmBottom = new StepByStep1_6(); frmBottom.BackColor = Color.AntiqueWhite; frmBottom.FormBorderStyle = FormBorderStyle.FixedSingle; frmBottom.Size = new Size(400,200); frmBottom.StartPosition = FormStartPosition.CenterScreen; frmBottom.MinimizeBox = false; // Create a new form and set its // properties to stay on top Form frmOnTop = new Form(); frmOnTop.TopMost = true; frmOnTop.Opacity = 0.7; frmOnTop.Show(); Application.Run(frmBottom); } NOTE The Opacity Property Transparent forms are supported only on operating systems that can display layered windows. Such operating systems include Windows 2000, Windows XP and later versions of Windows. The Opacity property has no effect when you run a program on older operating systems such as Windows 98. 3. In the Solution Explorer, right-click the project name and select Properties from the context menu. In the Property Pages window, select _316C01.StepByStep1_6 as the startup object. Click OK to close the Property Pages window. 4. Select Debug, Run. The application displays two forms. The top form is transparent and stays on the top, even when you click the other form (see Figure 1.13). Figure 1.13. The Show() method sets the Visible property of a form to true. [View full size image]

In Step by Step 1.6 you create a new form by creating an instance of the Form class. You set the properties of the new form so that it is the topmost form in the application and then you reduce the opacity to make the form slightly transparent. Finally, you invoke the Show() method of the form to actually display the form onscreen.

There are two forms in Step by Step 1.6, but you are calling the Show() method for only one of them. When you run the program, you actually see both forms onscreen. How? It happens because frmBottom is passed as a parameter to the Application.Run() method. When the Application.Run() method starts the application by launching frmBottom onscreen, in the process it internally calls the Show() method for frmBottom. In the running program, if you close frmOnTop, you close just that form, but if you close frmBottom, you close all open forms and quit the application.

[STAThread]
static void Main()
{
    Application.Run(new GuidedPracticeExercise1_1());
}

Adding New Properties to a Windows Form

In addition to using the existing properties, you can add custom properties to a Windows form. You can use a custom property to store application-specific data.

//define constant values for State
public enum State{Idle, Connecting, Processing}

//use this field as storage location
//for FormState property
private State formState;

//set attributes for FormState property
[Browsable(true),
EditorBrowsable(EditorBrowsableState.Never),
Description("Sets the custom Form state"),
Category("Custom")]

//Creating FormState property
public State FormState
{
    get
    {
        return formState;
    }
    set
    {
        formState = value;
        switch (formState)
        {
            case State.Idle:
                this.BackColor = Color.Red;
                this.Text = "Idle";
                break;
            case State.Connecting:
                this.BackColor = Color.Orange;
                this.Text = "Connecting...";
                break;
            case State.Processing:
                this.BackColor = Color.Green;
                this.Text = "Processing";
                break;
        }
    }
}

public StepByStep1_7()
{
    // Default code of the Constructor
    //set the FormState property of this form
    this.FormState = State.Processing;
}

[STAThread]
public static void Main()
{
    Application.Run(new StepByStep1_7());
}

The most important thing to note in Step by Step 1.7 is that you add a custom property named FormState to a form. The property that you create is even visible in the IntelliSense list when you try to access the members of this form object by typing a period (.) after the form's name in the form's constructor code.

To a program that uses the properties, the properties in Step by Step 1.7 look just like data fields, but properties by themselves do not have any storage locations, and their definitions look almost like method definitions. Properties provide two accessors (get and set) that would be called when a program would like to read from or write to the property. In Step by Step 1.7 you use a private field formState that works as a storage location for the FormState property; because formState is private, the rest of the world can access it only through the FormState public property. The data type of FormState is the enumerated type State, defined with a limited set of named constant values at the beginning of the code segment.

If you go to the design view and inspect the properties of form StepByStep1_7 through Properties window, you will not find the FormState property listed along with other properties. This is because the Properties window shows only the properties of the base class. You can think of it like this: The Properties window helps you design a new class (StepByStep1_7) in terms of a class that already exists (System.Windows.Forms.Form). So while you are designing the StepByStep1_7 class, if the Properties window would rather show the properties of the StepByStep1_7 class, then it's similar to defining a class in terms of a class that is itself under construction.

If you instead define a form by using the completely created class StepByStep1_7, it would make sense to have the FormState property available in the derived form through the Properties window. (I talk about this in a moment.)

Note that the FormState property has a big list of attributes. Such a big list isn't required to create a property, but it helps you specify the runtime behavior of the property. Table 1.6 describes how attributes can control the behavior of a property.

You cannot see the effect of using the attributes listed in Table 1.6 in the form you have been creating. However, you would see their effects if you inherited a form from that form. You'll learn more about this in the next section of this chapter.