Controls Fundamentals

 
Windows Fundamentals
 
Introduction to the Win32 Library
A library is a set of published documents. It could consist of a piece of paper, a book, or
a group of books used as a (written) reference for a specific purpose. The programs
that are on a Microsoft Windows operating system follow a set of rules and suggestions
defined in a library called Win32 (Windows 32-bits). Win32 is a group of functions,
objects, variables, and constants that define how the Microsoft Windows (95 and
above) operating systems function. As a reference, it allows individuals and companies
to know what is necessary in order to create or develop applications for this specific
platform.

Over all, it is not strictly necessary to know Win32 thoroughly to write programs; but it is highly
recommended to know most of the intricacies of its implementations. You should know as much
as possible about Win32 to be an effective Windows programmer.

In order to create a Win32 application in Borland C++ Builder, you would call the New Items
dialog box. From the General property page, you can click the Console Application icon and click
OK. From the Console Wizard dialog box, click the C++ radio button and make sure the Console
Application check box is unchecked.

As every C++ application specifies the main() function as its entry point, every Windows
application must have a function called WinMain. If you start a Win32 application using the
Console Wizard, Borland C++ Builder would display syntax of the WinMain() function. This is:

int WINAPI WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow);

If you start a default graphical application, a source file with the name of the project would be
created and it would have this syntax of the WinMain() function:

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

Practical Learning: Creating an Application

1. To start Borland C++ Builder, click Start -> (All) Programs -> Borland Developer Studio
2006 -> C++ Builder
2. On the main menu, click File -> New -> Other... 
3. On the New Items dialog box, click Console Wizard
 
 4. Click OK
5. In the Console Wizard dialog box, accept the C++ radio button and the Use VCL check box.
Clear the check mark on the Console Application chez box
 

6. Click OK

7. To save the application, on the Standard toolbar, click the Save All button

8. On the toolbar of the dialog box, click the Create New Folder button
9. Type Application1 and press Enter twice to put it in the Save In combo box
10. Change the name of the Unit1.cpp file to Exercise and click Save
11. Change the name of the project to Application1 and press Enter
12. Click the Exerice.cpp tab to access its file

C++ Builder Application Fundamentals

To make application development easier, that is, to provide Rapid Application Development
(RAD), the Visual Component Library (VCL) is equipped with various classes. To start a computer
 application in a Win32 environment, you must create an application. This is done using the
WNDCLASS or the WNDCLASSEX structure. These two structures are defined as follows:

typedef struct _WNDCLASS { typedef struct _WNDCLASSEX

UINT style; {
WNDPROC lpfnWndProc; UINT cbSize;
int cbClsExtra; UINT style;
int cbWndExtra; WNDPROC lpfnWndProc;
HINSTANCE hInstance; int cbClsExtra;
HICON hIcon; int cbWndExtra;
HCURSOR hCursor; HINSTANCE hInstance;
HBRUSH hbrBackground; HICON hIcon;
LPCTSTR lpszMenuName; HCURSOR hCursor;
LPCTSTR lpszClassName; HBRUSH hbrBackground;
} WNDCLASS, *PWNDCLASS; LPCTSTR lpszMenuName;
LPCTSTR lpszClassName;
HICON hIconSm;
} WNDCLASSEX,
*PWNDCLASSEX;

For a Win32 application, you must declare a variable of one of these structures. Then you should
provide or at least control the value of each of the member variables. Fortunately, to simplify this
process, the VCL provides two fundamental classes used to create an application. They are
TApplication and TScreen.

TApplication is used to create, or get access to, an application. It is the main central point of an
application as a Windows entity.

The TScreen class is used to access the computer’s desktop, its size, the monitor your are using,
and other pieces of information related to a screen as an object or related to the objects of an
application.

To give you ample access to the application and to the screen, every GUI application you develop
using the VCL declares a TApplication and a TScreen variables. This means that you will
hardly, if ever, need to declare these variables since they are already available to your
application.

To create an application, the TApplication class provides the Initialize() method. Its syntax is
simply:

void __fastcall Initialize(void);

This creates an empty application without much to do.

Application’s Instance
If you start an application such as Notepad, you are said to have created an instance of the
application. In the same way, when you declare a variable of a class, an instance of the class is
created and made available to the project. In fact, when you create an application, you must
create an instance of that application so it can be made available to the operating system. Such
an instance must be passed to the WinMain() function. Once the instance exists, it can be
accessed either by any control of the same application or by the operating system for any reason.

