Controls { The C# Language }

Controls

Windows Forms or Winforms is a contemporary Windows-based forms package that
endows the Windows programmer with an innovative methodology for creating
aesthetic user interfaces and interactive applications. We will not ramble on
about the pros and cons of the package, but commence the creation of the
smallest GUI (Graphical User Interface) application.

a.cs
public class zzz
{
public static void Main()
{
zzz z = new zzz();
System.Windows.Forms.Application.Run(z);
}
}

Run the compiler as
>csc a.cs

Compiler Error
a.cs(6,1): error CS1502: The best overloaded method match for
‘System.Windows.Forms.Application.Run(System.Windows.Forms.Form)’ has some
invalid arguments
a.cs(6,38): error CS1503: Argument ‘1’: cannot convert from ‘zzz’ to ‘System.Windows.Forms.Form’

An error is generated because, Run, which is a static function in the
Application class of the System.Windows.Forms namespace, requires a Form object.
The error distinctly states its inability to convert a zzz to
System.Windows.Forms.Form, which proves that, an object that looks like Form is
mandatory here, and not zzz.

a.cs
using System.Windows.Forms;
public class zzz : Form
{
public static void Main()
{
Application.Run(new zzz());
}
}

Screen 4.1

This program is not very dissimilar from the previous one. The using keyword is
employed to avoid the inevitability of writing namespace with every object. The
object z has no efficacy here, since we are passing the zzz object directly to
the Run function. As the class zzz is derived from Form, no error is generated.

When we run the program, a small blank window is displayed. You can click on the
‘x’ symbol to close it. The output is substantial enough for a single line of
code.

a.cs
using System.Windows.Forms;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
zzz()
{
Text = "Vijay Mukhi";
}
}

Screen 4.2

In the constructor of the zzz class, we have initialized a member called Text to
the string value ‘Vijay Mukhi’. When we run the program, to our amazement, our
window, which earlier was without a title, now possesses the title ‘Vijay Mukhi’.

This is the introductory concept of Windows Forms programming. The class called
Form has abundant properties such as Text etc., which have specific relevance in
a window. Any modifications to the properties get reflected immediately in the
window. The changes depend upon the properties that we modify. In this case, the
property of Text changes the Caption, text displayed in the title bar.

A Form represents a window displayed by an application. An application can have
different types of windows, such as a standard, tool bar, borderless or floating
window. The Form class is versatile enough to handle all the above types of
windows, as it is derived from innumerable classes. A Dialog Box, which is used
to accept input from the user, is available in two modes viz. modal and
modeless. Our trustworthy Form class can also handle such Dialog boxes with
equal aplomb. We normally use the Form class as the preliminary class for
building WinForms Applications.

The Main method calls the Run function and gives it the Form object. In the
constructor, we can modify the properties of the Form Class to give the window a
desired appearance. Since these properties are not static, they cannot be
altered in Main, but can be modified in the constructor or in any other
function.

a.cs
using System.Windows.Forms;
public class zzz
{
public static void Main()
{
Application.Run(new yyy());
}
}
class yyy : Form
{
public yyy()
{
Text = "Vijay Mukhi";
}
}

Screen 4.3

In this program, we have created another class yyy that derives from the Form
class. We have used this object as a parameter to the function Run. The rules do
not impel us to derive the class zzz from Form. However, in all our programs, we
shall follow the first approach since we have decided to steer clear of
controversy and stick to the rules.

a.cs
using System.Windows.Forms;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
zzz()
{
ClientSize = new System.Drawing.Size(300,600);
Size = new System.Drawing.Size(100,200);
}
}

Screen 4.4

The above example sets two properties of the Form class. The first, which is
called ClientSize, is used by Windows.Forms to decide how large our initial
window would be. This property has a default value, which can be overwritten by
specifying the width and height. As we need to furnish two values, we use a
class called Size in the namespace System.Drawing, which accepts two values.
This class does not insist on receiving meaningful values. The constructor is
passed the width and height of the desired window in pixels.

A graphics screen is divided into small dots or pixels. Depending upon the
configuration of the monitor and graphics card, a computer can handle and
display a certain number of pixels and colors. The higher the configuration, the
larger are the number of pixels and colors that are available.

The size of the client area of the form is computed as the size of the form
minus the borders and the title bar placed by Windows. They are not of our
concern, since we shall be placing our own controls in our form. ClientSize is a
property with a default value, and it gets updated automatically whenever the
form is resized.

The next property is Size. The user enjoys the flexibility of altering the size
of the window at run time. Size is initialized in manner similar to ClientSize.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form
{
Button b;
public static void Main()
{
Application.Run(new zzz());
}
zzz()
{
b = new Button();
Controls.Add(b);
}
}

Screen 4.5

We now see a small button at the top left hand corner of our Window. How did we
create this button? To do so, we first, create an object b, that looks like a
Button class.

The Form class has a large number of properties such as ClientSize, Size etc.
One of them is called Controls, which is a read-only property since it contains
only a Get. This property returns a Control.Collection object, whose Add
function adds the control to the Client area of the window. We shall be sprucing
up our button shortly.

Screen 4.6

Anything that is placed on a form is called a Control or a Widget. Similar to a
Form, a button control, popularly known as a command button, has numerous
properties. One of them is the Location property, which decides the position on
the Client area where the button will be positioned.

Here, we use the Point class and not Size, even though both are objects that
represent two numbers. By convention, a Size object represents a width and a
height and a Point object has an x and y co-ordinate system, starting from the
upper left corner.

Most properties have a default value. Since this fact about default values has
been reiterated numerous times, we shall not repeat it again. The Size property
determines the initial size of the window and the string assigned to the Text
property is displayed on the button.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form
{
Button b;
public static void Main() {
Application.Run(new zzz());
}
zzz()
{
b = new Button();
b.Location = new Point(100,200);
b.Size = new Size(100,50);
b.Text = "Vijay Mukhi is smart";
b.Click += new System.EventHandler(abc);
Controls.Add(b);
}
public void abc(object s, System.EventArgs e)
{
MessageBox.Show("Hi");
}
}

Screen 4.7

In the earlier example, clicking on the button was an exercise in futility
because the button did not achieve anything. After augmenting the code of the
program, when we click on the button, we see a MessageBox that displays the
greeting ‘Hi’. The rationale behind a button control is that, when we click on
it, some code should get executed, some action should take place.

The button class has an event object called Click, which accepts an object of
type EventHandler. The syntax for events uses the += symbol to add a function
that is to be called when the event handler gets activated. The function name is
given through the EventHandler delegate. This delegate has been specially
created only to handle events that a control will generate.

Thus, the function abc, which is passed as a parameter to the EventHandler
delegate, must have a certain signature. The first parameter is the generic
object that could represent any entity identifying the caller. The second
parameter is an EventArgs object, which we will explain shortly. Thus, each time
we click on the button, the function abc gets called. This function in turn
calls the static function Show from the MessageBox class to display ‘Hi’.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form {
Button b;
public static void Main()
{
Application.Run(new zzz());
}
zzz()
{
b = new Button();
b.Location = new Point(100,200);
b.Size = new Size(100,50);
b.Text = "Vijay Mukhi is smart";
b.Click += new System.EventHandler(abc);
b.Click += new System.EventHandler(pqr);
Controls.Add(b);
}
public void abc(object s, System.EventArgs e){
MessageBox.Show("Hi");
}
public void pqr(object s, System.EventArgs e)
{
MessageBox.Show("Bye");
}
}

Screen 4.8

This program reveals the veritable power of events and delegates. Two functions,
abc and pqr, are called whenever the button is clicked. To achieve this, all
that we need to do in the code is to call the Click event again, using the +=
symbol, followed by the name of the new function. The -= symbol is used if we
change our minds. This is a type safe way of calling code in response to an
event.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form {
Button b;
TextBox t;
public static void Main() {
Application.Run(new zzz());
}
zzz()
{
b = new Button();
b.Location = new Point(100,200);
b.Size = new Size(100,50);
b.Text = "Vijay Mukhi is smart";
b.Click += new System.EventHandler(abc);
t = new TextBox();
t.Text = "Hell";
t.Location = new Point(10,20);
Controls.Add(b);
Controls.Add(t);
}
public void abc(object s, System.EventArgs e)
{
MessageBox.Show(t.Text + " " + ClientSize );
}
}

Screen 4.9

In the Forms Window, we now see two controls: a Button and a TextBox object that
lets us enter some text. The textbox widget also has a large number of
properties associated with it. We shall not be repeating this obvious fact for
all the other controls. The properties Location and Size work in a similar
manner when used with any Control, but the property Text differs, depending upon
the object in use. For a button, it represents the caption, whereas for a text
box, it represents the text that is entered. Thus, some of the properties play
different roles when used in different controls.

Screen 4.10

Each time the button is clicked, we would like to display the text that has been
entered by the user in the text box. In the eventhandler function abc, the
property Text reveals the text entered into the textbox. The MessageBox class is
used to display the value, along with the size of the client area.

You can change the size of the window or change the contents of the text box and
observe the contents of the MessageBox changing dynamically.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
public override void Dispose()
{
base.Dispose();
MessageBox.Show( "hi " + ClientSize );
}
}

This program displays our ability to invoke code at a specific point in time,
which in this case, is at the stage when the user closes the window or when the
application quits out. It is akin to fulfilling the last wishes of the program.

Screen 4.11

As the application is quitting, it calls a function called Dispose. So, if you
ever want code to be called at the point when an application is about to quit
out, you must place it in the Dispose function. This code could be used to close
files or do anything else that the programmer desires.

It is not mandatory to call Dispose of the base class, but it is always a good
programming practice to call the base class function first, and then augment it
with your own code. In this particular case, it is inconsequential, but under
different circumstances, things may go out of hand if this advice is not heeded.

In this program, we are overriding a function called OnPaint, which is present
in the Form class. The OnPaint function gets called each time the window has to
be redrawn. Therefore, all code that is to be written to the screen must be
written in this function. This code cannot be placed anywhere else in the
program.

Our next endeavor is to create an object that has functions which display text
on the screen or draw a picture. The class that contains these display functions
is called Graphics. Thus, we create an object g that looks like Graphics. As an
object that looks like Graphics cannot be instantiated, WinForms provides us
with an object of type PaintEventArgs with the OnPaint Function. This class
contains members required for graphical display. Hence, g is initialized to the
Graphics member in e.

As mentioned earlier, OnPaint gets called whenever our window has to be redrawn.
Whenever OnPaint gets called, it creates an object that looks like
PaintEventArgs and then passes it as a parameter to the function. This object
has a member called Graphics, which contains functions used for drawing in our
client area. The DrawString function requires the text that is to be displayed
and its Font.

The Form class provides us with the object called Font. Thereafter, the text
color, or to be more precise, the brush is to be specified. Here, we want a
solid Brush like object. So, we create an object b, and give it a color in which
the text should be displayed. There is a static object Blue in the class Color
that stands for the color blue. The spelling of ‘color’ is as per the American
usage. Finally, the x and y co-ordinates on the screen are specified.

This positions the text in the window at these specified co-ordinates.
Thus, the function has a total of 5 parameters:-

• The text to be displayed.
• The font in which the text is to be displayed.
• The text color or the brush.
• The x co-ordinate.
• The y co-ordinate.

Here, we have specified certain values, but every time we use DrawString, we can
conveniently specify different values for these parameters. Thus, the second
DrawString function can display different text and use a different font or
brush. As the system does not have a default brush or font, we call it a
Stateless Model.

Screen 4.12

Along with ‘Vijay Mukhi’, we have used a variable called ii, which has been
initialized to 0. In the OnPaint function, we increment this variable by 1.
Before the window is displayed, function OnPaint gets called. Thereafter,
OnPaint gets called whenever the ‘minimize’ and ‘maximize’ buttons of the window
are clicked.

The function OnPaint gets called whenever our client area has to be redrawn due
to any action carried out by the user. This function has to be marked with the
modifier named protected. This is because the original function in the Form
class is tagged with this modifier. We can override a function of the base
class, provided we do not change any of the modifiers. By making OnPaint
protected, only derived classes can use the OnPaint function.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form {
public static void Main()
{
Application.Run(new zzz());
}
Brush b; int ii = 0;
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
b = new SolidBrush(Color.Blue);
ii++;
g.DrawString("Vijay Mukhi " + ii, Font, b ,1,25);
RectangleF r = new RectangleF(20, 60, 100, 25);
g.FillRectangle(new SolidBrush(Color.Gainsboro), r);
g.DrawString("Sonal Mukhi", Font, new SolidBrush(Color.Red), r);
StringFormat f = new StringFormat();
f.Alignment=StringAlignment.Center;
RectangleF r1 = new RectangleF(20, 100, 100, 25);
g.DrawString("Sonal Mukhi", Font, new SolidBrush(Color.Black), r1,f);
g.RotateTransform(-30);
g.TranslateTransform(0, 100);
g.DrawString("vijay mukhi", Font, new SolidBrush(Color.Orange), 20, 40);
g.ResetTransform();
}
}

Screen 4.13

The output of this program is a window with text displayed haphazardly. This
output is nothing to write home about, but is useful in elucidating numerous
concepts.

A rectangleF structure stores two point objects i.e. it specifies a rectangular
area of the window. We start at one corner, where the x and y co-ordinates are
20 and 60, and the opposite corner where the x and y co-ordinates are 100 and 25
respectively. The function FillRectangle from the Graphics class is used to
create and fill the above rectangular portion of the screen with the color
Gainsboro. The DrawString function is overloaded to take not only x and y as the
last two parameters, but also a rectangular area into which it will draw a
string.

We would now like to center the above string in the rectangular area. This is
easier said than done, because, it entails creation of an object that looks like
StringFormat with the Alignment property set as Center. The documentation
specifies many more options that can be implemented. The StringFormat object is
passed as the last parameter to the DrawString function, resulting in the string
being shown as centered, instead of being Left aligned, which is the default
setting.