When you create a VCL application, a variable of type TApplication is declared and the instance
of the application is globally made available to anything that needs it. The instance of the
application is called HInstance.

Practical Learning: Creating an Application

 1. In the body of the WinMain() function, call the TApplication::Initialize() method before
the return line:
 
//-------------------------------------------------------------------
--------
#include <vcl.h>
#include <windows.h>
#pragma hdrstop

//-------------------------------------------------------------------
--------

#pragma argsused
WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
Application->Initialize();

return 0;
}
//-------------------------------------------------------------------
--------
2. To save the application, on the Standard toolbar, click the Save All button

Introduction to User Interface Objects

After creating an application, you can create an object that the user will look at when interacting
with the computer. Such an object is called a window. Most of the things you see on the screen
or on an application are window objects. As various as they are, there are different techniques
used to create them.

The primary window and the most frequent object you will use in your applications is the form.
Therefore, after creating an application, the next step you probably take is to create a form.
Because C++ Builder provides a rapid application development (RAD) environment, a form is
related in two steps. First you must provide its resource. This is done by visually adding a form
available from clicking the New Form button on the Standard toolbar or by clicking File -> New
-> Form on the main menu.

After creating the form’s resource, you must let the application know that you have a have. To do
this, you must call the CreateForm() method of the TApplication class. Its syntax is:

void __fastcall CreateForm(System::TMetaClass* InstanceClass, void *Reference);

The name of the form is passed as pointer as the second argument. Because the form is being
added to the application, giving the application access to it for further operations and processing,
the CreateForm() method requires that the class that controls the form be specified. This is
normally done by calling the __classid() operator. Once you have specified the form to the
application, you must also specify the name of the source file that holds the implementation of
the form. This is done by calling the USEFORM macro. Its syntax is:

USEFORM(FileName, FormName)

This macro takes two arguments. The first is a string that specifies the source file. The second
specifies the name of the form as it appears in the project.

In future lessons, we will see that various object controls spend their time sending messages to
the application. As the application receives them, it processes them and acts appropriately. For
example, the application can be made aware that the user wants to close it. To process such
messages, the TApplication class uses a method called Run(). Its syntax is:
void __fastcall Run(void);

Therefore, an application should (must) call this method to process its assignment. If Run() is
not called, the application will compile and execute fine but because it cannot process messages,
it will not display anything (displaying something on the screen is a message by itself and must
be processed).

Practical Learning: Adding a Form to an Application

1. To add a form to the application, on the main menu, click File -> New -> Form - C++
Builder
2. To save the new form, on the Standard toolbar, click the Save All button
3. Change the name of the file to Central and click Save
4. Note the name of the form as Form1.
Press F12 to access the Code Editor window
5. Click the Exercise.cpp tab to access its file and change the content of the file as follows:
 
//-------------------------------------------------------------------
--------

#include <vcl.h>
#include <windows.h>
#pragma hdrstop
USEFORM("Central.cpp", Form1);

//-------------------------------------------------------------------
--------

#pragma argsused
WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
Application->Initialize();
Application->CreateForm(__classid(TForm1), &Form1); 
Application->Run();

return 0;
}
//-------------------------------------------------------------------
--------
6. To test the application, press F9
 
 7. Close it and return to Borland C++ Builder

Design and Run Times

To create your applications, there are two settings you will be using. If a control is displaying on
the screen and you are designing it, this is referred to as Design Time. This means that you have
the ability to manipulate the control. You can visually set the control’s appearance, its location,
its size, and other necessary or available characteristics. The design view is usually the most
used and the easiest because you can glance at a control, have a realistic display of the control
and configure its properties. The visual design is the technique that allows you to visually add a
control and manipulate its display. This is the most common, the most regularly used, and the
easiest technique.

The other system you will be using to control a window is with code, writing the program. This is
done by typing commands or instructions using the keyboard. This is considered, or referred to,
as Run Time. This is the only way you can control an object’s behavior while the user is
interacting with the computer and your program.

Techniques of Adding Controls to an Application

 