If we want to rotate the image by 30 degrees, we just have to call a function
named RotateTransform from the Graphics class and pass as a parameter, the
amount of rotation that is required. You can then watch the image get displayed
at the specified angle. Beware, too acute an angle may sprain your neck! The
next function, named TranslateTransform, is optional. It is used to move the
text around in the client area horizontally or vertically. Whenever we transform
something, it stays in the transformed position. But thereafter, if we do not
want the other objects to be in this form, we need to use the function
ResetTranform to undo the transform. However, it is optional.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
Brush b;
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
b = new SolidBrush(Color.FromArgb(180, Color.Black));
RectangleF r = new RectangleF(20, 20, 50, 50);
g.FillRectangle(b, r);
}
}

Screen 4.14

The topic of Brushes is so exhaustive that a thesis can well be written on it.
In this program, we use a special brush to fill up a rectangular area on our
screen.

Here, we specify not only a color, but also a number, which is the alpha value
and has a range from 0 to 255. The larger the value, the darker will be the
color. To put it technically, the larger the value, the lesser will be the
translucence and vice-versa.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
Brush b;
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
b = new SolidBrush(Color.Black);
Font f = new Font("Times New Roman", 30);
g.DrawString("Vijay Mukhi " , f , b ,1,25);
}
}

Screen 4.15

In this program, we will shed light on Fonts. When you read a newspaper or
magazine, the style of the letters looks different in each of them. This
difference is due to the Font or the Typeface used. There are numerous fonts in
the world of letters.

While displaying text, we can be very specific about the way in which the
letters look. To enhance their visual appeal, we create an object that looks
like Font. Then, in the constructor, the Name of the font is specified along
with the Size in points. Remember that 72 points make an inch. Thus my name,
Vijay Mukhi, now gets displayed in a size that is bigger than normal.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
Image i;
i = new Bitmap("sample.jpg");
g.DrawImage(i, 29, 20, 283, 212);
}
}

Screen 4.16

The above program merely displays an image. A file with a jpg or a gif extension
contains images or pictures. To display images, we use a class called Image that
can recognize pictures. Even though i is an image object, we initialize it to an
object that looks like Bitmap. An Image class is an abstract class and the class
Bitmap derives from it.

An Image class could represent a picture, which is not just an image, but could
also be a cursor, icon etc. The DrawImage function accepts an image object as
the first parameter, followed by the screen co-ordinates at which the image has
to be positioned. The above .jpg file is part of the samples offered while
installing the .NET SDK. So, search for the file and copy it to the current
working directory. Like the text sample, this picture can also be rotated,
transformed etc.

a.cs
using System.Windows.Forms;
using System.Drawing;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
Image i = new Bitmap("colorbars.jpg");
Brush b = new TextureBrush(i);
g.DrawString("Vijay Mukhi is very smart" , Font, b ,1,25);
}
}

Screen 4.17

By combining a Brush and an image, we can create a multicolor brush. In one of
the earlier programs, we had used a Solid brush. Here, we are using a Texture
brush. This brush fills the interiors of a shape with a picture.

Thus, the text gets reflected in a brush, which reminds us of a rainbow. You can
enhance the aesthetic appeal of your applications by using this facility.

a.cs
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
public class zzz: Form {
public static void Main()
{
Application.Run(new zzz());
}
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
Pen p = new Pen(Color.FromArgb(150, Color.Purple), 20);
p.DashStyle = DashStyle.Dash;
p.StartCap = LineCap.Round;
Point [] pp = new Point[] {new Point(200, 140),new Point(700, 240),new
Point(500, 340)};
g.DrawCurve(p,pp);
}
}

Screen 4.18

The above program introduces freehand drawing. A pen is like an artist’s brush,
which is used to draw any shape that permeates the mind. In our program, we
commence by creating a Pen object p. It is initialized to a particular alpha
color using FromArgb function from the Color class, and to a specified width.

The constructor can also be provided with other parameters, such as a brush. A
pen is used to draw lines and curves.

A Pen can also draw a line of a specified width and style. The default DashStyle
is Continuous. If we change the DashStyle to Dash, the starting point becomes a
rounded edge. The default is a Straight Edge. The line drawn by a pen is very
versatile, and can employ a variety of fill styles, colors and textures. The
DrawCurve function paints a pen object that specifies how to draw a curve. It
has an array of points with the individual three point objects specifying where
the curved line should be drawn.

a.cs
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
public class zzz: Form {
public static void Main() {
Application.Run(new zzz());
}
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
Image i= new Bitmap("BoilingPoint.jpg");
Brush pb = new TextureBrush(i);
Pen p= new Pen(pb, 75);
g.DrawLine(p,1,5,150,200);
}
}

Screen 4.19

We can use a brush that looks like an image and create a pen that will draw
lines in the garb of a picture. The DrawLine function accepts two sets of
numbers, the x-y co-ordinates of the starting point and the x-y co-ordinates of
the ending point. It draws a thick line joining these two points. Thus, we can
use this function to draw any possible shape.

a.cs
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
HatchBrush b = new HatchBrush(HatchStyle.ForwardDiagonal, Color.Green,
Color.FromArgb(100, Color.Yellow));
g.FillEllipse(b, 250, 10, 100, 100);
Rectangle r = new Rectangle(300, 250, 100, 100);
LinearGradientBrush lb = new LinearGradientBrush(r, Color.Red,
Color.Yellow,LinearGradientMode.BackwardDiagonal);
g.FillRectangle(lb, r);
}
}

Screen 4.20

On maximizing the screen, we see two figures; one is a filled circle, while the
other is a rectangular block. We are equipped with a large number of brushes
akin to those in the artistic world. One of them is a HatchBrush. The
constructor of HatchBrush accepts a hatch style and two colors, viz. a
background color and a foreground color.

The first parameter is the hatch style, which can be one of six possible hatch
styles. The foreground color, in this case, green, defines the color of the
lines to be drawn and the background color defines the color for the gaps
between the lines.

The FillEllipse function in Graphics fills up the shape to display the effect of
the brush. We could have used the Rectangle function also, but as we are trying
to be as akin as possible to the samples provided by Microsoft, we have used the
Ellipse function.

A LinearGradientBrush can represent color gradients and multi-color gradients. A
gradient represents a transformation from one color to another. A linear
gradient is defined alongside a line that is specified by the width of a
rectangle or by any two points. Thus, a two-color gradient will commence with a
starting color and conclude with the ending color. The blend from one color to
the next can be customized. First, we specify the object that is to be colored,
which is a rectangle in this case. The gradient starts with the left corner and
ends at the lower right corner. Thereafter, we follow with the starting color
followed by the ending color. Finally, the angle measured in degrees in the
clockwise direction is mentioned, starting from the x-axis. This defines the
orientation of the gradient. You can change the angle and witness the
spectacular effects.

Menus

Screen 4.21

Let us now build a menu. We have created an object m, which symbolizes the
MainMenu. MainMenu is called a control and represents the menu structure for a
Form. It is the root of the menu.

A menu consists of various menu items, which are displayed horizontally across
the menu. We want to create a menu item that displays the word ‘File For this,
we need another class called MenuItem. A MenuItem can represent either an
individual menu item depicting a command, or it can cascade to another popup of
menu items.

MenuItems is a read-only property in MainMenu that gives a reference to all the
MenuItems currently available in the menu. We have none so far. This
CollectionObject also has a function called Add, which is used to add menu
items. To do so, the text of the item that is to be displayed must be stated as
the parameter to the Add function. We can also remove any menu item that has
been previously added.

The variable mi stores the MenuItem object returned by the Add function.
Thereafter, Menu, which is an object of type MainMenu, available in Form, is
initialized to the menu that we desire. The appearance of the menu depends upon
the menu object stored in Menu.

When we run the program, we see the word File displayed in the top left corner.
At this stage, nothing happens when we click on it. On pressing the Alt key, F
is displayed as underlined since the symbol & underlines the character it is
preceded with.

Screen 4.22

Now things look more visually attractive. When we click on File or use the
accelerator Alt-F, a menu pops up with the word ‘Hi’, followed by a separator
and then finally by the word ‘Bye’.

A separator is used to logically group menus together. However, when we click on
‘hi’ or ‘bye’, nothing happens. This situation needs to be redressed, since a
menu should activate some code.

a.cs
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
MainMenu m;
public zzz()
{
m = new MainMenu();
MenuItem mi= m.MenuItems.Add("&File");
MenuItem m1;
m1 = new MenuItem("Hi", new System.EventHandler(abc), Shortcut.CtrlF11);
mi.MenuItems.Add(m1);
mi.MenuItems.Add("Bye");
Menu = m;
}
void abc(object sender, System.EventArgs e)
{
MessageBox.Show("hell");
}
}

Screen 4.24
Screen 4.23

Now, whether you either click on File and then on the word ‘Hi’, or you press
Control+F11, you will see a message box with the word "hell" displayed in it.

The MenuItem constructor is overloaded. The first parameter is the text to be
displayed. The second parameter is a delegate that encompasses the function to
be called whenever this menu item is activated. Just as the pen is mightier than
the sword, under some circumstances, the keyboard is certainly mightier than the
mouse. At times, it is faster to use a keyboard shortcut, instead of using the
mouse. Thus, the last parameter is the keyboard shortcut key, which is part of
an enumerator. This MenuItem object is passed to the Add function, that either
accepts a string or a MenuItem object.

a.cs
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
MainMenu m;
public zzz()
{
m = new MainMenu();
MenuItem mi= m.MenuItems.Add("&File");
MenuItem a = new MenuItem("One",new System.EventHandler(abc));
MenuItem b = new MenuItem("two",new System.EventHandler(abc));
mi.MenuItems.Add("hell",(new MenuItem[]{ a, b })
);
Menu = m;
}
void abc(object sender, System.EventArgs e)
{
MessageBox.Show("hell");
}
}

Screen 4.26
Screen 4.25

Here, we have a popup within a popup. When you click on File, you will see the
word ‘hell’ displayed. You will also see an arrow pointing to the right, along
with the menu item. If you move the mouse over the arrow, a popup is displayed,
containing the two menu items ‘one’ and ‘two’. If we click on them, a message
box with the word ‘hell’ gets displayed.

In the program, with a single statement, we have created two menu items, a and
b, followed by an array of menu items. This array is then passed as the last
parameter to the Add function. Thus, all the menus become sub-menus. In this
case, the event handler is associated with the submenu options, since clicking
on the menu item displays the sub-menu.

a.cs
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
MainMenu m;
public zzz()
{
m = new MainMenu();
MenuItem mi= m.MenuItems.Add("&File");
mi.MenuItems.Add( "hell",new System.EventHandler(abc));
mi.MenuItems.Add( "Bye",new System.EventHandler(abc));
Menu = m;
}
void abc(object s, System.EventArgs e)
{
MenuItem m = (MenuItem) s;
if ( m.Checked)
m.Checked = false;
else
m.Checked = true;
}
}

Screen 4.27 Screen 4.28

We add two menu items, ‘hell’ and ‘Bye’ to our File menu and assign the same
function abc to handle their events. Clicking on any one of the menu options
results in a call to the function abc. This function takes two parameters. The
first parameter s, represents the menu item that was clicked on. If the first
menu option ‘hell’ is clicked, then the parameter s is not an object, but a menu
item representing ‘hell’ and vice versa.

Every MenuItem has an option called Checked, which if True, will display a tick
mark on the menu item. Thus, you can Check or Uncheck a menu option by clicking
on it. You may click on each menu option to observe this effect.

a.cs
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
public class zzz: Form
{
public static void Main()
{
Application.Run(new zzz());
}
MainMenu m;
public zzz()
{
m = new MainMenu();
MenuItem mi= m.MenuItems.Add("&File");
mi.MenuItems.Add( "hell",new System.EventHandler(abc));
mi.MenuItems.Add( "Bye",new System.EventHandler(abc));
Label l = new Label();
ContextMenu lm;
lm = new ContextMenu();
l.ContextMenu = lm;
l.Text = "Vijay Mukhi";
lm.MenuItems.Add(mi.CloneMenu());
Controls.Add(l );
Menu = m;
}
void abc(object s, System.EventArgs e)
{
MenuItem m = (MenuItem) s ;
if ( m.Checked)
m.Checked = false;
else
m.Checked = true;
}
}

The program output will display the same menu – File, as seen in the earlier
program. The text Vijay Mukhi will also be visible. If you place the mouse on
this text and right click the mouse, you will see the same menu as seen with the
File option.

Screen 4.29 Screen 4.30

This is called a Context Sensitive Menu. These two menus, however, are
different. If you Check a menu option in this menu by clicking on it, it does
not carry the tick mark to the other menu.

We first create two objects:
• The first is lm, which looks like a ContextMenu.
• The second is l, which looks like a label.

Screen 4.31

Every label has a member called ContextMenu, wherein we can specify a Context
Sensitive menu. This member is initialized to lm. As we have already created a
menu item mi, we can reuse this menu item.

However, a menu item cannot be used twice. Hence, calling the function CloneMenu
off MenuItem creates a clone. This clone menu is then passed to the Add function
of MenuItems in the ContextMenu.

Writing Controls

Let us start by creating the simplest control that money can buy. We create the
following files:

c.cs
using System.Windows.Forms;
using System.Drawing;
public class yyy : Control
{
}

h.cs
using System.Windows.Forms;
public class zzz : System.Windows.Forms.Form
{
yyy a;
public zzz()
{
a = new yyy();
Controls.Add(a);
}
public static void Main() {
Application.Run(new zzz());
}
}

a.bat
del *.exe
del *.dll
csc.exe /t:library c.cs
csc.exe /r:c.dll h.cs
h

The file c.cs contains our very first custom control. In order to create our own
user-defined control, we create a class yyy and derive it from the Control
class. The Control class implements the basic code required by classes to
implement the behavior of a control or a widget. This code can handle user input
with a keyboard or a pointing device, such as a mouse. Message handling and
security features are also supported.
At the end of the day, all controls are merely child windows. The Control class
defines the area or bounds of a control along with the fonts, colors and images.
This class allows painting, context menus and anchoring with docking behavior.

Earlier, we had displayed scores of controls in our containers, written by the
Microsoft developers. All these controls were derived from the Control class.

Screen 4.32

Thus, a user control like yyy is an instance of a Control class, which is added
to the Form using the Add function off the Controls collection. It can’t get any
simpler. On running the executable, we see no output. Yet, since no error was
generated, we presume that all went well.

The major difference between the Microsoft controls and our controls is, the
file in which the code for the control is finally placed. We have placed our
control code in assembly c.dll, whereas, Microsoft controls are placed in
System.Windows.Forms.dll.

c.cs
using System.Windows.Forms;
using System.Drawing;
public class yyy : Control
{
protected override void OnPaint(PaintEventArgs e)
{
e.Graphics.DrawString(Text,Font, new SolidBrush(ForeColor), ClientRectangle);
}
}

h.cs
using System.Windows.Forms;
public class zzz : System.Windows.Forms.Form{
yyy a;
public zzz() {
a = new yyy();
a.Size = new System.Drawing.Size(600, 450);
a.Text = "Vijay Mukhi";
Controls.Add(a);
}
public static void Main() {
Application.Run(new zzz());
}
}

Screen 4.33

In the above example, we have overridden a function called OnPaint in the
Control class. This function gets called whenever a control is to be redrawn on
the screen. It is passed a PaintEventArgs object as a parameter, from where we
summon the DrawString function to paint a string in a specified font and color,
at a particular location. The first parameter, Text, is a property, which refers
to the string to be displayed. The string ‘Vijay Mukhi’ is presently displayed
in the window.

In the container h.cs, we have initialized the property Text contained in the
Control class to ‘Vijay Mukhi’. The Size property is also initialized, so that
our control has a specific size in the container.

h.cs
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form {
Button b;
ccc c;
public zzz() {
b = new Button();
c = new ccc();
b.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
b.DialogResult = System.Windows.Forms.DialogResult.OK;
b.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
b.Size = new System.Drawing.Size(96, 24);
b.Text = "&Save";
b.Location = new System.Drawing.Point(8, 328);
b.Click += new System.EventHandler(abc);
Text = "Sonal Mukhi";
AcceptButton = b;
ClientSize = new System.Drawing.Size(400, 373);
c.Anchor=AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left |
AnchorStyles.Right;
c.AutoScrollMinSize = new System.Drawing.Size(0, 0);
c.Size = new System.Drawing.Size(400, 310);
c.Text = "Vijay Mukhi";
Controls.Add(b);
Controls.Add(c);
c.cust = ddd.rrr();
Size = new Size(400, (373 + SystemInformation.CaptionHeight));
}
void abc(object sender, System.EventArgs e)
{
c.aaa();
MessageBox.Show("vijay "+ c.cust);
}
public static void Main(string[] args)
{
Application.Run(new zzz());
}
}

c.cs
using System;
using System.Windows.Forms;
using System.Drawing;
public class ccc : UserControl
{
TextBox t;
TextBox ID;
Label l;
ddd c;
public ccc()
{
t = new TextBox();
l = new Label();
ID = new TextBox();
Text = "Vijay Mukhi";
Size = new System.Drawing.Size(384, 304);
t.Size = new System.Drawing.Size(88, 20);
t.Location = new System.Drawing.Point(88, 70);
l.Size = new System.Drawing.Size(64, 16);
l.Location = new System.Drawing.Point(8, 32);
l.Text = "ID:";
ID.ReadOnly = true;
ID.Size = new System.Drawing.Size(200, 20);
ID.Location = new System.Drawing.Point(88, 30);
ID.Enabled = false;
Controls.Add(t);
Controls.Add(ID);
Controls.Add(l);
}
public ddd cust
{
get
{
return c;
}
set
{
c=value;
ID.Text = c.ID;
t.Text = c.ti;
}
}
public void aaa()
{
c.ti = t.Text;
}
}

cc.cs
using System;
using System.ComponentModel;
using System.IO;
public class ddd : Component
{
string i ;
string t ;
public static ddd rrr()
{
ddd c = new ddd("111");
c.ti = "Vijay";
return c;
}
internal ddd(string s): base()
{
i = s ;
}
public string ID
{
get
{
return i ;
}
}
public string ti
{
get
{
return t ;
}
set
{
t = value ;
}
}
public override string ToString()
{
StringWriter sb = new StringWriter() ;
sb.WriteLine("Sonal \n");
sb.WriteLine(i);
sb.Write(t);
return sb.ToString();
}
}

a.bat
del *.exe
del *.dll
csc.exe /t:library /out:c.dll c.cs cc.cs
csc.exe /R:c.dll h.cs
h

This program is a rather protracted one. As usual, we start with the container
in h.cs. In the zzz constructor, we first create a button b and an object c that
is an instance of our user control ccc. The control is present in the assembly
c.dll. What this class presently does is not significant. We begin by
initializing a large number of properties in the button.

The Anchor property decides as to which edges of the control are to be anchored
with the edges of the container. Here, we have chosen the Bottom edge.

The DialogResult property is the value that is returned to the parent form when
we click on the button. The value returned is OK.

The FlatStyle property belongs to the ButtonBase class and is one of the
numerous properties that influence the flat style appearance of the button.
Knowledge of GUI programming implies cognizance and comprehension about all the
facets of making your application more comely and pleasing to the eye. The Size,
Text and Location properties were explained earlier.

Each time we click on the button, the function abc gets called. The Text
property decides on the title of the windows. The AcceptButton property requires
an object that represents a button. Every form has a feature, which associates
the Enter key with a button. The resultant effect is that pressing the Enter key
on the keyboard simulates a click on the associated button. Thus, in the above
form, pressing Enter or clicking on the button would result in a call to the
function abc. The ClientSize property decides the size of the windows.

Our User Control too can initialize properties since they belong to the Control
class. In the program, we have set the Anchor, AutoScrollMinSize, Size and Text
properties of our user-defined control class ccc, even though our control may
not have implemented these properties directly.

Using the Add function, we have then added the button and the control ccc to the
form. Finally, we have called a static function rrr from the class ddd that
initializes a property cust from our user-defined control.

When we run this program, we see two text boxes, a label and a button. It is
obvious that other than the button, the other widgets were created by the class
ccc. This provides ample credence to our belief that our user-defined control
can do its biding.

Screen 4.35
Screen 4.34

We shall now endeavor to comprehend what the constructor of class ccc in file
c.cs is attempting to do. The constructor contains two text boxes, one called ID
to store the id of the user, and the other called t to store the user’s name.
The label l is used to display a simple descriptive message. Since we do not
want the user to change the value contained in ID, we assign the value true to
its ReadOnly property and assign the value false to its Enabled property.
Thereafter, we add these three widgets to the form. Hence, we can now see four
widgets on the screen.

In the container h.cs, we call a static function, rrr off class ddd. The ddd
class is created in cc.cs and is derived from Component. In the rrr function, we
create an object c, which looks like ddd and pass a value of 111 to the
constructor. The constructor of class ddd initializes an instance variable i to
the value contained in s. The variable i stands for the user id.

Class ddd has a property called ti, which is initialized to my name, Vijay. This
property ti sets another instance variable t to the value ‘Vijay’. Thus, we have
initialized two instance members of class ddd to specific values.

The value returned on calling the rrr function is stored in the cust property of
the control c. The class ccc contains the property having type ddd.

The property Cust stores the ddd object in the variable c for later use. It also
initializes the Text property of the text boxes to the ID and Name of the user
that the two properties in the class ddd were initialized to. Thus, we see ‘111’
and ‘Vijay’ displayed in the text boxes.

When we click on the button labeled ‘Save’, the function abc gets called. This
function first calls the function aaa from class ccc using the object c. In aaa,
we initialize the ti property of the control to the value present in the
textbox. The ID property is dimmed out, and hence its value can never be
changed. The object c represents the ddd object in class ccc.

To display a string, an object, whose data type is not a string, has to call the
ToString function in the datatype. The cust property in class ccc has the type
of ddd, which contains the ToString function. This function uses the
StringWriter class to concatenate the word ‘Sonal’ with the value of the
instance variables i and t, which eventually get displayed in the MessageBox.

The above program demonstrates two crucial points:
(a) All the code that refers to the user has been encapsulated in class ddd.
(b) The user interface code is entered in class ccc.

The container is oblivious to these classes and does not bother to verify
whether there are two classes or one. While the class ccc contains code
pertaining to User Interface interaction only, the class ddd contains code
relating to the actual object.

h.cs
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form {
RadioButton r1,r2;
GroupBox g1;
sss s;
public zzz()
{
r1 = new System.Windows.Forms.RadioButton();
r2 = new System.Windows.Forms.RadioButton();
r1.Location = new System.Drawing.Point(24, 24);
r1.Size = new System.Drawing.Size(128, 24);
r1.Text = "Vijay";
r1.Checked = true;
r1.CheckedChanged += new System.EventHandler(r1f);
r2.Location = new System.Drawing.Point(24, 64);
r2.Size = new System.Drawing.Size(128, 24);
r2.Text = "Mukhi";
r2.CheckedChanged += new System.EventHandler(r2f);
g1 = new System.Windows.Forms.GroupBox();
g1.Size = new System.Drawing.Size(192, 152);
g1.Text = "Sonal";
g1.Location = new System.Drawing.Point(320, 16);
s = new sss();
Text = "Control Example";
ClientSize = new System.Drawing.Size(528, 325);
s.Size = new System.Drawing.Size(304, 328);
s.TabIndex = 0;
s.Anchor = AnchorStyles.Left | AnchorStyles.Right;
s.Font = new System.Drawing.Font("TAHOMA", 16f, System.Drawing.FontStyle.Bold,
System.Drawing.GraphicsUnit.World);
s.Text = "Simple Control";
s.dmc += new System.EventHandler(sf);
Controls.Add(g1);
Controls.Add(s);
g1.Controls.Add(r2);
g1.Controls.Add(r1);
}
void r2f(object sender, System.EventArgs e)
{
if (r2.Checked)
{
s.dm = ddd.a2;
}
}
void r1f(object sender, System.EventArgs e)
{
if (r1.Checked)
{
s.dm = ddd.a1;
}
}
void sf(object sender, System.EventArgs e)
{
if (s.dm == ddd.a1)
MessageBox.Show("hi");
if (s.dm == ddd.a2)
MessageBox.Show("bye");
}
public static void Main()
{
Application.Run(new zzz());
}
}