Overview
A Windows control is a graphical object that allows the user to interact with the computer. The
controls are as varied as the needs and goals are. Because there are so many controls for various
purposes, their design and creation are left to the computer programmer.

When you start Borland C++ Builder, it creates and displays an empty form. It also provides its
various controls on the Tool Palette so you can choose which ones are appropriate for your
particular application. Otherwise, to create a graphical application, you can click File -> New ->
Application from the main menu. You can also click the New button on the Standard toolbar.
From the New Items dialog box, also called the Object Repository, you can click the type of
application or file you would like to create.

Controls can be set by categories based on their function or role. A container is a control whose
main purpose is to host other controls. To design it, you pick up objects from the Tool Palette and
drop them where desired. The most common and the most widely used container is the form. In
Borland C++ Builder, a form can be configured to display like a regular dialog box, to become a
Single Document Interface (SDI) or to participate in a Multiple Document Interface (MDI)
application.

All of the applications we will create in this book qualify as graphical user interface (GUI). A GUI
application is one that displays Windows controls to the user who acts on them to interact with
the computer.

Practical Learning: Introduction to Form Design

 To create an application, on the main menu, click File -> New -> VCL Forms Application -
C++ Builder

The Tool Palette

When creating an application, you will be adding Windows controls, also called controls, to it.
Most of the controls you will use reside on the Tool Palette:
There are various sections of objects on the Tool Palette. Each section has a header that displays
either a - or a + button. This allows you display or to hide the items in a section. To display the
items of a section, you must expand, which you can do by clicking its + button. To hide the items
of a section, you must collapse it, which you can do by clicking its - button.

Some sections of the Tool Palette holds the Windows controls you will use to create or design an
application. The controls on the Tool Palette are grouped into categories:

As mentioned already, you can expand or collapse a section at will.

In our lessons, we will study the controls as they are needed, in a cumulative fashion. We
 will not follow the categories as set on the Tool Palette. For this same reason, although
controls in Microsoft Windows are sometimes classified as Standard Controls (those that
were already available before Windows 95) and Common Controls (those that were
released with Windows 95 and added subsequently), in our lessons, unless specified
otherwise, the Windows controls will be considered regardless of their release date.

The controls are represented each by a specific button. Some of the buttons display an
appearance that easily suggests their role. Some others may not be obviously identified. In any
case, to find out what control a button represents, you can position your mouse on it. A small
yellow box called a tool tip or a hint would display. With experience, you will find out that the hint
reflects the actual name of the control:

 
From now on, each button on the Tool Palette will be called by its tool tip.

Rapid Application Development (RAD) consists of selecting the controls that are necessary for
your application and use them as you see fit. There are various techniques you can use to add a
control to your application.

Practical Learning: Introduction to Form Design

1. To add the first control, on the Tool Palette, expand the Standard section.
From the Standard section, double-click TButton
2. Notice that a button control is added to the form

3. To add another control, double-click TEdit

4. Notice that the second control is positioned on top of the first because whenever you
double-click a control from the Tool Palette, it gets positioned in the middle of the form
 
Actually when you double-click a control on the Tool Palette, it gets
positioned in the middle of the selected container. If the selected control
on the form is not a container, the control you double-click would be
positioned in the middle of the form.

5. To add another control, on the Tool Palette, click TMemo

6. To draw a Memo on the form, position the mouse in the top middle section of the form, then
click and hold the mouse. Drag to the center right section of the form:
 
 7. Release the mouse. Notice that a memo has been added to the form
8. There are other controls that do not use dimensions. You just click them and click on the
form. Their presence is more important on a form than their physical location. To see an
example, on the Tool Palette, expand the Dialogs section

9. Click the TColorDialog button 

10. Click and drag on the form to draw a big rectangular box and release the mouse
11. Notice that the icon keeps its set width and height
12. To display the code for the form, press F12. Notice that although we have added controls,
none of their code has been written
13. To display the header file for the form, on the lower section of the Code Editor, click the
unit1.h tab
14. Notice the list of the objects that were added and their names set by Borland C++ Builder
15. To display the form, press F12 and click on an unoccupied area on the form

User Interface Design

Creating a good-looking application is a combination of art, intuition, and logic. Not all IDEs
provide the same features but Borland C++ Builder is enhanced on this aspect. We will learn how
to configure various controls as we move on. The first thing to do is to get familiar with what can
ease the user’s experience with your application.

When designing an application, you will usually position the desired controls on a form. You will
you decide what control you need, where it will be positioned on the form and with regard to
other controls, what appearance it should have, and what behavior should be customized.

Practical Learning: Adding Controls

1. To start a new program, on the main menu, click File -> New -> VCL Forms Application - C+
+ Builder. If you are asked whether you want to save your project, click No
2. On the Tool Palette, expand the Standard section.
Click the TEdit control
3. Click the center-top section of the form (it is not important how it is positioned):
  

4. On the Tool Palette, click the TEdit control again

5. This time, click the middle left section of the form (again, the position is not important):
 

6. Once again, on the Standard section, click the TEdit control

7. This time, click in the lower-left section of the form and hold the mouse down
8. Drag in the opposite directions to draw a tall and wide rectangle:
 

9. Release the mouse

10. Notice that the control gets the same height as the other edit boxes

11. In the Standard section again, click the TMemo control

12. Click and drag on the form from the lower-right section to the upper-center section of the
form and release the mouse
13. Notice that this time, the memo keeps the drawn dimensions
14. To add another control, in the Standard section, click the TActionList control

15. Click and drag on the form to draw a tall and wide rectangle. Then release the mouse
16. Notice that the new control keeps a constant shape
17. To add another form, on the main menu, click File -> New -> Form - C++ Builder
18. While Form2 has focus, in the Standard section of the Tool Palette, double-click the Edit
control to place it on Form2

19. In the Standard section, click the TPanel control

20. On the form, click in the lower right section of the form and drag to the upper-center section
of the form to draw a rectangle that partially covers the edit box (ne need for precision).
Release the mouse:
 

21. Make sure the new panel is still selected. From the Standard section, double-click the Edit
control:
 

22. Notice that the new edit box is positioned in the center of the panel and not in the center of
the form. This is because the Panel control is a “container” and can hold its own controls
 23. From the Standard section of the Tool Palette, click the TEdit control
24. Click inside the panel but just above the Edit2 edit box (no need for precision)
 

Controls Maintenance
 

Controls Selection
While you are designing a form and it is hosting controls, it is important to always know what
particular control is selected. Whenever you make changes, they are applied to the control that
has focus.

A control that is selected or highlighted is described as having focus.

There are various techniques used to give focus to a control:

 On the form, you can click the desired control

 In the combo box on the upper section of the Object Inspector, you can select the desired
control
 

 You can select a control by clicking its name in the tree list of the Structure window
  

 On the form, you can click one control, then press the up, the down, the right, and/or the
left arrow keys to select a different control

To select a form, click an unoccupied area on the form. If the form is hidden, you can press F12
to toggle between the form and the code. If your application has more than one form, to display
one of them, on the main menu, you can click View -> Forms and select the desired form from
the list.

Practical Learning: Selecting Controls

1. To display one of the forms, on the main menu, click View -> Forms…
2. From the View Form dialog box, click Form1
 

3. Click OK and, in the lower-right section of the code editor, click Design
4. To select one of the controls, click the memo box. Also notice the Name field in the Object
Inspector:
 
5. To select another control, in the Structure window, click Edit3
6. Notice that, on the form, the Edit3 control receives focus
 

7. To select another control, click the arrow on the upper section of the Object Inspector and
click Edit2
 
8. Notice the new selected name in the Object Inspector
9. On the form, click Edit1 to select it
10. While one of the controls, namely Edit1 is still selected, press the up, down, left, and right
arrow keys on the keyboard to select other controls on the form
11. Click anywhere on the form and not on a control. Notice that the form is selected. You can
verify this by checking the name on the top section of the Object Inspector
12. On the form, click Memo1 to select it
13. To dismiss the selected control, press Esc. Notice that the form is now selected
14. To hide the form, press F12
15. To display the form again, press F12
16. To select two controls, on the form, click Edit2
17. Press and hold Shift
18. While you are still holding Shift, click Edit3 and click the ActionList button
19. Release Shift. Notice that the controls have handles on their corners, indicating that they
are selected. The Object Inspector displays properties that are common to the selected
controls
20. To make another selection, just under the lowest edit box on the form, click and drag up
and right as to draw a rectangle that would touch Edit2, Edit3, and Memo1:
 
 21. Then release the mouse. Notice that the touched controls are selected