c.cs
using System;
using System.ComponentModel;
using System.Windows.Forms;
using System.Drawing;
[DefaultProperty("dm"),DefaultEvent("dmc"),]
public class sss : Control
{
ddd d;
EventHandler eee;
public sss() :base()
{
d = ddd.a1;
ccc();
SetStyle(ControlStyles.ResizeRedraw, true);
}
[Category("Appearance"),Description("Controls how the control
paints"),DefaultValue(ddd.a1),Bindable(true),]
public ddd dm
{
get
{
return d;
}
set
{
d=value;
ccc();
dmf(EventArgs.Empty);
}
}
protected override void OnPaint(PaintEventArgs e)
{
e.Graphics.FillRectangle(new SolidBrush(BackColor), ClientRectangle);
Size textSize = e.Graphics.MeasureString(Text, Font).ToSize();
float x = (ClientRectangle.Width/2) – (textSize.Width/2);
float y = (ClientRectangle.Height/2) – (textSize.Height/2);
e.Graphics.DrawString(Text,Font,new SolidBrush(ForeColor),x, y);
}
protected override void OnTextChanged(EventArgs e) {
base.OnTextChanged(e);
Invalidate();
}
[Description("Raised when the DrawingMode changes")]
public event EventHandler dmc
{
add {
eee += value;
}
remove {
eee -= value;
}
}
protected virtual void dmf(EventArgs e)
{
Invalidate();
if (eee != null)
eee.Invoke(this, e);
}
void ccc()
{
if ( d == ddd.a1)
{
base.BackColor = Color.Yellow ;
base.ForeColor = Color.Green ;
}
if ( d == ddd.a2)
{
base.BackColor = Color.LightSlateGray ;
base.ForeColor = Color.White ;
}
}
}
public enum ddd
{
a1 = 0,
a2 = 1,
}

a.bat
del *.exe
del *.dll
csc /t:library c.cs
csc h.cs /r:c.dll
h

Let us now write a control that is considerably intricate. In the container
h.cs, we start with two radio buttons r1 and r2. Each time we select a radio
button, depending upon the option selected, either of the functions r1f or r2f
will get called. Thereafter, we create a group box called g1. The radio buttons
are added to the group box, and the group box is added to the Controls
collections. Apart from these controls, one more user control named s, which is
an instance of class sss, is added to the Controls collection.

Screen 4.36 Screen 4.37

Prior to this, we initialize various properties of this control such as
TabIndex, Font, Size, Anchor, Text etc. to some meaningful values. Besides
these, a property called dmc in the user control is initialized to an
EventHandler that calls function sf. Thus, whenever the event represented by dmc
is triggered, the function sf gets called.

The code implementing our user control s, resides in the file c.cs. The user
control s is an instance of sss and is derived from the Control class. At the
outset, the constructor of class sss calls the constructor of the base class
using the keyword base, even though this is optional, because the base class
constructor invariably gets called.

The class ddd is an enum, with two members a1 and a2, having values 0 and 1
respectively. We could conveniently have used numbers directly instead of an
enum, but since the original example used an enum, we have also done so. We set
the object d to the value 0 and call function ccc from class sss. The main
objective of placing code in a function is to enable the code to be called
several times.

In the function ccc, we start by checking the value of the object d. If it is a1
i.e. 0, we change the value of the two properties BackColor and ForeColor to
Yellow and Green respectively. If the object has a value of a2, then another
pair of colors is assigned to these properties. The properties are changed in
the base class using the keyword base. The function SetStyle ensures that the
form gets redrawn when it is resized.

We have already learnt that the OnPaint function is called whenever the window
needs to be redrawn. In this function, we first use the property BackColor to
fill the form background. Next, we use the width of the currently selected font,
to calculate the midpoint of our screen, and then, we write the value contained
in the text property in the center of the window.

When the second radio button is selected, function r2f gets called. In this
function, the program checks whether the radio button is already checked. If so,
it initializes the property dm, whose data type is ddd, to a2.

Similarly, when the first radio button is selected, function r1f gets called.
This function first ascertains if the radio button is already checked. If so, it
initializes the property dm to a1.

Now, we shall focus our attention on the property dm. In the set accessor of
property dm, the ddd object named d is initialized to either a1 or a2. Following
this action, a call is made to function ccc, which changes the background and
foreground color, depending on the value contained in d. The effect is observed
when the function OnPaint gets called. A call is made to the function dmf with a
parameter of an Empty event.

In function dmf, we first call Invalidate, which in turn, calls the OnPaint
function. Just as life offers no guarantees whatsoever, in much the same way,
the calls made to the OnPaint function are unpredictable. The Invalidate
function instantly calls the OnPaint function.

You may recall that in h.cs, the property dmc was initialized with the name of
the function sf. This property dmc is an event type that stores the EventHandler
or function sf in an instance object eee. So, the value in the object eee is
checked. If the value is not null, the function Invoke is called off the object
eee with two parameters. The first parameter is a reference to itself, i.e.
‘this’, and the second parameter is a null EventArgs object. The function
Invoke, in turn, calls function sf in the container, h.cs. The function sf
displays a message box, depending upon the value of the ddd object.

The main idea behind this exercise is to demonstrate that clicking on a radio
button in the container initializes a property in the user control. This in
turn, raises a property changed event, thus resulting in a call to a function
registered with a property of the control. The function resides in the container
and not in the user control.

This is a circuitous route for accomplishing results. The Invoke function is not
aware of and could not care less about the functions that it is calling.

All the other attributes in the code can be safely ignored, since they are
mainly meant for external tools or programs that display the metadata.

h.cs
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form
{
TextBox t;
Button b;
hhh h;
public zzz()
{
h = new hhh();
b = new Button();
t = new TextBox();
b.Size = new System.Drawing.Size(104, 40);
b.Text = "Vijay";
b.Location = new System.Drawing.Point(336, 56);
ClientSize = new System.Drawing.Size(448, 157);
t.Location = new System.Drawing.Point(80, 16);
t.Text = "Vijay Mukhi";
h.Dock = System.Windows.Forms.DockStyle.Bottom;
h.Size = new System.Drawing.Size(448, 40);
h.Location = new System.Drawing.Point(0, 117);
h.Text = "none";
h.ppp(t, "TextBox selected");
h.ppp(b, "Button Selected");
Controls.Add(t);
Controls.Add(b);
Controls.Add(h);
}
public static void Main(string[] args)
{
Application.Run(new zzz());
}
}

c.cs
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
public class hhh : Control
{
Hashtable h;
Control a;
public hhh()
{
h = new Hashtable();
BackColor = SystemColors.Info;
}
[Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) ]
public override string Text
{
get
{
return base.Text;
}
set
{
base.Text = value;
}
}
private void ce(object s, EventArgs e)
{
a = (Control)s;
Invalidate();
}
private void cl(object s, EventArgs e)
{
if (s == a)
{
a = null;
Invalidate();
}
}
public void ppp(Control c, string v)
{
if (v == null)
{
v = string.Empty;
}
if (v.Length == 0)
{
h.Remove(c);
c.Enter -= new EventHandler(ce);
c.Leave -= new EventHandler(cl);
}
else
{
h[c] = v;
c.Enter += new EventHandler(ce);
c.Leave += new EventHandler(cl);
}
if (c == a)
{
Invalidate();
}
}
protected override void OnPaint(PaintEventArgs pe)
{
base.OnPaint(pe);
Rectangle rect = ClientRectangle;
Pen borderPen = new Pen(ForeColor);
pe.Graphics.DrawRectangle(borderPen, rect);
borderPen.Dispose();
if (a != null)
{
string te = (string)h[a];
if (te != null && te.Length > 0)
{
rect.Inflate(-2, -2);
Brush brush = new SolidBrush(ForeColor);
pe.Graphics.DrawString(te, Font, brush, rect);
brush.Dispose();
}
}
}
}

In this program, we have three controls: a user control h, contained in class
hhh, a TextBox t and a Button b. The basic properties like Size, Text and
Location for the Button and the Text box are set to the specified initial
values. Thereafter, the properties of the user control h are initialized. The
DockStyle for the Dock property is set to the Bottom of the form, and the Size
and the Location are specified. The Text property is also initialized.

The user control h has a property called ppp, which accepts two parameters, a
control and a string. We call it twice. When it is called for the first time,
the first parameter passed is a text box control. The next time it is called,
the first parameter passed is a button control. The button and the text box are
displayed on the screen and a yellow colored label with the word ‘TextBox
selected’ in the bottom pane.

Screen 4.38

When we click on the button, the words in the label change to ‘Button selected’.

Screen 4.39

Thus, depending upon the control selected, our user control displays a help
message which we have registered using the property ppp.

The user control h in file c.cs, has two instance variables, a HashTable h and a
Control a. The HashTable class stores values based on a certain key. This helps
in retrieving the value efficiently on being provided with the key. In the
constructor of class hhh, an instance h of the HashTable is created. The
property BackColor is initialized to a Read Only Color property from the class
SystemColors. This property represents the tool tip background color. On our
machine, it happens to be Yellow, and thus, we see a yellow color label.

There is a property called Text in the Control class. In order to implement our
property, we must override the existing one. Presently, in our property, we are
merely accessing the original Text in the base class.

The attributes make interesting reading even though they have little use in the
current example. The Browsable attribute with a parameter of False prevents this
property from showing up in the Property Browser. Also, the value assigned to
the property is not saved on disk. We are not doing anything useful in the Text
property at all.

The property ppp is called twice in the control, because the container has two
property initialization statements. Good programming style incorporates
comprehensive error checks.

We first check for a string value in the second parameter v. If it is null, we
initialize the variable v to an empty string. If the string is not empty, we add
the string contained in v to the hash table using the control parameter c as the
key. Thus, in a hash table, any data type can be used as a key to insert or
retrieve values.

The control class has Events called Enter and Leave. We use the += syntax to
register the function ce whenever the Event Enter gets fired. In the same
manner, the function cl gets called whenever the Event Leave gets fired.

If the user calls the property without a string, it signifies that the control
has to be removed from the hash table and the list of functions in the events
has to be called. Thus, we use the Remove function of the HashTable class to
remove the key c from the hash table. The -= syntax of the Events and Delegates
is employed to remove the functions registered with the Enter and Leave events.
In the OnPaint function, we have drawn a label and displayed some text in it.
There is one rule that must never be violated: ‘Call the function in the base
class first.’ This is because we are unaware of what the overridden function
accomplishes.

A Pen is created from the color stored in ForeColor. This color is the default
color stored in the Control class. The Background color is initialized in the
constructor of hhh class. A rectangle that is drawn using this pen displays
yellow as the background color, with the size defaulting to the value stored in
the ClientRectangle property in the control class. The pen is then disposed off,
to enable the system to retrieve the resources consumed by it. A check is
thereafter performed on the value in the Control object. It should be null since
the control has not been initialized in the beginning.

Before the OnPaint function gets called, a lot of activities get executed in the
background, i.e. many functions get called and numerous events get triggered. On
entering a field, the event OnControlEnter gets triggered and the function that
is registered with the Enter event is called. In our case, function ce is
called. The first parameter to this function is a handle to the control that
caused the event. In our case, it is the Text Box. We initialize the object a to
the Text Box control. Thus, in OnPaint, the value of control a is a Text Box.

We then retrieve the string stored in the hash table using the control as the
key. We then ascertain that the value contained in the string te is not null and
its length is greater than zero.

The Rect structure contains the size of the rectangle. We can then inflate or
deflate the rectangle using the Inflate method. As a result, the position and
the size of the Rectangle change. The X and Y properties are changed by the
amount specified and the Width and Height are modified to twice the amount
specified. The final outcome is that the size of the rectangle is inflated
without moving its geometric center. In our case, since the numbers are
negative, the rectangular will be deflated. Following this, a solid brush is
created using the property ForeColor. A string is drawn using the DrawString
function in the Pen class. Thereafter, we dispose of the brush.

When we leave the control, the event handler named Leave is called. The function
associated with this eventhandler is cl, which ascertains whether the control in
‘a’ and the one passed as parameter i.e. ‘s’ is the same. If so, then ‘a’ is
initialized to a Null value and the OnPaint function is called. The value
contained in ‘a’ is the deciding factor on whether we are inside a control or
not.

h.cs
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form
{
fff f;
public zzz()
{
f = new fff();
f.Dock = System.Windows.Forms.DockStyle.Fill;
f.ForeColor = System.Drawing.Color.White;
f.BackColor = System.Drawing.Color.Black;
f.Size = new System.Drawing.Size(600, 450);
f.vvv = 73;
f.Text = "Vijay Mukhi";
ClientSize = new System.Drawing.Size(600, 450);
Controls.Add(f);
}
public static void Main()
{
Application.Run(new zzz());
}
}

c.cs
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
public class fff : Control {
int vvv1 = 0;
public int Min = 0;
public int Max = 100;
public bool ShowValue = false;
int dv = 0;
bool d = false;
public Color cs = Color.Red;
public Color ce = Color.LimeGreen;
Brush bb = null;
Brush bd = null;
public int vvv
{
get
{
if (d)
{
return dv;
}
return vvv1;
}
set
{
vvv1 = value;
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
bb=new LinearGradientBrush(new Point(0, 0),
new Point(ClientSize.Width, 0),cs,ce);
bd = new SolidBrush(Color.FromArgb(200, Color.Black));
e.Graphics.FillRectangle(bb, ClientRectangle);
Rectangle r = ClientRectangle;
float p = ((float)vvv / ((float)Max – (float)Min));
int a = (int)(p * (float)r.Width);
r.X += a;
r.Width -= a;
e.Graphics.FillRectangle(bd, r);
e.Graphics.Flush();
RectangleF r1 = new RectangleF();
SizeF ts = e.Graphics.MeasureString(Text, Font);
r1.Width = ts.Width;
r1.Height = ts.Height;
r1.X = (ClientRectangle.Width – r1.Width) / 2;
r1.Y = (ClientRectangle.Height – r1.Height) / 2;
e.Graphics.DrawString(Text, Font, new SolidBrush(ForeColor), r1);
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
Capture = true;
d = true;
sss(new Point(e.X, e.Y));
}
protected override void OnMouseMove(MouseEventArgs e)
{
base.OnMouseMove(e);
if ( !d)
return;
sss(new Point(e.X, e.Y));
}
protected override void OnMouseUp(MouseEventArgs e)
{
base.OnMouseUp(e);
if ( !d)
return;
Capture = false;
d = false;
vvv = dv;
}
void sss(Point l) {
Rectangle r = ClientRectangle;
float p = (float)l.X / (float)r.Width;
int a = (int)(p * (float)(Max – Min));
int o = dv;
dv = a;
float op = ((float)o / ((float)Max – (float)Min));
int ol = (int)(op * (float)r.Width);
float np = ((float)dv / ((float)Max – (float)Min));
int nl = (int)(np * (float)r.Width);
int mi = Math.Min(ol, nl);
int ma = Math.Max(ol, nl);
Rectangle r1 = new Rectangle(r.X + mi, r.Y, ma – mi, r.Height);
Invalidate(r1);
}
}

When we run the above program, we see a myriad of colors such as red, green and
black. We also see ‘Vijay Mukhi’ displayed in the center. On clicking the mouse,
more of the color black will be introduced upto the point of the mouse click on
the screen, whereas dragging the mouse will extend or diminish the colors
accordingly. This certainly is a sight for sore eyes!

Screen 4.40 Screen 4.41

We have to admit that the folks at Microsoft who worked on this sample did a
truly marvelous job. Our task here is to explain the program that they have
written, in absolute layman terms.

The h.cs file contains code that is already explained in the earlier program. As
always, along with the properties that are present in Control, we have also
initialized one of our own properties, vvv for control fff. The user-defined
property vvv is assigned a value of 73. The value contained in the Text property
is displayed at the center of the screen.

We now focus the spotlight on the actual code of our control fff that resides in
the file c.cs.

The container sets the value of the property vvv to 73. Therefore, in the
control, the property vvv gets called initially. The set accessor initializes
the int variable vvv1 to 73.

The function OnPaint is responsible for drawing the rainbow of colors on the
screen. In this function, we first call the original OnPaint function. Then, we
create two brushes to obtain the desired effect. The first brush is a
LinearGradientBrush, which can be accessed using the Brush object bb. The last
parameter to the constructor of this brush is the starting color cs, which has
been initialized to Red, and an ending color ce that is initialized to a value
of LimeGreen. The second brush is a SolidBrush bd, which is created to fill up
any shape. The function FromArgb of the Color class creates a new color, where
the first parameter is an alpha value 200 and the second parameter is the base
color.

The Graphics property of PaintEventArgs merely returns a Graphics object when we
call function FillRectangle. The two parameters to this function are : a Brush
that represents a gradient and the Size of the window whose value is stored in
the ClientRectangle property. If we stop at this stage, the red and the green
gradients will stand out glaringly.

Now, let us draw the black rectangle separating the red and green colors. We
create a temporary variable r to store the dimensions of the window.
Two instance variables, Max and Min having a value of 100 and 0 respectively,
are used to decide the factor by which the property vvv should be divided. Since
we need to retrieve the value for the property, the get accessor is called. The
value contained in d decides on the value to be assigned to the property.
Initially d is false, so the value 73 contained in vvv1 is returned.

The float variable p now has a value of .73. The Width of the window in our case
is 600 pixels. Thus, the variable ‘a’ is assigned a value of 438. You can use
the WriteLine function to display these values. The Width of the rectangle is
reduced by this amount and the X position is shifted by 438 pixels. Next, we
draw the black rectangle using the function FillRectangle by providing it with a
black brush and the new Rectangle object r. Modifying the value of the property
vvv from 73 to 3 will result in displaying the entire screen in black color.
Thus, the vvv parameter decides the size of the black rectangle; the smaller its
value, the larger will be the size of the rectangle. The Flush function ensures
that all pending graphic operations on the stack are executed immediately. If we
stop here, the gradient and the rectangle will be displayed, but no text will be
displayed in the center of the screen.

The Rectangular structure r1 stores the size and location of the rectangular
region that our string requires. The MeasureString function takes two
parameters:
• The first is a string value that is stored in our property Text.
• The second is a Font object.

The default Font property is supplied for the second parameter. The function
returns a SizeF object, whose Width and Height determine the display region that
the string requires. The width and height of rectangle r1 is initialized to the
Width and Height of the string. As the string is to be displayed in the center
of the form, objects X and Y, which are the members of rectangle r1, are given
the following values:
• The Width of the form = the width of the string divided by 2.
• The Height of the form = the height of the string divided by 2.

We then use the DrawString function to display the text. This function takes the
following parameters in the specified order:
• A string that is stored in the Text property.
• The default font.
• The color of the brush that is stored in the property ForeColor.
• The region, which is stored in object r1.

We have three mouse events that trigger off three functions. They are as
follows:
• OnMouseMove: When we move the mouse.
• OnMouseDown: When we click the left mouse button, with the mouse cursor placed
on the form.
• OnMouseUp: When we release the left mouse button.

If we move the mouse around, nothing happens. This is because the ‘if’ statement
results in a value of true, as the variable d has a value of false. So, the
function practically achieves nothing. Clicking the left mouse button toggles
the value of the variable d to true. Thus, if the variable d is True, we know
that the user has clicked the left mouse button, and when it reverts back to
false, we know that the left mouse button has been released. The OnMouseMove
function does something constructive and gainful only when the left mouse button
is depressed.

The Capture property reveals whether the control has been able to capture the
mouse or not. This property is optional. When we click within the window, the
framework is informed about our victory over the mouse, and the variable d is
set to true. The next most pertinent action is to call function sss with a Point
object. This object stores the position at which the mouse has been clicked. The
MouseEventArgs parameter e, has two members X and Y, which identify the current
position of the mouse.

The function sss is called yet again when the mouse is moved. The OnMouseUp
function changes the value of Capture, and sets the value of the boolean
variable d to false. It also initializes the value of a property vvv to dv.
The net achievement of the function sss is that, it calls the function OnPaint
using the Invalidate function. The OnPaint function does not draw or paint the
entire form or window, but only the specific part that has been invalidated.
This is done to achieve optimum efficiency, since it is preposterous to waste
effort in redrawing areas that have not been invalidated. The Invalidate
function is also passed a Rect object as a parameter, which takes a decision on
the area of the client rectangle that is to be re-drawn.

Function sss is therefore, given a smaller Rect object as a parameter, which
informs the OnPaint function about the specific part of the form that should be
invalidated. The Point parameter is employed to determine the area of the form,
that must be redrawn.
The co-ordinates of the entire screen are stored in ClientRectangle. We also
calculate a percentage p, depending upon our current position, i.e. l.X, divided
by the Width of the screen. Next, we multiply this percentage by 100 (the
difference between Max and Min). The value of dv is stored in variable o, since
we are initializing dv to ‘a’ in the next line.

Two new percentage values, op and np have been calculated. They are merely the
values of o and dv divided by 100. Thereafter, we calculate the minimum and
maximum values of ol and nl. The new rectangle created is the Client Rectangle,
where the minimum value is added to X, and Y is left untouched. The Width is set
to the difference of ma and mi, and the Height is left unaltered.

The difference between variables ma and mi is negligible. Correspondingly, the
width of the invalidated region too is insignificantly small. Further, mi is
used to decide the position at which the X of the black rectangle should
commence. Thus, if we replace r1 with ClientRectangle, everything would be hunky
dory, but the screen will flicker a great deal, while the mouse is in motion.
This is because the same screen has to be displayed when the movement ceases.
Thus, to thwart this flicker, we redraw only the specific part of the screen
that has been invalidated.

ScrollBar Control

a.cs
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form
{
VScrollBar v;
HScrollBar h;
PictureBox p;
Label l2;
Label l1;
bool d = false;
int ox, oy;
float vm;
float vp;
float hm;
float hp;
public zzz()
{
ClientSize = new System.Drawing.Size(520, 277);
l1 = new Label();
l1.Location = new System.Drawing.Point(408, 160);
l2 = new Label();
l2.Location = new Point(408, 184);
v = new VScrollBar();
v.Location = new Point(200, 24);
v.Size = new Size(16, 152);
v.Scroll += new ScrollEventHandler(vScroll);
v.Minimum = -100;
h = new HScrollBar();
h.Location = new Point(16, 176);
h.Size = new Size(184, 16);
h.Scroll += new ScrollEventHandler(hScroll);
h.Minimum = -100;
p = new PictureBox();
Bitmap b = new Bitmap("water.bmp");
p.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
p.Location = new Point(64, 32);
p.Size = new Size(96, 96);
p.Image = (Image)b;
p.MouseDown += new MouseEventHandler(pDown);
p.MouseUp += new MouseEventHandler(pUp);
p.MouseMove += new MouseEventHandler(pMove);
Controls.Add(l2);
Controls.Add(l1);
Controls.Add(h);
Controls.Add(v);
Controls.Add(p);
v.LargeChange = 20;
h.LargeChange = 20;
v.SmallChange = 1;
h.SmallChange = 1;
vmf();
hmf();
l1.Text = h.Value.ToString();
l2.Text = v.Value.ToString();
p.Cursor = Cursors.SizeAll;
}
void vmf()
{
float hsb = (float)(v.Height – p.Height);
float ticks = (float)(v.Maximum – v.Minimum);
vm = hsb / ticks;
}
void hmf()
{
float hsb = (float)(h.Width – p.Width) ;
float ticks = (float)(h.Maximum – h.Minimum) ;
hm = hsb / ticks ;
}
void vScroll(object sender, ScrollEventArgs e)
{
l2.Text = v.Value.ToString() ;
vp = (float)(v.Value- v.Minimum);
p.Top = v.Bottom – (int)(vm * vp) – p.Height;
}
void hScroll(object sender, ScrollEventArgs e)
{
l1.Text = h.Value.ToString() ;
hp = (float)(h.Value – h.Minimum);
p.Left = h.Right – (int)(hm * hp) – p.Width;
}
void pDown(object s, MouseEventArgs e)
{
d = true;
ox = e.X;
oy = e.Y;
}
void pMove(object s, MouseEventArgs e)
{
if (d)
{
int minY = v.Minimum;
int maxY = v.Maximum;
int minX = h.Minimum;
int maxX = h.Maximum;
int value = (int)(v.Value – (e.Y – oy)/vm);
if (value < minY)
{
v.Value = minY;
}
else if (value > maxY – v.LargeChange + 1)
{
v.Value = maxY – v.LargeChange + 1;
}
else
{
v.Value = value;
}
value = (int)(h.Value – (e.X – ox)/hm);
if (value < minX)
{
h.Value = minX;
}
else if (value > maxX – h.LargeChange + 1)
{
h.Value = maxX – h.LargeChange + 1;
}
else
{
h.Value = value;
}
l1.Text = h.Value.ToString() ;
l2.Text = v.Value.ToString() ;
value = p.Top + (e.Y – oy);
if (value < v.Top)
{
value = v.Top;
}
else if (value > v.Bottom – p.Height)
{
value = v.Bottom – p.Height;
}
p.Top = value;
value = p.Left + (e.X – ox);
if (value < h.Left)
{
value = h.Left;
}
else if (value > h.Right – p.Width)
{
value = h.Right – p.Width;
}
p.Left = value;
}
}
void pUp(object s, MouseEventArgs e)
{
d = false;
}
public static void Main()
{
Application.Run(new zzz());
}
}

>csc a.cs

Before running the program, copy the file water.bmp into the current directory.
This file is provided along with the samples in the installation program. The
singular methodology to comprehend large programs is by first examining their
output, because the output will motivate you to grasp the program.

We see two scrollbars, one vertical and the other horizontal, with a picture
within them. Clicking on the scrollbars will move the picture in the direction
of the scrollbar that is clicked. Let us understand how this is achieved.

Screen 4.42

We start by examining the constructor of class zzz. The default client size is
modified to the desired size. Then, there are two labels l1 and l2, which
display the current values of the two scroll bars. A vertical scrollbar v is an
instance of a class VScrollBar, and a horizontal scrollbar h is an instance of a
class HScrollBar. As is customary, we provide a Location and a Size to the
scrollbar. The Minimum and Maximum properties decide the range of values that
the user can select. Most controls such as a Text box or a Combo box already
have a scroll bar built into them. Hence, they do not require this control. The
Scroll event gets triggered whenever the scroll button moves. The button can be
moved either by using a mouse or by the keyboard. Moving the vertical scroll
button will call the vScroll function, whereas moving the horizontal scroll
button will call the hScroll function.

After setting the properties of the Scroll Bar, we create an object p, which is
an instance of a PictureBox class. Next, we create a Bitmap object, and in the
constructor, we pass the file water.bmp to it. The SizeMode decides on the
display of the image in the Picture Box. The enum value of StretchImage
stretches the image to fit it into the PictureBox, whereas, the enum value of
Normal places it in the upper left corner.

The image property is assigned to the picture or the bitmap that is to be
displayed. Three event handlers are attached to the image:
• pDown : This is called each time we click in the picture.
• pUp : This is called when we release the mouse button.
• pMove : This is called when we move the mouse within the picture.

Finally, all the controls i.e. two labels, two scroll bars and one image, are
appended to the Control class.

The property of LargeChange in the scrollbar control decides on the magnitude of
the change in the value of the scroll bar, when the scroll bar is clicked. The
SmallChange property is associated with the arrows on the scroll bar. We have
set the LargeChange property to 20 and the SmallChange to 1.

To dispel the banality of the somber explanation given above, let us digress
slightly to present a small, albeit important, elucidation on how Windows
handles the art of scrolling.

Screen 4.43

The value of the scrollbar ranges between the minimum and the maximum. The
maximum value is LargeChange+1. The rationale behind this is that, the scrollbar
has a property called Value, which represents the position of the top of the
thumb. The size of the scrollbar’s thumb is equal to the page value or
LargeChange. When we reach the last page, or when the thumb reaches the end of
the scroll bar, whereupon, we cannot scroll any further, the value property will
always be shown less than the maximum.

We shall now beguile you with the concepts of the vertical scroll bars. The
explanation for the horizontal scroll bars is much the same.

The function vmf, which is called from the constructor, initializes 3 variables.
The Height of the Vertical scroll bar is 152 pixels because the Size property of
the scrollbar is initialized to this value. The Height of the picture is 96
pixels because the Size property of the picture is initialized to this value.
The difference between these two heights, which is 56 pixels, is stored in the
variable hsb. The variable named ticks stores a value, which is within a range
that the vertical scroll bar can handle.

A Tick happens to be the smallest increment that a scrollbar can make. In our
case, as the Minimum is -100 and the Maximum is 100, the range of value stored
in ticks becomes 200. This variable represents the ticks that the scroll bar
needs in order to move from one end to the other. In the same vein, the variable
hsb denotes the amount of pixels the image needs to be relocated from one end of
the scroll bar to another. This is calculated by subtracting the height of the
image from the height of the scroll bar.

Screen 4.44

Dividing 56 (the number of pixels to be moved) by 200 (the total number of ticks
available), gives us a value of .28. Thus, every tick moved by the scroll bar
moves the image by .28 pixels. This value, known as the ‘pixels per tick’, is
stored in vm. A similar routine is followed for the hmf function while
implementing a horizontal scroll bar.

The labels initially display zero, since this is the default value stored in the
property value. The cursor property of the picture is changed to SizeAll. As a
result of this, whenever the cursor moves into the picture, it’s shape changes
into a four-headed monster.

At the outset, we want to move the picture downwards. So, we click on the
vertical scroll bar. This movement calls the vScroll function. In this function,
we initialize the Text property of the label l2 to the Value property of the
vertical scroll bar v. Then, variable vp is calculated, whose value is the
current value of the scroll bar, i.e. the value of the Minimum property of the
scroll bar.

Every downward movement of the scroll bar increments the Value property by 1.
This is because, the value of property SmallChange has been initialized to 1.
Thus, the value of vp will commence at 100 and will keep escalating thereafter.
The value stored in the Bottom property of the scroll bar is 176 and the Height
of the picture is 96 pixels. Thus, the picture will start at 52 pixels, and
then, the distance between the picture and the bottom property will start
reducing.

The formula for computing the top position where the picture should be placed is
as follows: the Bottom of the scroll bar, minus the pixels per tick, multiplied
by the current value of the property Value, minus the Height of the picture,
plus the value of Minimum.

Now, let us do the reverse i.e. let us move the picture around and see how the
scroll bars behave. Also, let us observe the corresponding transformation in the
values. To move the picture, we first have to click on it with the left mouse
button. This calls function pDown. In this function, the value of variable d,
which is a boolean, is set to true. Simultaneously, in the function pUp, the
value of variable d is set to false.
The parameter e of MouseEventArgs has two members X and Y, which furnish the
co-ordinates of the mouse pointer with regard to the picture, rather than the
window or form. We save these values in the variables ox and oy, which will be
utilized to calculate the distance that the picture has been dragged.

The function pMove is the focus of all attention since, this is where the real
excitement action lies! We place all the code in a large if statement, which
results in true when the variable d is true. This occurs only when the mouse
button is depressed. Each time the function is called, the minimum and maximum
values of the scroll bars are stored in 4 variables. This is futile, since the
values always remain constant.

We calculate a variable called Value as follows:
The initial Y position of the mouse before its dragging commenced, minus the
current Y position of the mouse. The result is then divided by the multiplier to
convert the pixels into scroll bar ticks. This simulates the scroll bar
scrolling in the opposite direction.

If the new value of variable Value is less than the minimum value allowed for
the scroll bar, the property of the scroll bar v is set to the minimum possible.
If the value is larger than the maximum permissible value, then it is
initialized to the largest possible value. This concept has been explained in
the small note we earlier presented on scrolling. If none of the above hold
true, then we merely change the property Value of the scroll bar to the variable
Value. These are simple error checks. The labels l1 and l2 are also updated.
The above explanation is also relevant for the horizontal scroll bar.

The property Top of the picture has to be updated to take into account the new
position. This is also stored in the variable value and computed as follows:
The original Top property value, plus the current position of the mouse, minus
the position of the mouse before the dragging commenced.

Like before, we make sure that we do not exceed the Top and Bottom limits of the
scroll bar. The picture has to be contained within the scroll bars. If it is
smaller than the Top property of the scroll bar, we change the value to that of
the Top property. The same holds true for the Bottom. Finally, we initialize the
Top property of the picture to Value and do the same for the Left property.

Up Down Control

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form {
DomainUpDown u;
NumericUpDown n;
DomainUpDown a;
public zzz() {
ClientSize = new Size(504, 352);
n = new NumericUpDown();
n.Location = new Point(132, 132);
n.Maximum = new System.Decimal(100d);
n.Minimum = new System.Decimal(0d);
n.DecimalPlaces = 2;
n.Text = "0.00";
Controls.Add(n);
a = new DomainUpDown();
a.Location = new Point(152, 32);
a.Size = new Size(120, 23);
a.SelectedItemChanged += new EventHandler(abc);
Controls.Add(a);
u = new DomainUpDown();
u.Location = new Point(152, 64);
u.SelectedItemChanged += new EventHandler(pqr);
Controls.Add(u);
a.Items.Add(new yyy("Center",(int) HorizontalAlignment.Center));
a.Items.Add(new yyy("Left",(int)HorizontalAlignment.Left));
a.Items.Add(new yyy("Right",(int)HorizontalAlignment.Right));
u.Items.Add(new yyy("Left",(int)LeftRightAlignment.Left));
u.Items.Add(new yyy("Right",(int)LeftRightAlignment.Right));
u.SelectedIndex = 1;
}
void pqr(object s, EventArgs e)
{
yyy c = (yyy)(u.Items[u.SelectedIndex]) ;
n.UpDownAlign = (LeftRightAlignment)(c.i);
}
void abc(object s, EventArgs e)
{
yyy c = (yyy)(a.Items[a.SelectedIndex]) ;
n.TextAlign = (HorizontalAlignment)(c.i);
}
public static void Main()
{
Application.Run(new zzz());
}
class yyy
{
public string s;
public int i;
public yyy(string sz, int n)
{
s=sz;
i=n;
}
public override string ToString()
{
return s;
}
}
}

Screen 4.45

In the above program, we have a NumericUpDown control called n. A NumericUpDown
control is used when we have a single numeric value that needs to be incremented
or decremented.

Screen 4.46

This can be done by clicking on the Up and Down buttons of the control
respectively. This control has a property called ReadOnly, which has a value of
False by default.

This allows entry of a value directly in the control if the user finds it too
bothersome to click on the buttons to do so. From this perspective, it operates
akin to a text box. The properties Minimum and Maximum specify the minimum and
maximum values that the control can accept. Under no circumstances will the
control permit us to exceed the range specified by the above two properties.
Thus, error checking has been built into the control.

A NumericUpDown control has a large number of properties such as DecimalPlaces,
Hexadecimal, ThousandsSeparator etc. These properties format the value that is
displayed using the Text property.
Their roles are as follows:
• The DecimalPlaces property controls the number of decimal places.
• The Hexadecimal property displays numbers in hexadecimal format.
• The ThousandsSeparator property decides on the character to be used to
separate the 1000s. This is because the comma is not the universally accepted
separator.

The Increment property of the control which has a default value of 1 decides on
the amount of increase/decrease in the number. each time we click on the up or
down buttons. n.Increment=10; will increase the number by 10. The two functions
ParseEditText and UpdateEditText get called with every change in the number.

Thereafter, two DomainUpDown controls, which behave in a manner similar to a
NumericUpDown control, are created. These controls display a string instead of a
number. Thus, the value passed to this control can be of any class, since all
classes are derived from object. The user can also type in text directly. The
value typed in must obviously match an item in the collection. The ToString
function of the object is called, to display the value in the up-down control.

The DomainUpDown control has a property called Items, that returns a
DomainUpDown.DomainUpDownItems object. This object represents the object
collection. Thus, we can use the Add or Remove methods from the above collection
to add or remove the items individually. The Sort property sorts the collection.
We pass an object like yyy to the Add function, which accepts a string and an
enum called HorizontalAlignment. The enum value is stored in the variable i to
facilitate its retrieval at a later stage.

Each time we click on the control, function abc gets called. This is because the
SelectedItemChanged event has been initialized to this function. In this
function, we use the property SelectedIndex, which returns a number depicting
the item that has been selected. The property is used as an array index. It
returns the yyy object at that index. We store this object in c and then, access
the variable i stored in the object yyy.

Thus, the entire object yyy is stored as part of the collection. The string and
the int can both be accessed together. If the SelectedIndex property is not set,
it will not display any value in the control.

DateTimePicker Control

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form {
DateTimePicker d;
public zzz() {
ClientSize = new Size(504, 293);
d = new DateTimePicker();
d.Location = new Point(24, 24);
d.CalendarFont = new Font("Times New Roman", 8f);
d.Size = new Size(200, 20);
d.CalendarForeColor = System.Drawing.SystemColors.WindowText;
d.ShowCheckBox = true;
d.ForeColor = System.Drawing.SystemColors.WindowText;
d.Format = System.Windows.Forms.DateTimePickerFormat.Custom;
d.BackColor = System.Drawing.SystemColors.Window;
d.CustomFormat = "\’Date : \’yy MM d – HH\’:\’mm\’:\’s ddd";
d.Anchor = AnchorStyles.Top|AnchorStyles.Right | AnchorStyles.Left;
DateTime now = DateTime.Now;
d.Value = now;
Controls.Add(d);
}
public static void Main()
{
Application.Run(new zzz());
}
}

Screen 4.47 Screen 4.48

On running the above program, we see a listbox displaying a date. This date is
the system date. You may wonder as to what is the big deal about displaying a
simple date. But, when you click on the down arrow of the list box, a
fine-looking calendar springs up! The current date is shown highlighted in red.
If you click on any date, it will be instantly displayed in the list box. Once
the date has been chosen, the calendar vanishes. You can change the month by
clicking on the arrows, which are on the left and right of the month.

Now, let us get behind the scenes and unravel the mysteries of this program. We
first create an object d as an instance of class DateTimePicker, thus
encapsulating the standard Windows date time picker control. The control has all
the standard properties like Location, Size, Color etc. The default size, in the
case of the DateTimePicker, is a width of 200 pixels and a height of 23 pixels.
The colors of the control can be changed using CalendarForeColor and ForeColor.
The property CalendarFont decides on the font to be used to display the dates.

Screen 4.49

The ShowCheckBox property , which has the default value of false, is set to
true, in order to display a check box on the extreme left of the date displayed
in the control. The checkbox presently is checked.

If the checkbox is checked, the date is valid. If not, the date is said to be
unset.

The Format property of the control, which is initialized to Custom, decides the
display format of the date and time in the control. This property can be
initialized to any four of the following enums: Custom, Short, Long and Time.
The last three values use the operating system’s format options.

Since the Format property has been given the value of Custom, the property
CustomFormat decides on the display format of the date in the control. This
property is initialized as follows: The word Date:, followed by the year, month
and day separated by a space, followed by a minus sign and finally, the time.
The three ‘ddd’ represent the day of the week in words.

The Now property of the DateTime class, that returns the current day, is finally
assigned to the Value property of the picker class, which then gets displayed in
the control.

LinkLabel Control:

a.cs
using System;
using System.Windows.Forms;
using System.Drawing;
public class zzz : Form {
PropertyGrid pg;
LinkLabel l;
Panel p;
GroupBox g;
public zzz() {
l = new LinkLabel();
l.DisabledLinkColor = (Color)System.Drawing.Color.Blue;
l.ForeColor = (Color)System.Drawing.Color.Gainsboro;
l.Location = new System.Drawing.Point(32, 128);
l.BackColor = (Color)System.Drawing.Color.Transparent;
l.LinkArea = new LinkArea(13, 28);
l.Font = new System.Drawing.Font("Tahoma", 12f, System.Drawing.FontStyle.Bold,
System.Drawing.GraphicsUnit.World);
l.Text = "please click on sonal to see a message box";
l.Size = new System.Drawing.Size(136, 96);
l.LinkClicked += new LinkLabelLinkClickedEventHandler(abc);
ClientSize = new System.Drawing.Size(504, 445);
pg = new PropertyGrid();
pg.Dock = System.Windows.Forms.DockStyle.Fill;
pg.Location = new System.Drawing.Point(3, 16);
pg.CommandsVisibleIfAvailable = true;
pg.Text = "propertyGrid1";
pg.Size = new System.Drawing.Size(242, 405);
pg.SelectedObject = l ;
g = new GroupBox();
g.Location = new System.Drawing.Point(248, 16);
g.Anchor = AnchorStyles.Top|AnchorStyles.Right | AnchorStyles.Left;
g.Text = "LinkLabel Properties";
g.Size = new System.Drawing.Size(248, 424);
g.Controls.Add(pg);
Controls.Add(g);
p = new Panel();
p.Size = new System.Drawing.Size(200, 320);
p.Location = new System.Drawing.Point(24, 40);
p.BackgroundImage = (Bitmap) new Bitmap("hikingboot.bmp");
p.Controls.Add(l);
Controls.Add(p);
}
void abc(object sender, LinkLabelLinkClickedEventArgs e)
{
MessageBox.Show("hi") ;
l.LinkVisited = true ;
}
public static void Main() {
Application.Run(new zzz());
}
}

To avoid any exception from being thrown, you should copy the file
hikingboot.bmp to the current directory. Though the above program is not very
sizeable, its achievements are substantial. The output of this program shows our
screen divided into two parts as follows:

(a) The left pane has a picture in the background with some text that behaves
like a hyperlink. Clicking on the hyperlink displays a message box with the
message ‘hi’ and changes the color of the hyper link.

Screen 4.50

(b) On the right hand side, we come across a large number of properties. When we
click on the plus sign in front of the font property, yet more properties get
displayed. On varying the Font, the font of the text displayed in the window on
the left side changes. You can experiment with the other properties too.

Thus, you can achieve a lot without writing tons of code!

l is an instance of LinkLabel, which relates to text that can be displayed as a
hyper link. The DisabledLinkColor property of LinkLabel decides the color of the
hyperlink when it is disabled. The ForeColor and the BackColor specify the
foreground and the background color of the control respectively.

We may not intend to display the entire string as a hyperlink. So, we use the
LinkArea property to ascertain the text that is to be hyper linked. The default
position begins at 0,0.

The GraphicsUnit enumeration in the Font property specifies a unit of
measurement. The value displayed uses 1/75 of an inch, since the unit of measure
selected is World. We could also use any of the other 6 values in the enum, such
as pixel, millimeter etc.

Screen 4.51

The Text property is the most significant property, as it decides the text to be
displayed. The LinkClicked is the event property that will call function abc
each time we click on the link. In this function, we display a Message Box and
change the LinkVisited property to True, which results in a change in the color
of the hyper link. You may observe that this LinkLabel instance l is not added
to the form. Next, we create an instance of a PropertyGrid class and store it in
pg.

The Dock property decides on the edge of the container that this property will
be docked to. The usage of the Fill style allows docking of the property on all
sides.

The property CommandsVisibleIfAvailable displays the command pane only for those
objects that expose verbs. As always, the Text property is initialized to some
text that does not get displayed. The property of SelectedObject is assigned the
LinkLabel control, thereby linking it into the grid and facilitating browsing of
the LinkLable control properties. This property also allows us to browse
multiple objects. Finally, we add this object to the Form, thereby indirectly
adding the hyperlink also.

A group box is merely an anthology of other controls. The Group box control is
the one that contains the PropertyGrid object. We also create an instance of a
Panel object, which, like a GroupBox class, contains other controls. If the
Enabled property in the panels is set to False, all the controls within it will
be disabled. The panel control, by default, is drawn without any Borders. The
BorderStyle property provides us with two-dimensional or three-dimensional
borders, to distinguish a panel from other areas of the form. The Panel class
can also contain scrollbars.

The Panel class has a property called BackgroundImage that selects the picture
to be displayed in the panel. This Panel class has the LinkLabel added to it, to
which we add the Panel. Thus, we have two controls that have been added directly
to the form, the Panel that has the LinkLabel and the GroupBox that has the
PropertyGrid.

ListBox Control

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form
{
sss p;
ListBox l;
Button b;
ColorDialog c;
ImageList i;
public zzz()
{
b = new Button();
b.Location = new System.Drawing.Point(16, 200);
b.Text = "Color";
b.Size = new System.Drawing.Size(75, 23);
b.Click += new EventHandler(abc);
Controls.Add(b);
c = new ColorDialog();
p = new sss();
p.Location = new System.Drawing.Point(64, 90);
p.Size = new System.Drawing.Size(64, 168);
Controls.Add(p);
i = new ImageList();
i.ImageSize = new Size(24, 22);
i.Images.Add(new Bitmap("club.bmp"));
i.Images.Add(new Bitmap("diamond.bmp"));
i.Images.Add(new Bitmap("heart.bmp"));
i.Images.Add(new Bitmap("spade.bmp"));
Size = new System.Drawing.Size(512, 320);
l = new ListBox();
l.ForeColor = (Color)System.Drawing.SystemColors.WindowText;
l.Location = new System.Drawing.Point(8, 24);
l.IntegralHeight = false;
l.Size = new System.Drawing.Size(232, 60);
l.ColumnWidth = 144;
l.SelectedIndexChanged += new EventHandler(pqr);
l.Items.AddRange (new object[] {"a1", "a2", "a3", "a4"});
l.SelectionMode = SelectionMode.MultiSimple;
Controls.Add(l);
}
void abc(object sender, EventArgs e)
{
if (c.ShowDialog() == DialogResult.OK)
{
l.ForeColor = c.Color;
}
}
void pqr(object sender, EventArgs e)
{
p.ci();
int[] se = new int[l.SelectedIndices.Count];
l.SelectedIndices.CopyTo(se, 0);
for (int i=0; i<se.Length; i++)
{
int ind = se[i];
object it = l.Items[ind];
string s = it.ToString();
Image im = aaa(s);
p.ai(im);
}
p.Invalidate();
}
Image aaa(string b)
{
if (b.Equals("a1"))
{
return i.Images[0];
}
else if (b.Equals("a2"))
{
return i.Images[1];
}
else if (b.Equals("a3"))
{
return i.Images[2];
}
else if (b.Equals("a4"))
{
return i.Images[3];
}
else
{
return null;
}
}
public static void Main()
{
Application.Run(new zzz());
}
}
public class sss : Panel
{
Image[] i = new Image[4];
int Cnt=0;
public virtual void ai(Image img)
{
i[Cnt++] = img;
}
protected override void OnPaint(PaintEventArgs pe)
{
base.OnPaint(pe);
for (int j=0; j< Cnt; j++)
{
pe.Graphics.DrawImage(i[j], new System.Drawing.Point(0, 30 * j + 5));
}
}
public virtual void ci()
{
Cnt = 0;
}
}

Before running the executable file, the 4 files with the ‘bmp’ extension must be
copied from one of the sample directories into the current directory.

Screen 4.52 Screen 4.53

When we run the above program, we see a list box with 4 values and a button
labeled ‘Color’. When we click on the button, it displays a color dialog box,
which permits us to choose from amongst a plethora of colors. We can select a
color and then, click on the OK button. As a result, the color of the list box
items changes to the selected color. We are also allowed to create our own
custom colors in the dialog box.

Screen 4.54 Screen 4.55

Each time we select an item from the list box, an image representing the item is
displayed. If we reselect an item that we had selected earlier, the currently
selected image gets replaced by the latest selected one.

In the program, a Button b is created. It calls function abc whenever it is
clicked. Then, an instance c of class ColorDialog is created. We have created
the class sss. It is derived from the class Panel. It has a member i, which is
an array of 4 images and an int variable named Cnt. The variable Cnt is used as
an index to access the images in the array, and to store the count of the number
of images. When we add the sss object to our Form, nothing gets displayed in the
window. This is because, there are no controls in the panel.

Next, we create an ImageList object called i. This class stores a collection of
images that can be used by other controls such as the Toolbar or ListView.
Bitmaps or Icons are added to this class so that they are available for
exploitation by other controls. Images is a property of type
ImageList.ImageCollection, whose Add method is used to add a bitmap to the
collection. We add a total of 4 bitmaps to our ImageList object.

The ListBox object l has a property ColumnWidth, that decides on the width, in
pixels, of each column in the ListBox. In a multi-column ListBox, the
ColumnWidth property refers to the width of each column. A value of zero is
connotative of the fact that each column has a default width, taking into
account the data displayed in them. The property IntegralHeight decides whether
partial items can be displayed or not. If the value is set to true, then only
complete items are displayed. In this case, the ListBox will be resized to
ensure that partial items are not displayed.

Each time we select an item, the Event SelectedIndexChanged gets kick started.
This event, in turn, calls function pqr. Every list box has a property called
Items, which is a collection of items displayed in the list box. The data type
of Items is ListBox.ObjectCollection. It has a method called AddRange, which
accepts an array of Child Controls present in the list, sorted on the index.
Since we want the list box to display the text a1, a2, a3 and a4, we initialize
the object array to this array of strings.

The property SelectionMode decides on the number of items that can be chosen or
selected concomitantly.

Four options available:
• None : This means that no items can be selected. In effect, it disables the
ListBox.
• One : This allows us to select only one item at a time,
• MultiSimple : This lets us choose multiple items at the same time
• MultiExtended : This enables us to choose multiple items at a time and allows
us to use keys like SHIFT and CONTROL combinations to select the multiple
options.

We finally add the list box to the Form. Clicking on the button labeled Color
calls ShowDialog from the ColorDialog class, which displays a dialog box with a
zillion colors. Until we click on the OK button or the Cancel button, we cannot
leave the dialog box.

The button returns one of two values:
• DialogResult.OK if we click on OK button.
• DialogResult.CANCEL if we click on the Cancel button.

If the user opts to click on the OK button, the color selected is assigned to
the ForeColor property of the ListBox.
The function pqr is the vortex of action. The function is called when any item
is selected or unselected from the list box. We first call function ci from the
class sss, which initializes the variable Cnt to zero.

The SelectedIndices property returns a collection object named
ListBox.SelectedIndicesCollection, which lists all the items that are currently
selected in the list box. This is so because we can select multiple items from
the list box. First, an array called se of type int is created, depending on the
number of items selected. Then, the selected indices are copied to the array.
The variable ind in the for statement refers to each index selected. The Items
array returns an object that stores the value of each index. As we need the
string representation of the selected item, function ToString is used to convert
the object into a string. This facilitates the possibility of having a list box
containing pictures.

We then call the function aaa that accepts a string representing the ListBox
item selected, which can be either a1, a2, a3 or a4. It returns an image
representing the string. It then checks the value of the string passed and
returns an image stored in the ImageList object. The function ai merely uses the
variable Cnt to index the array of images with a new picture. Thus, if we select
three images, the array i will contain three pictures. When the for loop
terminates, we call the function Invalidate.

As we had learnt earlier, function OnPaint displays all the pictures. This is
achieved using the Cnt variable that contains the number of images stored in the
Array. Thus, we use the ImageList class to store the images and the array of
images in the sss class to store the images that need to be displayed each time.

StatusBar control

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form {
System.ComponentModel.Container c;
StatusBar s;
StatusBarPanel s1;
StatusBarPanel s2;
StatusBarPanel s3;
Timer t;
public zzz() {
c = new System.ComponentModel.Container();
s2 = new StatusBarPanel();
t = new Timer(c);
s = new StatusBar();
s3 = new StatusBarPanel();
s1 = new StatusBarPanel();
s2.AutoSize = (StatusBarPanelAutoSize)2;
s2.Alignment = HorizontalAlignment.Right;
s2.Width = 76;
s3.AutoSize = StatusBarPanelAutoSize.Contents;
s3.Width = 20;
s1.BorderStyle = StatusBarPanelBorderStyle.None;
s1.Icon = new Icon("status.ico");
s1.AutoSize = StatusBarPanelAutoSize.Contents;
s1.Width = 62;
s1.Text = "sonal";
Size = new System.Drawing.Size(512, 320);
KeyUp += new KeyEventHandler(abc);
t.Interval = 1000;
t.Enabled = true;
t.Tick += new EventHandler(pqr);
s.Size = new Size(212, 20);
s.Location = new Point(0, 216);
s.BackColor = (Color)SystemColors.Control;
s.Text = "Vijay Mukhi";
s.ShowPanels = true;
s.Panels.AddRange((StatusBarPanel[])new StatusBarPanel[] {s1, s2, s3});
Controls.Add(s);
s3.Text = "OVR";
}
void abc(object se, KeyEventArgs e)
{
if (e.KeyCode == Keys.Insert)
{
string s = this.s3.Text;
if (s.Equals("INS"))
s3.Text = "OVR";
else
s3.Text = "INS";
}
}
void pqr(object se, EventArgs e)
{
DateTime t = DateTime.Now;
string s = t.ToLongTimeString() ;
s2.Text = s ;
}
public static void Main()
{
Application.Run(new zzz());
}
}

Every Windows application displays a StatusBar control. This program is going to
introduce the status bar in our window. In order to accomplish this, the file
status.ico needs to be copied from one of the sample directories into the
current directory.

The above program merely presents a blank window with a status bar at the
bottom. The status bar has the following contents:
• an icon.
• the word ‘sonal’.
• the time ticking away in the middle.
• the status of the Insert key.

Screen 4.56 Screen 4.57

Each time we use the insert key, the text toggles between INS and OVR.

The class Container encapsulates zero to one or more components. We create three
status bar objects s1, s2 and s3, which are instances of class StatusBarPanel.
This class, in turn, is derived from class Component. It stores the StatusBar
control panel information. The object s is an instance of class StatusBar, which
represents a Window status bar control. This control has no panels by default.

The property AutoSize in the StatusBarPanel class regulates the changes
occurring in the panel of a status bar, whenever the status bar is resized. The
values are obtained from the enumeration StatusBarPanelAutoSize that has the
following three values:
• Contents: As is evident from the name, the contents of the status bar decide
how its size will change.
• None: The status bar panel does not change whenever the status bar is resized.
• Spring: The panel shares the available space with all other panels having a
setting of Spring, after yielding space to the panels having either the Contents
or None settings.

Text can be aligned in a status bar panel in 3 ways with reference to the status
bar, i.e. Left, Right and Center. The Alignment property, by default, has a
value of Left. For the status bar panel s2, we have set it to Right. The default
width is 100 pixels for a status bar panel. An Icon can be specified along with
the text that is displayed. To do so, we initialize the Icon property to a .ico
file. An .ico file is a small transparent bitmap image.

The KeyUp Event is fired whenever a key is released in the focused control. In
our case, function pqr is called. The Timer class, that implements a Windows
timer, merely activates an event at a particular time interval. This timer,
which can be used in a window, is designed for a single threaded environment
only, where User Interface threads are being executed. The Interval property
decides the time, in milliseconds, between timer ticks. The Enabled property
sets the timer On. The garbage collector does not interfere with the timer while
it is running. The Event Tick will call the function pqr whenever the time
interval set in the timer elapses. In our case, it is occurs after one second.

The StatusBar is made up of panels. The ShowPanels property displays all the
panels that are added using the AddRange method, i.e. s1, s2 and s3. Finally,
the text of the last panel is set to OVR and the StatusBar object is added to
the form.

The function abc gets called each time we press a key in our form. This function
is called with the parameter e of KeyEventArgs, which has a member KeyCode,
which contains a number corresponding to the key pressed. As it is difficult to
remember the numbers assigned to every key, the enumeration Keys is used to
represent the keys. If the Insert key is pressed, the current Text displayed in
the status bar panel s3 is retrieved and the value gets toggled from OVR to INS.

On completion of the timer interval, we use the Now property of the DateTime
class to provide us with the current time. This is then supplied to s2.Text,
which updates the status bar panel with the current time every second. What you
can display in a status bar is limited by your imagination. It is common to
display the status of keys and the time on the status bar.

Tab Control

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form {
GroupBox g2;
GroupBox g1;
ImageList i;
TabPage t1;
TabPage t2;
TabControl t;
public zzz()
{
ClientSize = new Size(546, 293);
g1 = new GroupBox();
g1.Location = new Point(12, 16);
g1.Text = "Sonal";
g1.Size = new Size(202, 144);
g2 = new GroupBox();
g2.Location = new Point(12, 16);
g2.Text = "Vijay mukhi";
g2.Size = new Size(202, 128);
i = new ImageList();
t1 = new TabPage();
t2 = new TabPage();
t = new TabControl();
t1.Text = "Mukhi";
t1.Size = new Size(224, 193);
t1.ImageIndex = 0;
t1.TabIndex = 0;
t2.Text = "Vijay";
t2.ImageIndex = 1;
t2.TabIndex = 1;
t.Location = new Point(24, 32);
t.Size = new Size(232, 220);
t.SelectedIndex = 0;
t.ImageList = i;
i.Images.Add((Bitmap)new Bitmap("calendar.bmp"));
i.Images.Add((Bitmap)new Bitmap("note.bmp"));
t.ImageList = i;
Controls.Add(t);
t1.Controls.Add(g1);
t2.Controls.Add(g2);
t.Controls.Add(t1);
t.Controls.Add(t2);
}
public static void Main()
{
Application.Run(new zzz());
}
}

This program requires two bitmaps called note.bmp and calendar.bmp.

We start by creating two GroupBox controls named g1 and g2, and change the
properties of Locations, Size and Text. The ImageList i stores a list of images.
We next create two TabPage objects t1 and t2. A TabPage class implements a
single page of the TabControl class. It is a panel class having the properties
of a TabItem.

Screen 4.58 Screen 4.59

The string assigned to the Text property is displayed as the tab page text. We
can set it to a certain size. The ImageIndex property is an index into the
ImageList list object, which is associated with the TabControl. The TabPage
objects are added to the TabControl using the Controls collection. The ImageList
property is initialized to the list of images denoted by the ImageList class.
Thus, the ImageIndex member decides on the image that will be displayed along
with the Text in the TabControl.

A TabControl shows a list of TabPages. Clicking on the tab activates them. A
TabControl, in other words, is like a series of Dialog boxes containing
controls, organized in a logical fashion. The controls that would earlier have
appeared in one large dialog box, are now placed in separate dialog boxes.

As mentioned earlier, we add the GroupBox to the Control collection of the
individual TabPage objects t1 and t2. The controls that we require are added to
the GroupBox. The GroupBox, in turn, gets added to the TabPage. From then on,
the TabControl takes over and we can flick between TabPages with ease.

ToolTip Control

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form {
System.ComponentModel.Container c;
ToolTip t;
PictureBox p1;
PictureBox p2;
public zzz()
{
c = new System.ComponentModel.Container();
t = new ToolTip(c);
t.Active = true;
t.ShowAlways = true;
t.AutomaticDelay = 100;
t.AutoPopDelay = 100;
t.InitialDelay = 100;
t.ReshowDelay = 100;
p1 = new PictureBox();
p2 = new PictureBox();
Size = new Size(512, 300);
p1.Location = new Point(8, 7);
p1.Size = new Size(20, 20);
p1.Image = new Bitmap("open.bmp");
t.SetToolTip(p1, "vijay");
Controls.Add(p1);
p2.Location = new Point(28, 7);
p2.Size = new Size(20, 20);
p2.Image = new Bitmap("new.bmp");
t.SetToolTip(p2, "mukhi");
Controls.Add(p2);
}
public static void Main()
{
Application.Run(new zzz());
}
}

All of us need help at some point in time. The ToolTip control is just the
antidote for all maladies. Before running the executable, copy the two bitmaps
open.bmp and new.bmp to the current directory.These two bitmaps will be
displayed as two separate images on our form. Whenever we move our cursor close
to them, a yellow colored help text comes into sight.

A ToolTip class gives us a small window that contains a single line of text that
describes what a control stands for. The real productivity of Bitmaps and Icons
can be fully harnessed only if we are able to discern their functionality. The
Active property, if set to false, disables the ToolTip control. The ShowAlways
property will show a ToolTip despite the fact that the control it is assigned
to, is currently disabled.

Screen 4.60 Screen 4.61

The following four properties have been set for the Tooltip control:
• AutomaticDelay: It denotes the time in milliseconds that elapses before the
tool tip appears. The default is 500 milliseconds.
• AutoPopDelay: It is the time in milliseconds for which the ToolTip remains
visible to the user while the mouse is stationary on the control. Its default
value is 10 times the value of the property AutomaticDelay.
• InitialDelay: It is the time in milliseconds for which the mouse must remain
fixed within the control, before the tool tip becomes visible again. The default
value is equal to that of property AutomaticDelay.
• ReshowDelay: It is the time in milliseconds that elapses, as the mouse moves
from one control to another. The default is 1/5 of the property AutomaticDelay.

Any amendment made to the property AutomaticDelay has an impact on the above
properties. Thus, it is advisable to first change the AutomaticDelay property,
followed by the other properties.

Two PictureBox controls have been added in our window. We add these two pictures
to the form. This class can display all types of images, including bitmaps,
icons, JPEG, GIF and many more. The Image property decides on the image that
gets displayed. By default, the image has no borders and can be clipped too.
The ToolTip class has a method called SetToolTip, which accepts a control as the
first parameter and the text of the tool tip as the second. Henceforth, whenever
the mouse is positioned on that control, the tool tip will be displayed.

TrackBar Control

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz : Form
{
TrackBar t;
Label l;
public zzz() {
Size = new Size(512, 320);
t = new TrackBar();
t.Location = new Point(8, 24);
t.Size = new Size(200, 42);
t.ValueChanged += new EventHandler(abc);
t.TickFrequency = 5;
t.Minimum = 0;
t.Maximum = 100;
t.SmallChange = 5;
t.LargeChange = 25;
t.Orientation = Orientation.Horizontal;
t.TickStyle = TickStyle.Both;
l = new Label();
l.Location = new Point(112, 192);
l.Text = t.Value.ToString();
Controls.Add(t);
Controls.Add(l);
}
void abc(object source, EventArgs e)
{
l.Text = t.Value.ToString();
}
public static void Main() {
Application.Run(new zzz());
}
}

The TrackBar class resembles a scroll bar in many respects, but its interaction
with the user is distinct. We can configure values that the TrackBar represents
and also define increments for off-button clicks. The TrackBar can be positioned
horizontally or vertically. The number of ticks that are displayed can also be
configured.

Each time that the value of the TrackBar changes, the Event property
ValueChanged calls the function abc. The property TickFrequency specifies the
number of ticks that will be drawn. The lower limit of the range of the TrackBar
is confined to a value decided by the Minimum property, which in our case is 0.
The upper limit of the range of the TrackBar is confined to a value determined
by the Maximum property, which in our case is 100.

Screen 4.62 Screen 4.63

We may not want to draw 100 ticks to represent all the values. So, we specify a
value such as 5 as the TickFrequency. This will draw a tick mark at a spacing of
5, resulting in a total of 20 ticks. Thus, each tick will represent 5 units of
the TrackBar’s range of values.

The property SmallChange decides on the magnitude of change that occurs in the
TrackBar, whenever the user presses the Up arrow key or the Down arrow key to
move the TrackBar thumb. The value assigned to the LargeChange property is used
whenever we click on the side, or use the Page Up and Page Down keys.

The Orientation property can take only two values i.e. horizontal or vertical.
The TickStyle property uses an enumeration that can have four values:
• None: for no tick marks.
• Both: for tick marks on both sides of the control.
• BottomRight: for tick marks at the bottom for a horizontal control, and on the
right for a vertical control .
• TopLeft: this is the reverse of BottomRight.

We then use a label to display the value of the track bar on the form. This
value is stored in the property Value of the label class. Finally, we add the
label and TrackBar. Function abc merely updates the label to depict the current
position of the TrackBar.

Tree-Node Control

a.cs
using System;
using System.IO;
using System.Resources;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
public class zzz : Form
{
TreeView d;
ImageList i;
public zzz()
{
ClientSize = new System.Drawing.Size(502, 293);
i = new ImageList();
i.Images.Add(new Bitmap("clsdfold.bmp"));
i.Images.Add(new Bitmap("openfold.bmp"));
d = new TreeView();
d.ImageList = (ImageList)i;
d.ForeColor = (Color)System.Drawing.SystemColors.WindowText;
d.Location = new System.Drawing.Point(24, 16);
d.AllowDrop = true;
d.Indent = 19;
d.Text = "treeView1";
d.SelectedImageIndex = 1;
d.Size = new System.Drawing.Size(200, 264);
d.AfterSelect += new TreeViewEventHandler(sss);
d.BeforeExpand += new TreeViewCancelEventHandler(eee);
Controls.Add(d);
string[] dr = Environment.GetLogicalDrives();
for (int ii = 0; ii < dr.Length; ii++)
{
if (PlatformInvokeKernel32.GetDriveType(dr[ii]) ==
PlatformInvokeKernel32.DRIVE_FIXED)
{
TreeNode c = new TreeNode(dr[ii]);
d.Nodes.Add(c);
ddd(c);
}
}
}
void ddd(TreeNode n)
{
DirectoryInfo dir = new DirectoryInfo(ppp(n));
DirectoryInfo[] e = dir.GetDirectories ();
for (int i = 0; i < e.Length; i++)
{
string na = e[i].Name;
if (!na.Equals(".") && !na.Equals(".."))
{
n.Nodes.Add(new TreeNode(na));
}
}
}
void sss(object source, TreeViewEventArgs e)
{
Text = "Windows.Forms File Explorer – " + e.Node.Text;
}
void eee(object source, TreeViewCancelEventArgs e)
{
TreeNode n = (TreeNode)e.Node;
for (int i = 0; i < n.Nodes.Count; i++)
{
ddd(n.Nodes[i]);
}
}
string ppp(TreeNode node)
{
if (node.Parent == null)
{
return node.Text;
}
return Path.Combine(ppp(node.Parent), node.Text);
}
[STAThread]
public static void Main(string[] args) {
Application.Run(new zzz());
}
}
public class PlatformInvokeKernel32
{
[DllImport("KERNEL32", CharSet=System.Runtime.InteropServices.CharSet.Auto)]
public static extern int GetDriveType(string lpRootPathName);
public const int DRIVE_FIXED = 3;
}

Copy the two bmp files clsdfold.bmp and openfold.bmp required for this program,
from the samples directory into your current directory.

Here, we first create a TreeView control called d. A TreeView displays a list of
items or nodes in a hierarchical manner. A node consists of a caption and a
bitmap; the bitmap is optional. The user can select a node and collapse it or
expand it by clicking on the plus or minus sign, displayed alongside,
respectively.

We have an ImageList control i that represents two images. We initialize the
ImageList property of the TreeView control to the Image List. Thus, the TreeView
can now use the images stored in the ImageList. The AllowDrop property
facilitates the use of the control for events and Drag and Drop operations.

The property Indent decides the indent in the pixels. The SelectedImageIndex
determines as to which picture is to be used from the ImageList when the user
selects an item in the control.
There are a large number of events that get triggered off, but we are capturing
only the following two:
• AfterSelect, that calls function sss
• BeforeExapnd, that calls functions eee.

The EventHandler functions use different delegate types.
The class Environment has a static function GetLogicalDrives that returns an
array of strings, which denotes the logical drives on our machine. If machine
has three drives, C:\, D:\and E:\, the for loop is repeated thrice.

Using the Platform invoke API, we can call any code in any dll. So, we first
call the external function GetDriveType and compare it with the value retrieved
for DRIVE_FIXED, which is 3 in this case.
If there are 3 fixed drives then the if statement is true for 3 of them,
resulting in the display of 3 nodes only. If you have only one fixed drive i.e.
C, you will see only one node on your screen.

Screen 4.64 Screen 4.65

A TreeNode object is created, which is used in the TreeView. The constructor is
passed the drive name to enable it to be displayed as a label for the node. A
TreeView is made up of Nodes. It has a property called Nodes, which is of type
TreeNodeCollection. Using the Add member of the collection, we add the tree
node. Thereafter, function ddd is called with this newly created and empty tree
node object.

Function ppp is called with an empty tree node. If the node has no parent, the
text associated with the node is returned. But if a parent exists, we use the
static function Combine, of the Path class, to combine the two strings together.
The Combine function calls the ppp function recursively.

To begin with, the value of ppp(n) is C:\. The object dir represents directories
in the C drive. To obtain all the directories present on the drive, we call
function GetDirectories, which returns an array of DirectoryInfo objects. The
Name member returns the name of the directory. If the return value is not a . or
.., we add the directory name to the list of Nodes.

In the AfterSelect event, function sss gets called. In this function, we change
the Text of the form to the node selected. This is possible because the node
label is passed as a parameter to TreeViewEventArgs. The function eee recovers
the current active node from the parameter passed to it. Using the Count
property, we calculate the number of nodes contained in the active node and
thereafter, iterate through each of these nodes. The same function ddd is called
with every node.

This is how we can display the sub-directories contained within directories and
the files displayed within the directories. Data is sent to the control, which
merely returns the same data in a tree like form. When we click on the first
plus (+) sign of C:\, the function ppp(n) returns the entire path name of each
directory in a recursive fashion.

Docking

a.cs
using System;
using System.Drawing;
using System.Windows.Forms;
public class zzz :Form {
Panel p1;
Panel p2;
GroupBox g;
Button b;
RadioButton r1;
RadioButton r2;
RadioButton r3;
RadioButton r4;
RadioButton r5;
RadioButton r6;
RadioButton rs;
Splitter s;
public zzz () {
g = new GroupBox();
rs = new RadioButton();
r5 = new RadioButton();
s = new Splitter();
b = new Button();
r6 = new RadioButton();
r4 = new RadioButton();
r1 = new RadioButton();
r3 = new RadioButton();
p1 = new Panel();
p2 = new Panel();
r2 = new RadioButton();
Location = new Point(100, 100);
SizeGripStyle = SizeGripStyle.Show;
ClientSize = new Size(448, 400);
g.Location = new Point(16, 152);
g.TabStop = false;
g.Text = "&Dock";
g.Size = new Size(88, 176);
s.BackColor = Color.Blue;
s.Dock = DockStyle.Right;
s.Location = new Point(325, 0);
s.Size = new Size(3, 400);
b.BackColor = SystemColors.Control;
b.FlatStyle = FlatStyle.Popup;
b.Anchor = AnchorStyles.None;
b.Text = "Demo Button";
rs.Text = "rs";
rs.Size = new Size(100, 23);
r5.Location = new Point(8, 120);
r5.Text = "&Right";
r5.Size = new Size(72, 24);
r5.Click += new System.EventHandler(abc);
r6.Location = new Point(8, 144);
r6.Text = "&Fill";
r6.Size = new Size(72, 24);
r6.Click += new System.EventHandler(abc);
r4.Location = new Point(8, 96);
r4.Text = "&Bottom";
r4.Size = new Size(72, 24);
r4.Click += new System.EventHandler(abc);
r1.Checked = true;
r1.Location = new Point(8, 24);
r1.Text = "&None";
r1.Size = new Size(72, 24);
r1.Click += new System.EventHandler(abc);
r3.Location = new Point(8, 72);
r3.Text = "&Left";
r3.Size = new Size(72, 24);
r3.Click += new System.EventHandler(abc);
p1.Text = "ButtonPanel";
p1.Size = new Size(325, 400);
p1.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
p1.Dock = DockStyle.Fill;
p1.BackColor = Color.Green;
p2.Location = new Point(328, 0);
p2.Text = "ControlsPanel";
p2.Size = new Size(120, 400);
p2.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
p2.Dock = DockStyle.Right;
r2.Location = new Point(8, 48);
r2.Text = "&Top";
r2.Click += new System.EventHandler(abc);
Controls.Add(p2);
Controls.Add(s);
Controls.Add(p1);
p1.Controls.Add(b);
p2.Controls.Add(g);
g.Controls.Add(r4);
g.Controls.Add(r3);
g.Controls.Add(r1);
g.Controls.Add(r5);
g.Controls.Add(r6);
g.Controls.Add(r2);
rs = r1;
aaa();
}
void aaa() {
if (rs == r1)
b.Dock = DockStyle.None;
else if (rs == r2)
b.Dock = DockStyle.Top;
else if (rs == r3)
b.Dock = DockStyle.Left;
else if (rs == r4)
b.Dock = DockStyle.Bottom;
else if (rs == r5)
b.Dock = DockStyle.Right;
else
b.Dock = DockStyle.Fill;
}
protected void abc(object s, EventArgs e)
{
rs = (RadioButton)s;
aaa();
}
public static void Main() {
Application.Run(new zzz());
}
}

This program may be generously proportioned, however it is very simple to
comprehend. We have created seven radio buttons, one GroupBox, two panels, one
splitter and one button. The SizeGripStyle property can have three values:
• Show: that always shows the sizing grip.
• Hide : that always hides the sizing grip.
• Auto : that shows and hides the sizing grip as necessary.

The sizing handle is always shown at the right hand corner of the form.

The button has a FlatStyle of Popup that determines the appearance of the
button. Clicking on any of the Radio Buttons results in a call to the function
abc. This is as a consequence of the Event property Click having been set to
abc. Next, we add all the controls to the Form. The repetitive code for adding
the controls results in a lengthy program.

Screen 4.66 Screen 4.67

The function abc gets called. Its first parameter is an object type. The object
stands for the control that calls the function. In function abc, the RadioButton
that was clicked on, is represented by s. The value contained in s is stored in
another RadioButton called rs. The function aaa is called thereafter. It
compares the value contained in rs with the 5 radio buttons r1 to r5. Depending
upon the value that matches, the Dock property of the button changes.

Screen 4.68 Screen 4.69

When a control is docked to the edge of a container, it will always take up a
position flush against the edge, if the control is resized.

The Left, Right, Top and Bottom styles position the control towards the
respective edge of the container. Fill will fill upto all the sides of the
control.

The control is resized to fill the container’s edges. The First dock style named
None, ensures that the control does not get docked at all.

December 17, 2007 - Posted by s web solution | The C# Language

No comments yet.

Web Designing Education

Web Designing Education