22. Press Shift + F12 to display the View Form dialog box
23. Press the down arrow key to select Form2 and press Enter. Notice that Form2 displays

The Name of a Control

Every object of an application must have a name. This also applies to the Windows controls you
add to your application. When you create a form, Borland C++ Builder assigns it a default name,
such as Form1, or Form2. In the same way, if you add a control to a form, the control receives a
default name, such as Edit1 or Panel1. Most of the time, you should change that name to reflect
the role of the control in your application.

To change the name of a control, first select it. Then, in the Object Inspector, click the Name field
and type the desired name. Each control in the same application must have a unique name.

Controls Moving
Any control on a form can be moved to a desired location either to accommodate other controls
or based on new demands:

 To move a control, click and hold your mouse on it; then drag your mouse to the desired
location, and release the mouse
 To move a group of controls, first select them; then click one of the selected controls and
drag to the desired location, and release the mouse.
If the controls are hosted by another control, you can move all of them when moving the
container
 To move a control or a group of controls by one pixel, first make the selection. Press and
hold Ctrl. Then press one of the arrow keys. Once you are satisfied with the location, release
the Ctrl key.
 To move a control or a group of controls by one grid unit, first make the selection. Press and
hold Shift + Ctrl. Then press one of the arrow keys. Once you are satisfied with the location,
release the Ctrl key.

There are two valuable dialog boxes available to move controls. To solve alignment issues, access
the Align dialog box from the main menu by clicking Edit -> Align…
 To better control the relative alignment of controls, you can use the Alignment toolbar. To access
it, on the main menu, you can click View -> Toolbars -> Align:

Because it may be equipped with buttons you are not familiar with, to know what a button is for,
you can position the mouse on it and wait for the tool tip.

When dealing with relative dimensions, call the Size dialog by clicking Edit -> Size…

Control Resizing
Most controls, including the form, can be resized using guiding mouse cursors. To resize a
control, first select it. Except for the form, whenever a control is selected, there are eight handles
around it. To resize the control, position your mouse on one of the handles. The mouse pointer
will change, indicating in what direction you can move to resize the control

Cursor Role

Moves the seized border in the North-West <-> South-East direction

Shrinks or heightens the control

Moves the seized border in the North-East <-> South-West direction

 Narrows or enlarges the control

To resize the control by one grid unit, click one of the handles and drag in the desired location.
Once satisfied, release the mouse.

To resize a control by the small possible unit, select the control. Press and hold Alt. Then click the
desired handle and drag in the desired direction. Once satisfied, release the mouse and Alt.

Practical Learning: Resizing Controls

1. To resize the form, position your mouse on its right border until the mouse turns into double

horizontal arrow
2. Click and drag left for one inch
3. Release the mouse

4. Position the mouse on the lower right corner 

5. Click and drag in the upper right direction, to acceptable dimensions
6. Release the mouse
7. To resize a control, on the form, click ActionList
8. Position the mouse on its lower left corner until the mouse turns into a double arrow
9. Click and drag in the lower left direction and release the mouse
10. Notice that the control’s dimensions did not change but the icon moved
11. Click Memo1
12. Position your mouse on its left border until the pointer turns into a double horizontal line
13. Click and drag to the left to enlarge it. Then release the mouse
14. Click anywhere on the form to select it

Controls Navigation
Controls navigation has to deal with not only the alignment of controls on a form but also the
logical process the user should follow when using your product. The Tab key on your keyboard is
the primary means for users to navigate from one control to another. The tab order is the
sequence of controls that the keyboard follows when the user presses the Tab key. Sometimes,
after creating a form, this navigation sequence does not follow the right logic. You usually have
to adjust that sequence. This is done from the Edit Tab Order dialog box.

Practical Learning: Navigating a Form

1. To start another project, on the main menu, click File -> New -> Other…
2. From the New Items dialog, int the Items Categories list, click C++Builder Project
3. In the right list, click VCL Forms Application
 
4. Click OK
5. When asked whether you want to save the current project, click No

6. From the Standard section of the Tool Palette, click TEdit and click the form
7. Add other edit controls as Edit2, Edit3, and Edit4

8. From the Standard section of the Tool Palette, click TButton and click the form
to add a button control to the form
9. Add one more button
10. Add two more TEdit controls
11. Move and resize your controls on the form as follows:
 

12. To test the form, press F9

13. Notice that Edit1 is highlighted, meaning it has focus
14. Press Tab and notice that when the second edit box receives focus, its content is
highlighted:
 
15. Press Tab a few times until the left button receives focus:
 

16. Close the form

17. To adjust the navigation sequence, right-click an empty area on the form and flick Tab
Order…
18. On the Edit Tab Order dialog, click Button1: TButton

19. Click the down pointing button twice

20. Click Edit6: TEdit

21. Click the up pointing button

22. Rearrange the list on the Edit Tab Order dialog as follows:
 
 23. Click OK
24. To test the form, press F9
25. On the form, Press Tab a few times and notice the new sequence of navigation
26. Close the form

Runtime Creation of Controls

 

Window Creation
As seen above, in a RAD environment, the primary means of adding a control to an application
consists of visually adding it to a container such as a form. In the world of Win32 programming, a
control can only be created programmatically. In a VCL application, you can either add a control
at design time or programmatically create it.

To create a control, the Win32 library provides two main functions: CreateWindow() and
CreateWindowEx().

VCL Control Creation

To programmatically create a control in a VCL application, you must know its base class. This is
fortunately very easy to find out. If the control is one of the types of objects of the Tool Palette,
you can use the exact name that displays. Examples are TEdit, TPanel, or TMemo.

The VCL requires that a dynamic control be declared as a pointer.

Windows Controls and their Properties

 

Overview of Controls Properties

A property is a piece of information that characterizes a control. It could be related to its location
or size. It could be its color, its identification, or any visual aspect that gives it presence on the
screen.

The properties of an object can be changed either at design time or at run time. You can also
manipulate these characteristics both at design and at run times. This means that you can set
some properties at design time and some others at run time.

To manipulate the properties of a control at design time, first click the desired property from the
Tool Palette. Then add it to the form or to a container control. To change the properties of a
control at design time, on the form, click the control to select it. Then use the Object Inspector:
Properties Categories
Each field on the Object Inspector has two sections: the property’s name and the property's
value:

The box on the right side of each name represents the value of the property that you can set for
an object. There are various kinds of fields you will use to set the properties. To know what
particular kind a field is, you can click its name. But to set or change a property, you use the box
on the right side of the property’s name: the property's value, also referred to as the field's
value.

Empty fields: By default, these fields have nothing in their

properties. Most of these properties are dependent on other settings of your program. For
example, you can set a menu property for a form only after you have created a menu.

To set the property on such a field, you can type in it or select from a list. If you type an invalid
value and press Enter, you would receive an "Invalid Property Value" error:

Text Fields: There are fields that expect you to type a value.
Most of these fields have a default value. To change the value of the property, click the name of
the property, type the desired value, and press Enter. While some properties, such as the
Caption, would allow anything, some other fields expect a specific type of text, such as a numeric
value. If you type an invalid value, you would receive an error:

You can click OK to dismiss the error dialog and type a new valid value.

Expandable Fields: Some fields have a + button. This indicates

that the property has a set of sub-properties that actually belong to the same property and are
set together. To expand such a field, click its + button and a – button will appear:

To collapse the field, click the – button. Some of the set properties are created from an
enumerator. Since the field was created as a Pascal-style set, this allows the property to have
 more than one value. For example, the BorderIcons property can have the minimize and the
maximum buttons. Some other fields that have a + button are actually complete classes or a
combination of classes.

Boolean Fields: Some fields can have only a true or false value.
To change their setting, you can either select from the combo box or double-click the property to
toggle to the other value.

Action Fields: Some fields would require a list of items and need
to be controlled by an intermediary action. Such fields display an ellipsis button. When you click
the button, a dialog box would come up and you can set the value for the field. You can also
double-click the field value to call the dialog.

Selection Fields: To change the value of some of the fields, you

would use their combo box to display the available values. After clicking the arrow, a list would
display:

There are various types of selection fields. Some of them display just two items. To change their
value, you can just double-click the field. Some other fields have more than two values in the
field. To change them, you can click their arrow and select from the list. You can also double-click
a few times until the desired value is selected. On some other properties, you can double-click
the field and a dialog box would come up.

 
 
Previous Copyright © 2004-2007 Yevol Next